analytics/webcontent/bi/lib/mobx-state-tree/3.15.0/mobx-state-tree.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('mobx')) :
    typeof define === 'function' && define.amd ? define(['exports', 'mobx'], factory) :
    (global = global || self, factory(global.mobxStateTree = {}, global.mobx));
}(this, function (exports, mobx) { 'use strict';

    var livelinessChecking = "warn";
    /**
     * Defines what MST should do when running into reads / writes to objects that have died.
     * By default it will print a warning.
     * Use the `"error"` option to easy debugging to see where the error was thrown and when the offending read / write took place
     *
     * @param mode `"warn"`, `"error"` or `"ignore"`
     */
    function setLivelinessChecking(mode) {
        livelinessChecking = mode;
    }
    /**
     * Returns the current liveliness checking mode.
     *
     * @returns `"warn"`, `"error"` or `"ignore"`
     */
    function getLivelinessChecking() {
        return livelinessChecking;
    }
    /**
     * @deprecated use setLivelinessChecking instead
     * @hidden
     *
     * Defines what MST should do when running into reads / writes to objects that have died.
     * By default it will print a warning.
     * Use the `"error"` option to easy debugging to see where the error was thrown and when the offending read / write took place
     *
     * @param mode `"warn"`, `"error"` or `"ignore"`
     */
    function setLivelynessChecking(mode) {
        setLivelinessChecking(mode);
    }

    /**
     * @hidden
     */
    var Hook;
    (function (Hook) {
        Hook["afterCreate"] = "afterCreate";
        Hook["afterAttach"] = "afterAttach";
        Hook["afterCreationFinalization"] = "afterCreationFinalization";
        Hook["beforeDetach"] = "beforeDetach";
        Hook["beforeDestroy"] = "beforeDestroy";
    })(Hook || (Hook = {}));

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    function __rest(s, e) {
        var t = {};
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
            t[p] = s[p];
        if (s != null && typeof Object.getOwnPropertySymbols === "function")
            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                    t[p[i]] = s[p[i]];
            }
        return t;
    }

    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }

    function __values(o) {
        var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
        if (m) return m.call(o);
        return {
            next: function () {
                if (o && i >= o.length) o = void 0;
                return { value: o && o[i++], done: !o };
            }
        };
    }

    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m) return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
        }
        catch (error) { e = { error: error }; }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) m.call(i);
            }
            finally { if (e) throw e.error; }
        }
        return ar;
    }

    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }

    /**
     * Returns the _actual_ type of the given tree node. (Or throws)
     *
     * @param object
     * @returns
     */
    function getType(object) {
        assertIsStateTreeNode(object, 1);
        return getStateTreeNode(object).type;
    }
    /**
     * Returns the _declared_ type of the given sub property of an object, array or map.
     * In the case of arrays and maps the property name is optional and will be ignored.
     *
     * Example:
     * ```ts
     * const Box = types.model({ x: 0, y: 0 })
     * const box = Box.create()
     *
     * console.log(getChildType(box, "x").name) // 'number'
     * ```
     *
     * @param object
     * @param propertyName
     * @returns
     */
    function getChildType(object, propertyName) {
        assertIsStateTreeNode(object, 1);
        return getStateTreeNode(object).getChildType(propertyName);
    }
    /**
     * Registers a function that will be invoked for each mutation that is applied to the provided model instance, or to any of its children.
     * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details. onPatch events are emitted immediately and will not await the end of a transaction.
     * Patches can be used to deep observe a model tree.
     *
     * @param target the model instance from which to receive patches
     * @param callback the callback that is invoked for each patch. The reversePatch is a patch that would actually undo the emitted patch
     * @returns function to remove the listener
     */
    function onPatch(target, callback) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsFunction(callback, 2);
        return getStateTreeNode(target).onPatch(callback);
    }
    /**
     * Registers a function that is invoked whenever a new snapshot for the given model instance is available.
     * The listener will only be fire at the end of the current MobX (trans)action.
     * See [snapshots](https://github.com/mobxjs/mobx-state-tree#snapshots) for more details.
     *
     * @param target
     * @param callback
     * @returns
     */
    function onSnapshot(target, callback) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsFunction(callback, 2);
        return getStateTreeNode(target).onSnapshot(callback);
    }
    /**
     * Applies a JSON-patch to the given model instance or bails out if the patch couldn't be applied
     * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details.
     *
     * Can apply a single past, or an array of patches.
     *
     * @param target
     * @param patch
     * @returns
     */
    function applyPatch(target, patch) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertArg(patch, function (p) { return typeof p === "object"; }, "object or array", 2);
        getStateTreeNode(target).applyPatches(asArray(patch));
    }
    /**
     * Small abstraction around `onPatch` and `applyPatch`, attaches a patch listener to a tree and records all the patches.
     * Returns an recorder object with the following signature:
     *
     * Example:
     * ```ts
     * export interface IPatchRecorder {
     *      // the recorded patches
     *      patches: IJsonPatch[]
     *      // the inverse of the recorded patches
     *      inversePatches: IJsonPatch[]
     *      // true if currently recording
     *      recording: boolean
     *      // stop recording patches
     *      stop(): void
     *      // resume recording patches
     *      resume(): void
     *      // apply all the recorded patches on the given target (the original subject if omitted)
     *      replay(target?: IAnyStateTreeNode): void
     *      // reverse apply the recorded patches on the given target  (the original subject if omitted)
     *      // stops the recorder if not already stopped
     *      undo(): void
     * }
     * ```
     *
     * The optional filter function allows to skip recording certain patches.
     *
     * @param subject
     * @param filter
     * @returns
     */
    function recordPatches(subject, filter) {
        // check all arguments
        assertIsStateTreeNode(subject, 1);
        var data = {
            patches: [],
            reversedInversePatches: []
        };
        // we will generate the immutable copy of patches on demand for public consumption
        var publicData = {};
        var disposer;
        var recorder = {
            get recording() {
                return !!disposer;
            },
            get patches() {
                if (!publicData.patches) {
                    publicData.patches = data.patches.slice();
                }
                return publicData.patches;
            },
            get reversedInversePatches() {
                if (!publicData.reversedInversePatches) {
                    publicData.reversedInversePatches = data.reversedInversePatches.slice();
                }
                return publicData.reversedInversePatches;
            },
            get inversePatches() {
                if (!publicData.inversePatches) {
                    publicData.inversePatches = data.reversedInversePatches.slice().reverse();
                }
                return publicData.inversePatches;
            },
            stop: function () {
                if (disposer) {
                    disposer();
                    disposer = undefined;
                }
            },
            resume: function () {
                if (disposer)
                    return;
                disposer = onPatch(subject, function (patch, inversePatch) {
                    // skip patches that are asked to be filtered if there's a filter in place
                    if (filter && !filter(patch, inversePatch, getRunningActionContext())) {
                        return;
                    }
                    data.patches.push(patch);
                    data.reversedInversePatches.unshift(inversePatch);
                    // mark immutable public patches as dirty
                    publicData.patches = undefined;
                    publicData.inversePatches = undefined;
                    publicData.reversedInversePatches = undefined;
                });
            },
            replay: function (target) {
                applyPatch(target || subject, data.patches);
            },
            undo: function (target) {
                applyPatch(target || subject, data.reversedInversePatches);
            }
        };
        recorder.resume();
        return recorder;
    }
    /**
     * The inverse of `unprotect`.
     *
     * @param target
     */
    function protect(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        var node = getStateTreeNode(target);
        if (!node.isRoot)
            throw fail$1("`protect` can only be invoked on root nodes");
        node.isProtectionEnabled = true;
    }
    /**
     * By default it is not allowed to directly modify a model. Models can only be modified through actions.
     * However, in some cases you don't care about the advantages (like replayability, traceability, etc) this yields.
     * For example because you are building a PoC or don't have any middleware attached to your tree.
     *
     * In that case you can disable this protection by calling `unprotect` on the root of your tree.
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *     done: false
     * }).actions(self => ({
     *     toggle() {
     *         self.done = !self.done
     *     }
     * }))
     *
     * const todo = Todo.create()
     * todo.done = true // throws!
     * todo.toggle() // OK
     * unprotect(todo)
     * todo.done = false // OK
     * ```
     */
    function unprotect(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        var node = getStateTreeNode(target);
        if (!node.isRoot)
            throw fail$1("`unprotect` can only be invoked on root nodes");
        node.isProtectionEnabled = false;
    }
    /**
     * Returns true if the object is in protected mode, @see protect
     */
    function isProtected(target) {
        return getStateTreeNode(target).isProtected;
    }
    /**
     * Applies a snapshot to a given model instances. Patch and snapshot listeners will be invoked as usual.
     *
     * @param target
     * @param snapshot
     * @returns
     */
    function applySnapshot(target, snapshot) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).applySnapshot(snapshot);
    }
    /**
     * Calculates a snapshot from the given model instance. The snapshot will always reflect the latest state but use
     * structural sharing where possible. Doesn't require MobX transactions to be completed.
     *
     * @param target
     * @param applyPostProcess If true (the default) then postProcessSnapshot gets applied.
     * @returns
     */
    function getSnapshot(target, applyPostProcess) {
        if (applyPostProcess === void 0) { applyPostProcess = true; }
        // check all arguments
        assertIsStateTreeNode(target, 1);
        var node = getStateTreeNode(target);
        if (applyPostProcess)
            return node.snapshot;
        return freeze(node.type.getSnapshot(node, false));
    }
    /**
     * Given a model instance, returns `true` if the object has a parent, that is, is part of another object, map or array.
     *
     * @param target
     * @param depth How far should we look upward? 1 by default.
     * @returns
     */
    function hasParent(target, depth) {
        if (depth === void 0) { depth = 1; }
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsNumber(depth, 2, 0);
        var parent = getStateTreeNode(target).parent;
        while (parent) {
            if (--depth === 0)
                return true;
            parent = parent.parent;
        }
        return false;
    }
    /**
     * Returns the immediate parent of this object, or throws.
     *
     * Note that the immediate parent can be either an object, map or array, and
     * doesn't necessarily refer to the parent model.
     *
     * Please note that in child nodes access to the root is only possible
     * once the `afterAttach` hook has fired.
     *
     * @param target
     * @param depth How far should we look upward? 1 by default.
     * @returns
     */
    function getParent(target, depth) {
        if (depth === void 0) { depth = 1; }
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsNumber(depth, 2, 0);
        var d = depth;
        var parent = getStateTreeNode(target).parent;
        while (parent) {
            if (--d === 0)
                return parent.storedValue;
            parent = parent.parent;
        }
        throw fail$1("Failed to find the parent of " + getStateTreeNode(target) + " at depth " + depth);
    }
    /**
     * Given a model instance, returns `true` if the object has a parent of given type, that is, is part of another object, map or array
     *
     * @param target
     * @param type
     * @returns
     */
    function hasParentOfType(target, type) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsType(type, 2);
        var parent = getStateTreeNode(target).parent;
        while (parent) {
            if (type.is(parent.storedValue))
                return true;
            parent = parent.parent;
        }
        return false;
    }
    /**
     * Returns the target's parent of a given type, or throws.
     *
     * @param target
     * @param type
     * @returns
     */
    function getParentOfType(target, type) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsType(type, 2);
        var parent = getStateTreeNode(target).parent;
        while (parent) {
            if (type.is(parent.storedValue))
                return parent.storedValue;
            parent = parent.parent;
        }
        throw fail$1("Failed to find the parent of " + getStateTreeNode(target) + " of a given type");
    }
    /**
     * Given an object in a model tree, returns the root object of that tree.
     *
     * Please note that in child nodes access to the root is only possible
     * once the `afterAttach` hook has fired.
     *
     * @param target
     * @returns
     */
    function getRoot(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).root.storedValue;
    }
    /**
     * Returns the path of the given object in the model tree
     *
     * @param target
     * @returns
     */
    function getPath(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).path;
    }
    /**
     * Returns the path of the given object as unescaped string array.
     *
     * @param target
     * @returns
     */
    function getPathParts(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return splitJsonPath(getStateTreeNode(target).path);
    }
    /**
     * Returns true if the given object is the root of a model tree.
     *
     * @param target
     * @returns
     */
    function isRoot(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).isRoot;
    }
    /**
     * Resolves a path relatively to a given object.
     * Returns undefined if no value can be found.
     *
     * @param target
     * @param path escaped json path
     * @returns
     */
    function resolvePath(target, path) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsString(path, 2);
        var node = resolveNodeByPath(getStateTreeNode(target), path);
        return node ? node.value : undefined;
    }
    /**
     * Resolves a model instance given a root target, the type and the identifier you are searching for.
     * Returns undefined if no value can be found.
     *
     * @param type
     * @param target
     * @param identifier
     * @returns
     */
    function resolveIdentifier(type, target, identifier) {
        // check all arguments
        assertIsType(type, 1);
        assertIsStateTreeNode(target, 2);
        assertIsValidIdentifier(identifier, 3);
        var node = getStateTreeNode(target).root.identifierCache.resolve(type, normalizeIdentifier(identifier));
        return node ? node.value : undefined;
    }
    /**
     * Returns the identifier of the target node.
     * This is the *string normalized* identifier, which might not match the type of the identifier attribute
     *
     * @param target
     * @returns
     */
    function getIdentifier(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).identifier;
    }
    /**
     * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes,
     * else it returns undefined.
     *
     * @param getter Function to access the reference.
     * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
     * @returns
     */
    function tryReference(getter, checkIfAlive) {
        if (checkIfAlive === void 0) { checkIfAlive = true; }
        try {
            var node = getter();
            if (node === undefined || node === null) {
                return undefined;
            }
            else if (isStateTreeNode(node)) {
                if (!checkIfAlive) {
                    return node;
                }
                else {
                    return isAlive(node) ? node : undefined;
                }
            }
            else {
                throw fail$1("The reference to be checked is not one of node, null or undefined");
            }
        }
        catch (e) {
            if (e instanceof InvalidReferenceError) {
                return undefined;
            }
            throw e;
        }
    }
    /**
     * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns if the check passes or not.
     *
     * @param getter Function to access the reference.
     * @param checkIfAlive true to also make sure the referenced node is alive (default), false to skip this check.
     * @returns
     */
    function isValidReference(getter, checkIfAlive) {
        if (checkIfAlive === void 0) { checkIfAlive = true; }
        try {
            var node = getter();
            if (node === undefined || node === null) {
                return false;
            }
            else if (isStateTreeNode(node)) {
                return checkIfAlive ? isAlive(node) : true;
            }
            else {
                throw fail$1("The reference to be checked is not one of node, null or undefined");
            }
        }
        catch (e) {
            if (e instanceof InvalidReferenceError) {
                return false;
            }
            throw e;
        }
    }
    /**
     * Try to resolve a given path relative to a given node.
     *
     * @param target
     * @param path
     * @returns
     */
    function tryResolve(target, path) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsString(path, 2);
        var node = resolveNodeByPath(getStateTreeNode(target), path, false);
        if (node === undefined)
            return undefined;
        try {
            return node.value;
        }
        catch (e) {
            // For what ever reason not resolvable (e.g. totally not existing path, or value that cannot be fetched)
            // see test / issue: 'try resolve doesn't work #686'
            return undefined;
        }
    }
    /**
     * Given two state tree nodes that are part of the same tree,
     * returns the shortest jsonpath needed to navigate from the one to the other
     *
     * @param base
     * @param target
     * @returns
     */
    function getRelativePath(base, target) {
        // check all arguments
        assertIsStateTreeNode(base, 1);
        assertIsStateTreeNode(target, 2);
        return getRelativePathBetweenNodes(getStateTreeNode(base), getStateTreeNode(target));
    }
    /**
     * Returns a deep copy of the given state tree node as new tree.
     * Short hand for `snapshot(x) = getType(x).create(getSnapshot(x))`
     *
     * _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_
     *
     * @param source
     * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
     * @returns
     */
    function clone(source, keepEnvironment) {
        if (keepEnvironment === void 0) { keepEnvironment = true; }
        // check all arguments
        assertIsStateTreeNode(source, 1);
        var node = getStateTreeNode(source);
        return node.type.create(node.snapshot, keepEnvironment === true
            ? node.root.environment
            : keepEnvironment === false
                ? undefined
                : keepEnvironment); // it's an object or something else
    }
    /**
     * Removes a model element from the state tree, and let it live on as a new state tree
     */
    function detach(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        getStateTreeNode(target).detach();
        return target;
    }
    /**
     * Removes a model element from the state tree, and mark it as end-of-life; the element should not be used anymore
     */
    function destroy(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        var node = getStateTreeNode(target);
        if (node.isRoot)
            node.die();
        else
            node.parent.removeChild(node.subpath);
    }
    /**
     * Returns true if the given state tree node is not killed yet.
     * This means that the node is still a part of a tree, and that `destroy`
     * has not been called. If a node is not alive anymore, the only thing one can do with it
     * is requesting it's last path and snapshot
     *
     * @param target
     * @returns
     */
    function isAlive(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).observableIsAlive;
    }
    /**
     * Use this utility to register a function that should be called whenever the
     * targeted state tree node is destroyed. This is a useful alternative to managing
     * cleanup methods yourself using the `beforeDestroy` hook.
     *
     * This methods returns the same disposer that was passed as argument.
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *   title: types.string
     * }).actions(self => ({
     *   afterCreate() {
     *     const autoSaveDisposer = reaction(
     *       () => getSnapshot(self),
     *       snapshot => sendSnapshotToServerSomehow(snapshot)
     *     )
     *     // stop sending updates to server if this
     *     // instance is destroyed
     *     addDisposer(self, autoSaveDisposer)
     *   }
     * }))
     * ```
     *
     * @param target
     * @param disposer
     * @returns The same disposer that was passed as argument
     */
    function addDisposer(target, disposer) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsFunction(disposer, 2);
        var node = getStateTreeNode(target);
        node.addDisposer(disposer);
        return disposer;
    }
    /**
     * Returns the environment of the current state tree. For more info on environments,
     * see [Dependency injection](https://github.com/mobxjs/mobx-state-tree#dependency-injection)
     *
     * Please note that in child nodes access to the root is only possible
     * once the `afterAttach` hook has fired
     *
     * Returns an empty environment if the tree wasn't initialized with an environment
     *
     * @param target
     * @returns
     */
    function getEnv(target) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        var node = getStateTreeNode(target);
        var env = node.root.environment;
        if (!env)
            return EMPTY_OBJECT;
        return env;
    }
    /**
     * Performs a depth first walk through a tree.
     */
    function walk(target, processor) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertIsFunction(processor, 2);
        var node = getStateTreeNode(target);
        // tslint:disable-next-line:no_unused-variable
        node.getChildren().forEach(function (child) {
            if (isStateTreeNode(child.storedValue))
                walk(child.storedValue, processor);
        });
        processor(node.storedValue);
    }
    /**
     * Returns a reflection of the model type properties and name for either a model type or model node.
     *
     * @param typeOrNode
     * @returns
     */
    function getPropertyMembers(typeOrNode) {
        var type;
        if (isStateTreeNode(typeOrNode)) {
            type = getType(typeOrNode);
        }
        else {
            type = typeOrNode;
        }
        assertArg(type, function (t) { return isModelType(t); }, "model type or model instance", 1);
        return {
            name: type.name,
            properties: __assign({}, type.properties)
        };
    }
    /**
     * Returns a reflection of the model node, including name, properties, views, volatile and actions.
     *
     * @param target
     * @returns
     */
    function getMembers(target) {
        var type = getStateTreeNode(target).type;
        var reflected = __assign(__assign({}, getPropertyMembers(type)), { actions: [], volatile: [], views: [] });
        var props = Object.getOwnPropertyNames(target);
        props.forEach(function (key) {
            if (key in reflected.properties)
                return;
            var descriptor = Object.getOwnPropertyDescriptor(target, key);
            if (descriptor.get) {
                if (mobx.isComputedProp(target, key))
                    reflected.views.push(key);
                else
                    reflected.volatile.push(key);
                return;
            }
            if (descriptor.value._isMSTAction === true)
                reflected.actions.push(key);
            else if (mobx.isObservableProp(target, key))
                reflected.volatile.push(key);
            else
                reflected.views.push(key);
        });
        return reflected;
    }
    /**
     * Casts a node snapshot or instance type to an instance type so it can be assigned to a type instance.
     * Note that this is just a cast for the type system, this is, it won't actually convert a snapshot to an instance,
     * but just fool typescript into thinking so.
     * Either way, casting when outside an assignation operation won't compile.
     *
     * Example:
     * ```ts
     * const ModelA = types.model({
     *   n: types.number
     * }).actions(self => ({
     *   setN(aNumber: number) {
     *     self.n = aNumber
     *   }
     * }))
     *
     * const ModelB = types.model({
     *   innerModel: ModelA
     * }).actions(self => ({
     *   someAction() {
     *     // this will allow the compiler to assign a snapshot to the property
     *     self.innerModel = cast({ a: 5 })
     *   }
     * }))
     * ```
     *
     * @param snapshotOrInstance Snapshot or instance
     * @returns The same object casted as an instance
     */
    function cast(snapshotOrInstance) {
        return snapshotOrInstance;
    }
    /**
     * Casts a node instance type to an snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
     * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a snapshot,
     * but just fool typescript into thinking so.
     *
     * Example:
     * ```ts
     * const ModelA = types.model({
     *   n: types.number
     * }).actions(self => ({
     *   setN(aNumber: number) {
     *     self.n = aNumber
     *   }
     * }))
     *
     * const ModelB = types.model({
     *   innerModel: ModelA
     * })
     *
     * const a = ModelA.create({ n: 5 });
     * // this will allow the compiler to use a model as if it were a snapshot
     * const b = ModelB.create({ innerModel: castToSnapshot(a)})
     * ```
     *
     * @param snapshotOrInstance Snapshot or instance
     * @returns The same object casted as an input (creation) snapshot
     */
    function castToSnapshot(snapshotOrInstance) {
        return snapshotOrInstance;
    }
    /**
     * Casts a node instance type to a reference snapshot type so it can be assigned to a refernence snapshot (e.g. to be used inside a create call).
     * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a refererence snapshot,
     * but just fool typescript into thinking so.
     *
     * Example:
     * ```ts
     * const ModelA = types.model({
     *   id: types.identifier,
     *   n: types.number
     * }).actions(self => ({
     *   setN(aNumber: number) {
     *     self.n = aNumber
     *   }
     * }))
     *
     * const ModelB = types.model({
     *   refA: types.reference(ModelA)
     * })
     *
     * const a = ModelA.create({ id: 'someId', n: 5 });
     * // this will allow the compiler to use a model as if it were a reference snapshot
     * const b = ModelB.create({ refA: castToReference(a)})
     * ```
     *
     * @param instance Instance
     * @returns The same object casted as an reference snapshot (string or number)
     */
    function castToReferenceSnapshot(instance) {
        return instance;
    }
    /**
     * Returns the unique node id (not to be confused with the instance identifier) for a
     * given instance.
     * This id is a number that is unique for each instance.
     *
     * @export
     * @param target
     * @returns
     */
    function getNodeId(target) {
        assertIsStateTreeNode(target, 1);
        return getStateTreeNode(target).nodeId;
    }

    /**
     * @internal
     * @hidden
     */
    var BaseNode = /** @class */ (function () {
        function BaseNode(type, parent, subpath, environment) {
            this.type = type;
            this.environment = environment;
            this._state = NodeLifeCycle.INITIALIZING;
            this.environment = environment;
            this.baseSetParent(parent, subpath);
        }
        Object.defineProperty(BaseNode.prototype, "subpath", {
            get: function () {
                return this._subpath;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "subpathUponDeath", {
            get: function () {
                return this._subpathUponDeath;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "pathUponDeath", {
            get: function () {
                return this._pathUponDeath;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "value", {
            get: function () {
                return this.type.getValue(this);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "state", {
            get: function () {
                return this._state;
            },
            set: function (val) {
                var wasAlive = this.isAlive;
                this._state = val;
                var isAlive = this.isAlive;
                if (this.aliveAtom && wasAlive !== isAlive) {
                    this.aliveAtom.reportChanged();
                }
            },
            enumerable: true,
            configurable: true
        });
        BaseNode.prototype.fireInternalHook = function (name) {
            if (this._hookSubscribers) {
                this._hookSubscribers.emit(name, this, name);
            }
        };
        BaseNode.prototype.registerHook = function (hook, hookHandler) {
            if (!this._hookSubscribers) {
                this._hookSubscribers = new EventHandlers();
            }
            return this._hookSubscribers.register(hook, hookHandler);
        };
        Object.defineProperty(BaseNode.prototype, "parent", {
            get: function () {
                return this._parent;
            },
            enumerable: true,
            configurable: true
        });
        BaseNode.prototype.baseSetParent = function (parent, subpath) {
            this._parent = parent;
            this._subpath = subpath;
            this._escapedSubpath = undefined; // regenerate when needed
            if (this.pathAtom) {
                this.pathAtom.reportChanged();
            }
        };
        Object.defineProperty(BaseNode.prototype, "path", {
            /*
             * Returns (escaped) path representation as string
             */
            get: function () {
                return this.getEscapedPath(true);
            },
            enumerable: true,
            configurable: true
        });
        BaseNode.prototype.getEscapedPath = function (reportObserved) {
            if (reportObserved) {
                if (!this.pathAtom) {
                    this.pathAtom = mobx.createAtom("path");
                }
                this.pathAtom.reportObserved();
            }
            if (!this.parent)
                return "";
            // regenerate escaped subpath if needed
            if (this._escapedSubpath === undefined) {
                this._escapedSubpath = !this._subpath ? "" : escapeJsonPath(this._subpath);
            }
            return this.parent.getEscapedPath(reportObserved) + "/" + this._escapedSubpath;
        };
        Object.defineProperty(BaseNode.prototype, "isRoot", {
            get: function () {
                return this.parent === null;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "isAlive", {
            get: function () {
                return this.state !== NodeLifeCycle.DEAD;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "isDetaching", {
            get: function () {
                return this.state === NodeLifeCycle.DETACHING;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseNode.prototype, "observableIsAlive", {
            get: function () {
                if (!this.aliveAtom) {
                    this.aliveAtom = mobx.createAtom("alive");
                }
                this.aliveAtom.reportObserved();
                return this.isAlive;
            },
            enumerable: true,
            configurable: true
        });
        BaseNode.prototype.baseFinalizeCreation = function (whenFinalized) {
            {
                if (!this.isAlive) {
                    // istanbul ignore next
                    throw fail("assertion failed: cannot finalize the creation of a node that is already dead");
                }
            }
            // goal: afterCreate hooks runs depth-first. After attach runs parent first, so on afterAttach the parent has completed already
            if (this.state === NodeLifeCycle.CREATED) {
                if (this.parent) {
                    if (this.parent.state !== NodeLifeCycle.FINALIZED) {
                        // parent not ready yet, postpone
                        return;
                    }
                    this.fireHook(Hook.afterAttach);
                }
                this.state = NodeLifeCycle.FINALIZED;
                if (whenFinalized) {
                    whenFinalized();
                }
            }
        };
        BaseNode.prototype.baseFinalizeDeath = function () {
            if (this._hookSubscribers) {
                this._hookSubscribers.clearAll();
            }
            this._subpathUponDeath = this._subpath;
            this._pathUponDeath = this.getEscapedPath(false);
            this.baseSetParent(null, "");
            this.state = NodeLifeCycle.DEAD;
        };
        BaseNode.prototype.baseAboutToDie = function () {
            this.fireHook(Hook.beforeDestroy);
        };
        return BaseNode;
    }());

    /**
     * @internal
     * @hidden
     */
    var ScalarNode = /** @class */ (function (_super) {
        __extends(ScalarNode, _super);
        function ScalarNode(simpleType, parent, subpath, environment, initialSnapshot) {
            var _this = _super.call(this, simpleType, parent, subpath, environment) || this;
            try {
                _this.storedValue = simpleType.createNewInstance(initialSnapshot);
            }
            catch (e) {
                // short-cut to die the instance, to avoid the snapshot computed starting to throw...
                _this.state = NodeLifeCycle.DEAD;
                throw e;
            }
            _this.state = NodeLifeCycle.CREATED;
            // for scalar nodes there's no point in firing this event since it would fire on the constructor, before
            // anybody can actually register for/listen to it
            // this.fireHook(Hook.AfterCreate)
            _this.finalizeCreation();
            return _this;
        }
        Object.defineProperty(ScalarNode.prototype, "root", {
            get: function () {
                // future optimization: store root ref in the node and maintain it
                if (!this.parent)
                    throw fail$1("This scalar node is not part of a tree");
                return this.parent.root;
            },
            enumerable: true,
            configurable: true
        });
        ScalarNode.prototype.setParent = function (newParent, subpath) {
            var parentChanged = this.parent !== newParent;
            var subpathChanged = this.subpath !== subpath;
            if (!parentChanged && !subpathChanged) {
                return;
            }
            {
                if (!subpath) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: subpath expected");
                }
                if (!newParent) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: parent expected");
                }
                if (parentChanged) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: scalar nodes cannot change their parent");
                }
            }
            this.environment = undefined; // use parent's
            this.baseSetParent(this.parent, subpath);
        };
        Object.defineProperty(ScalarNode.prototype, "snapshot", {
            get: function () {
                return freeze(this.getSnapshot());
            },
            enumerable: true,
            configurable: true
        });
        ScalarNode.prototype.getSnapshot = function () {
            return this.type.getSnapshot(this);
        };
        ScalarNode.prototype.toString = function () {
            var path = (this.isAlive ? this.path : this.pathUponDeath) || "<root>";
            return this.type.name + "@" + path + (this.isAlive ? "" : " [dead]");
        };
        ScalarNode.prototype.die = function () {
            if (!this.isAlive || this.state === NodeLifeCycle.DETACHING)
                return;
            this.aboutToDie();
            this.finalizeDeath();
        };
        ScalarNode.prototype.finalizeCreation = function () {
            this.baseFinalizeCreation();
        };
        ScalarNode.prototype.aboutToDie = function () {
            this.baseAboutToDie();
        };
        ScalarNode.prototype.finalizeDeath = function () {
            this.baseFinalizeDeath();
        };
        ScalarNode.prototype.fireHook = function (name) {
            this.fireInternalHook(name);
        };
        __decorate([
            mobx.action
        ], ScalarNode.prototype, "die", null);
        return ScalarNode;
    }(BaseNode));

    var nextNodeId = 1;
    var snapshotReactionOptions = {
        onError: function (e) {
            throw e;
        }
    };
    /**
     * @internal
     * @hidden
     */
    var ObjectNode = /** @class */ (function (_super) {
        __extends(ObjectNode, _super);
        function ObjectNode(complexType, parent, subpath, environment, initialValue) {
            var _this = _super.call(this, complexType, parent, subpath, environment) || this;
            _this.nodeId = ++nextNodeId;
            _this.isProtectionEnabled = true;
            _this._autoUnbox = true; // unboxing is disabled when reading child nodes
            _this._isRunningAction = false; // only relevant for root
            _this._hasSnapshotReaction = false;
            _this._observableInstanceState = 0 /* UNINITIALIZED */;
            _this._cachedInitialSnapshotCreated = false;
            _this.unbox = _this.unbox.bind(_this);
            _this._initialSnapshot = freeze(initialValue);
            _this.identifierAttribute = complexType.identifierAttribute;
            if (!parent) {
                _this.identifierCache = new IdentifierCache();
            }
            _this._childNodes = complexType.initializeChildNodes(_this, _this._initialSnapshot);
            // identifier can not be changed during lifecycle of a node
            // so we safely can read it from initial snapshot
            _this.identifier = null;
            _this.unnormalizedIdentifier = null;
            if (_this.identifierAttribute && _this._initialSnapshot) {
                var id = _this._initialSnapshot[_this.identifierAttribute];
                if (id === undefined) {
                    // try with the actual node if not (for optional identifiers)
                    var childNode = _this._childNodes[_this.identifierAttribute];
                    if (childNode) {
                        id = childNode.value;
                    }
                }
                if (typeof id !== "string" && typeof id !== "number") {
                    throw fail$1("Instance identifier '" + _this.identifierAttribute + "' for type '" + _this.type.name + "' must be a string or a number");
                }
                // normalize internal identifier to string
                _this.identifier = normalizeIdentifier(id);
                _this.unnormalizedIdentifier = id;
            }
            if (!parent) {
                _this.identifierCache.addNodeToCache(_this);
            }
            else {
                parent.root.identifierCache.addNodeToCache(_this);
            }
            return _this;
        }
        ObjectNode.prototype.applyPatches = function (patches) {
            this.createObservableInstanceIfNeeded();
            this._applyPatches(patches);
        };
        ObjectNode.prototype.applySnapshot = function (snapshot) {
            this.createObservableInstanceIfNeeded();
            this._applySnapshot(snapshot);
        };
        ObjectNode.prototype.createObservableInstanceIfNeeded = function () {
            var e_1, _a;
            if (this._observableInstanceState !== 0 /* UNINITIALIZED */) {
                return;
            }
            {
                if (this.state !== NodeLifeCycle.INITIALIZING) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: the creation of the observable instance must be done on the initializing phase");
                }
            }
            this._observableInstanceState = 1 /* CREATING */;
            // make sure the parent chain is created as well
            // array with parent chain from parent to child
            var parentChain = [];
            var parent = this.parent;
            // for performance reasons we never go back further than the most direct
            // uninitialized parent
            // this is done to avoid traversing the whole tree to the root when using
            // the same reference again
            while (parent &&
                parent._observableInstanceState === 0 /* UNINITIALIZED */) {
                parentChain.unshift(parent);
                parent = parent.parent;
            }
            try {
                // initialize the uninitialized parent chain from parent to child
                for (var parentChain_1 = __values(parentChain), parentChain_1_1 = parentChain_1.next(); !parentChain_1_1.done; parentChain_1_1 = parentChain_1.next()) {
                    var p = parentChain_1_1.value;
                    p.createObservableInstanceIfNeeded();
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (parentChain_1_1 && !parentChain_1_1.done && (_a = parentChain_1.return)) _a.call(parentChain_1);
                }
                finally { if (e_1) throw e_1.error; }
            }
            var type = this.type;
            try {
                this.storedValue = type.createNewInstance(this._childNodes);
                this.preboot();
                this._isRunningAction = true;
                type.finalizeNewInstance(this, this.storedValue);
            }
            catch (e) {
                // short-cut to die the instance, to avoid the snapshot computed starting to throw...
                this.state = NodeLifeCycle.DEAD;
                throw e;
            }
            finally {
                this._isRunningAction = false;
            }
            this._observableInstanceState = 2 /* CREATED */;
            // NOTE: we need to touch snapshot, because non-observable
            // "_observableInstanceState" field was touched
            invalidateComputed(this, "snapshot");
            if (this.isRoot)
                this._addSnapshotReaction();
            this._childNodes = EMPTY_OBJECT;
            this.state = NodeLifeCycle.CREATED;
            this.fireHook(Hook.afterCreate);
            this.finalizeCreation();
        };
        Object.defineProperty(ObjectNode.prototype, "root", {
            get: function () {
                var parent = this.parent;
                return parent ? parent.root : this;
            },
            enumerable: true,
            configurable: true
        });
        ObjectNode.prototype.clearParent = function () {
            if (!this.parent)
                return;
            // detach if attached
            this.fireHook(Hook.beforeDetach);
            var previousState = this.state;
            this.state = NodeLifeCycle.DETACHING;
            var root = this.root;
            var newEnv = root.environment;
            var newIdCache = root.identifierCache.splitCache(this);
            try {
                this.parent.removeChild(this.subpath);
                this.baseSetParent(null, "");
                this.environment = newEnv;
                this.identifierCache = newIdCache;
            }
            finally {
                this.state = previousState;
            }
        };
        ObjectNode.prototype.setParent = function (newParent, subpath) {
            var parentChanged = newParent !== this.parent;
            var subpathChanged = subpath !== this.subpath;
            if (!parentChanged && !subpathChanged) {
                return;
            }
            {
                if (!subpath) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: subpath expected");
                }
                if (!newParent) {
                    // istanbul ignore next
                    throw fail$1("assertion failed: new parent expected");
                }
                if (this.parent && parentChanged) {
                    throw fail$1("A node cannot exists twice in the state tree. Failed to add " + this + " to path '" + newParent.path + "/" + subpath + "'.");
                }
                if (!this.parent && newParent.root === this) {
                    throw fail$1("A state tree is not allowed to contain itself. Cannot assign " + this + " to path '" + newParent.path + "/" + subpath + "'");
                }
                if (!this.parent &&
                    !!this.environment &&
                    this.environment !== newParent.root.environment) {
                    throw fail$1("A state tree cannot be made part of another state tree as long as their environments are different.");
                }
            }
            if (parentChanged) {
                // attach to new parent
                this.environment = undefined; // will use root's
                newParent.root.identifierCache.mergeCache(this);
                this.baseSetParent(newParent, subpath);
                this.fireHook(Hook.afterAttach);
            }
            else if (subpathChanged) {
                // moving to a new subpath on the same parent
                this.baseSetParent(this.parent, subpath);
            }
        };
        ObjectNode.prototype.fireHook = function (name) {
            var _this = this;
            this.fireInternalHook(name);
            var fn = this.storedValue &&
                typeof this.storedValue === "object" &&
                this.storedValue[name];
            if (typeof fn === "function") {
                // we check for it to allow old mobx peer dependencies that don't have the method to work (even when still bugged)
                if (mobx._allowStateChangesInsideComputed) {
                    mobx._allowStateChangesInsideComputed(function () {
                        fn.apply(_this.storedValue);
                    });
                }
                else {
                    fn.apply(this.storedValue);
                }
            }
        };
        Object.defineProperty(ObjectNode.prototype, "snapshot", {
            // advantage of using computed for a snapshot is that nicely respects transactions etc.
            get: function () {
                return freeze(this.getSnapshot());
            },
            enumerable: true,
            configurable: true
        });
        // NOTE: we use this method to get snapshot without creating @computed overhead
        ObjectNode.prototype.getSnapshot = function () {
            if (!this.isAlive)
                return this._snapshotUponDeath;
            return this._observableInstanceState === 2 /* CREATED */
                ? this._getActualSnapshot()
                : this._getCachedInitialSnapshot();
        };
        ObjectNode.prototype._getActualSnapshot = function () {
            return this.type.getSnapshot(this);
        };
        ObjectNode.prototype._getCachedInitialSnapshot = function () {
            if (!this._cachedInitialSnapshotCreated) {
                var type = this.type;
                var childNodes = this._childNodes;
                var snapshot = this._initialSnapshot;
                this._cachedInitialSnapshot = type.processInitialSnapshot(childNodes, snapshot);
                this._cachedInitialSnapshotCreated = true;
            }
            return this._cachedInitialSnapshot;
        };
        ObjectNode.prototype.isRunningAction = function () {
            if (this._isRunningAction)
                return true;
            if (this.isRoot)
                return false;
            return this.parent.isRunningAction();
        };
        ObjectNode.prototype.assertAlive = function (context) {
            var livelinessChecking = getLivelinessChecking();
            if (!this.isAlive && livelinessChecking !== "ignore") {
                var error = this._getAssertAliveError(context);
                switch (livelinessChecking) {
                    case "error":
                        throw fail$1(error);
                    case "warn":
                        warnError(error);
                }
            }
        };
        ObjectNode.prototype._getAssertAliveError = function (context) {
            var escapedPath = this.getEscapedPath(false) || this.pathUponDeath || "";
            var subpath = (context.subpath && escapeJsonPath(context.subpath)) || "";
            var actionContext = context.actionContext || getCurrentActionContext();
            // try to use a real action context if possible since it includes the action name
            if (actionContext && actionContext.type !== "action" && actionContext.parentActionEvent) {
                actionContext = actionContext.parentActionEvent;
            }
            var actionFullPath = "";
            if (actionContext && actionContext.name != null) {
                // try to use the context, and if it not available use the node one
                var actionPath = (actionContext && actionContext.context && getPath(actionContext.context)) ||
                    escapedPath;
                actionFullPath = actionPath + "." + actionContext.name + "()";
            }
            return "You are trying to read or write to an object that is no longer part of a state tree. (Object type: '" + this.type.name + "', Path upon death: '" + escapedPath + "', Subpath: '" + subpath + "', Action: '" + actionFullPath + "'). Either detach nodes first, or don't use objects after removing / replacing them in the tree.";
        };
        ObjectNode.prototype.getChildNode = function (subpath) {
            this.assertAlive({
                subpath: subpath
            });
            this._autoUnbox = false;
            try {
                return this._observableInstanceState === 2 /* CREATED */
                    ? this.type.getChildNode(this, subpath)
                    : this._childNodes[subpath];
            }
            finally {
                this._autoUnbox = true;
            }
        };
        ObjectNode.prototype.getChildren = function () {
            this.assertAlive(EMPTY_OBJECT);
            this._autoUnbox = false;
            try {
                return this._observableInstanceState === 2 /* CREATED */
                    ? this.type.getChildren(this)
                    : convertChildNodesToArray(this._childNodes);
            }
            finally {
                this._autoUnbox = true;
            }
        };
        ObjectNode.prototype.getChildType = function (propertyName) {
            return this.type.getChildType(propertyName);
        };
        Object.defineProperty(ObjectNode.prototype, "isProtected", {
            get: function () {
                return this.root.isProtectionEnabled;
            },
            enumerable: true,
            configurable: true
        });
        ObjectNode.prototype.assertWritable = function (context) {
            this.assertAlive(context);
            if (!this.isRunningAction() && this.isProtected) {
                throw fail$1("Cannot modify '" + this + "', the object is protected and can only be modified by using an action.");
            }
        };
        ObjectNode.prototype.removeChild = function (subpath) {
            this.type.removeChild(this, subpath);
        };
        // bound on the constructor
        ObjectNode.prototype.unbox = function (childNode) {
            if (!childNode)
                return childNode;
            this.assertAlive({
                subpath: childNode.subpath || childNode.subpathUponDeath
            });
            return this._autoUnbox ? childNode.value : childNode;
        };
        ObjectNode.prototype.toString = function () {
            var path = (this.isAlive ? this.path : this.pathUponDeath) || "<root>";
            var identifier = this.identifier ? "(id: " + this.identifier + ")" : "";
            return this.type.name + "@" + path + identifier + (this.isAlive ? "" : " [dead]");
        };
        ObjectNode.prototype.finalizeCreation = function () {
            var _this = this;
            this.baseFinalizeCreation(function () {
                var e_2, _a;
                try {
                    for (var _b = __values(_this.getChildren()), _c = _b.next(); !_c.done; _c = _b.next()) {
                        var child = _c.value;
                        child.finalizeCreation();
                    }
                }
                catch (e_2_1) { e_2 = { error: e_2_1 }; }
                finally {
                    try {
                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                    }
                    finally { if (e_2) throw e_2.error; }
                }
                _this.fireInternalHook(Hook.afterCreationFinalization);
            });
        };
        ObjectNode.prototype.detach = function () {
            if (!this.isAlive)
                throw fail$1("Error while detaching, node is not alive.");
            this.clearParent();
        };
        ObjectNode.prototype.preboot = function () {
            var self = this;
            this._applyPatches = createActionInvoker(this.storedValue, "@APPLY_PATCHES", function (patches) {
                patches.forEach(function (patch) {
                    var parts = splitJsonPath(patch.path);
                    var node = resolveNodeByPathParts(self, parts.slice(0, -1));
                    node.applyPatchLocally(parts[parts.length - 1], patch);
                });
            });
            this._applySnapshot = createActionInvoker(this.storedValue, "@APPLY_SNAPSHOT", function (snapshot) {
                // if the snapshot is the same as the current one, avoid performing a reconcile
                if (snapshot === self.snapshot)
                    return;
                // else, apply it by calling the type logic
                return self.type.applySnapshot(self, snapshot);
            });
            addHiddenFinalProp(this.storedValue, "$treenode", this);
            addHiddenFinalProp(this.storedValue, "toJSON", toJSON);
        };
        ObjectNode.prototype.die = function () {
            if (!this.isAlive || this.state === NodeLifeCycle.DETACHING)
                return;
            this.aboutToDie();
            this.finalizeDeath();
        };
        ObjectNode.prototype.aboutToDie = function () {
            if (this._observableInstanceState === 0 /* UNINITIALIZED */) {
                return;
            }
            this.getChildren().forEach(function (node) {
                node.aboutToDie();
            });
            // beforeDestroy should run before the disposers since else we could end up in a situation where
            // a disposer added with addDisposer at this stage (beforeDestroy) is actually never released
            this.baseAboutToDie();
            this._internalEventsEmit("dispose" /* Dispose */);
            this._internalEventsClear("dispose" /* Dispose */);
        };
        ObjectNode.prototype.finalizeDeath = function () {
            // invariant: not called directly but from "die"
            this.getChildren().forEach(function (node) {
                node.finalizeDeath();
            });
            this.root.identifierCache.notifyDied(this);
            // "kill" the computed prop and just store the last snapshot
            var snapshot = this.snapshot;
            this._snapshotUponDeath = snapshot;
            this._internalEventsClearAll();
            this.baseFinalizeDeath();
        };
        ObjectNode.prototype.onSnapshot = function (onChange) {
            this._addSnapshotReaction();
            return this._internalEventsRegister("snapshot" /* Snapshot */, onChange);
        };
        ObjectNode.prototype.emitSnapshot = function (snapshot) {
            this._internalEventsEmit("snapshot" /* Snapshot */, snapshot);
        };
        ObjectNode.prototype.onPatch = function (handler) {
            return this._internalEventsRegister("patch" /* Patch */, handler);
        };
        ObjectNode.prototype.emitPatch = function (basePatch, source) {
            if (this._internalEventsHasSubscribers("patch" /* Patch */)) {
                var localizedPatch = extend({}, basePatch, {
                    path: source.path.substr(this.path.length) + "/" + basePatch.path // calculate the relative path of the patch
                });
                var _a = __read(splitPatch(localizedPatch), 2), patch = _a[0], reversePatch = _a[1];
                this._internalEventsEmit("patch" /* Patch */, patch, reversePatch);
            }
            if (this.parent)
                this.parent.emitPatch(basePatch, source);
        };
        ObjectNode.prototype.hasDisposer = function (disposer) {
            return this._internalEventsHas("dispose" /* Dispose */, disposer);
        };
        ObjectNode.prototype.addDisposer = function (disposer) {
            if (!this.hasDisposer(disposer)) {
                this._internalEventsRegister("dispose" /* Dispose */, disposer, true);
                return;
            }
            throw fail$1("cannot add a disposer when it is already registered for execution");
        };
        ObjectNode.prototype.removeDisposer = function (disposer) {
            if (!this._internalEventsHas("dispose" /* Dispose */, disposer)) {
                throw fail$1("cannot remove a disposer which was never registered for execution");
            }
            this._internalEventsUnregister("dispose" /* Dispose */, disposer);
        };
        ObjectNode.prototype.removeMiddleware = function (middleware) {
            if (this.middlewares) {
                var index = this.middlewares.indexOf(middleware);
                if (index >= 0) {
                    this.middlewares.splice(index, 1);
                }
            }
        };
        ObjectNode.prototype.addMiddleWare = function (handler, includeHooks) {
            var _this = this;
            if (includeHooks === void 0) { includeHooks = true; }
            var middleware = { handler: handler, includeHooks: includeHooks };
            if (!this.middlewares)
                this.middlewares = [middleware];
            else
                this.middlewares.push(middleware);
            return function () {
                _this.removeMiddleware(middleware);
            };
        };
        ObjectNode.prototype.applyPatchLocally = function (subpath, patch) {
            this.assertWritable({
                subpath: subpath
            });
            this.createObservableInstanceIfNeeded();
            this.type.applyPatchLocally(this, subpath, patch);
        };
        ObjectNode.prototype._addSnapshotReaction = function () {
            var _this = this;
            if (!this._hasSnapshotReaction) {
                var snapshotDisposer = mobx.reaction(function () { return _this.snapshot; }, function (snapshot) { return _this.emitSnapshot(snapshot); }, snapshotReactionOptions);
                this.addDisposer(snapshotDisposer);
                this._hasSnapshotReaction = true;
            }
        };
        // we proxy the methods to avoid creating an EventHandlers instance when it is not needed
        ObjectNode.prototype._internalEventsHasSubscribers = function (event) {
            return !!this._internalEvents && this._internalEvents.hasSubscribers(event);
        };
        ObjectNode.prototype._internalEventsRegister = function (event, eventHandler, atTheBeginning) {
            if (atTheBeginning === void 0) { atTheBeginning = false; }
            if (!this._internalEvents) {
                this._internalEvents = new EventHandlers();
            }
            return this._internalEvents.register(event, eventHandler, atTheBeginning);
        };
        ObjectNode.prototype._internalEventsHas = function (event, eventHandler) {
            return !!this._internalEvents && this._internalEvents.has(event, eventHandler);
        };
        ObjectNode.prototype._internalEventsUnregister = function (event, eventHandler) {
            if (this._internalEvents) {
                this._internalEvents.unregister(event, eventHandler);
            }
        };
        ObjectNode.prototype._internalEventsEmit = function (event) {
            var _a;
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            if (this._internalEvents) {
                (_a = this._internalEvents).emit.apply(_a, __spread([event], args));
            }
        };
        ObjectNode.prototype._internalEventsClear = function (event) {
            if (this._internalEvents) {
                this._internalEvents.clear(event);
            }
        };
        ObjectNode.prototype._internalEventsClearAll = function () {
            if (this._internalEvents) {
                this._internalEvents.clearAll();
            }
        };
        __decorate([
            mobx.action
        ], ObjectNode.prototype, "createObservableInstanceIfNeeded", null);
        __decorate([
            mobx.computed
        ], ObjectNode.prototype, "snapshot", null);
        __decorate([
            mobx.action
        ], ObjectNode.prototype, "detach", null);
        __decorate([
            mobx.action
        ], ObjectNode.prototype, "die", null);
        return ObjectNode;
    }(BaseNode));

    /**
     * @internal
     * @hidden
     */
    var TypeFlags;
    (function (TypeFlags) {
        TypeFlags[TypeFlags["String"] = 1] = "String";
        TypeFlags[TypeFlags["Number"] = 2] = "Number";
        TypeFlags[TypeFlags["Boolean"] = 4] = "Boolean";
        TypeFlags[TypeFlags["Date"] = 8] = "Date";
        TypeFlags[TypeFlags["Literal"] = 16] = "Literal";
        TypeFlags[TypeFlags["Array"] = 32] = "Array";
        TypeFlags[TypeFlags["Map"] = 64] = "Map";
        TypeFlags[TypeFlags["Object"] = 128] = "Object";
        TypeFlags[TypeFlags["Frozen"] = 256] = "Frozen";
        TypeFlags[TypeFlags["Optional"] = 512] = "Optional";
        TypeFlags[TypeFlags["Reference"] = 1024] = "Reference";
        TypeFlags[TypeFlags["Identifier"] = 2048] = "Identifier";
        TypeFlags[TypeFlags["Late"] = 4096] = "Late";
        TypeFlags[TypeFlags["Refinement"] = 8192] = "Refinement";
        TypeFlags[TypeFlags["Union"] = 16384] = "Union";
        TypeFlags[TypeFlags["Null"] = 32768] = "Null";
        TypeFlags[TypeFlags["Undefined"] = 65536] = "Undefined";
        TypeFlags[TypeFlags["Integer"] = 131072] = "Integer";
        TypeFlags[TypeFlags["Custom"] = 262144] = "Custom";
        TypeFlags[TypeFlags["SnapshotProcessor"] = 524288] = "SnapshotProcessor";
    })(TypeFlags || (TypeFlags = {}));
    /**
     * @internal
     * @hidden
     */
    var cannotDetermineSubtype = "cannotDetermine";
    /**
     * A base type produces a MST node (Node in the state tree)
     *
     * @internal
     * @hidden
     */
    var BaseType = /** @class */ (function () {
        function BaseType(name) {
            this.isType = true;
            this.name = name;
        }
        BaseType.prototype.create = function (snapshot, environment) {
            typecheckInternal(this, snapshot);
            return this.instantiate(null, "", environment, snapshot).value;
        };
        BaseType.prototype.getSnapshot = function (node, applyPostProcess) {
            // istanbul ignore next
            throw fail$1("unimplemented method");
        };
        BaseType.prototype.isAssignableFrom = function (type) {
            return type === this;
        };
        BaseType.prototype.validate = function (value, context) {
            var node = getStateTreeNodeSafe(value);
            if (node) {
                var valueType = getType(value);
                return this.isAssignableFrom(valueType)
                    ? typeCheckSuccess()
                    : typeCheckFailure(context, value);
                // it is tempting to compare snapshots, but in that case we should always clone on assignments...
            }
            return this.isValidSnapshot(value, context);
        };
        BaseType.prototype.is = function (thing) {
            return this.validate(thing, [{ path: "", type: this }]).length === 0;
        };
        Object.defineProperty(BaseType.prototype, "Type", {
            get: function () {
                // istanbul ignore next
                throw fail$1("Factory.Type should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.Type`");
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseType.prototype, "TypeWithoutSTN", {
            get: function () {
                // istanbul ignore next
                throw fail$1("Factory.TypeWithoutSTN should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.TypeWithoutSTN`");
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseType.prototype, "SnapshotType", {
            get: function () {
                // istanbul ignore next
                throw fail$1("Factory.SnapshotType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.SnapshotType`");
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(BaseType.prototype, "CreationType", {
            get: function () {
                // istanbul ignore next
                throw fail$1("Factory.CreationType should not be actually called. It is just a Type signature that can be used at compile time with Typescript, by using `typeof type.CreationType`");
            },
            enumerable: true,
            configurable: true
        });
        __decorate([
            mobx.action
        ], BaseType.prototype, "create", null);
        return BaseType;
    }());
    /**
     * A complex type produces a MST node (Node in the state tree)
     *
     * @internal
     * @hidden
     */
    var ComplexType = /** @class */ (function (_super) {
        __extends(ComplexType, _super);
        function ComplexType(name) {
            return _super.call(this, name) || this;
        }
        ComplexType.prototype.create = function (snapshot, environment) {
            if (snapshot === void 0) { snapshot = this.getDefaultSnapshot(); }
            return _super.prototype.create.call(this, snapshot, environment);
        };
        ComplexType.prototype.getValue = function (node) {
            node.createObservableInstanceIfNeeded();
            return node.storedValue;
        };
        ComplexType.prototype.tryToReconcileNode = function (current, newValue) {
            if (current.isDetaching)
                return false;
            if (current.snapshot === newValue) {
                // newValue is the current snapshot of the node, noop
                return true;
            }
            if (isStateTreeNode(newValue) && getStateTreeNode(newValue) === current) {
                // the current node is the same as the new one
                return true;
            }
            if (current.type === this &&
                isMutable(newValue) &&
                !isStateTreeNode(newValue) &&
                (!current.identifierAttribute ||
                    current.identifier ===
                        normalizeIdentifier(newValue[current.identifierAttribute]))) {
                // the newValue has no node, so can be treated like a snapshot
                // we can reconcile
                current.applySnapshot(newValue);
                return true;
            }
            return false;
        };
        ComplexType.prototype.reconcile = function (current, newValue, parent, subpath) {
            var nodeReconciled = this.tryToReconcileNode(current, newValue);
            if (nodeReconciled) {
                current.setParent(parent, subpath);
                return current;
            }
            // current node cannot be recycled in any way
            current.die(); // noop if detaching
            // attempt to reuse the new one
            if (isStateTreeNode(newValue) && this.isAssignableFrom(getType(newValue))) {
                // newValue is a Node as well, move it here..
                var newNode = getStateTreeNode(newValue);
                newNode.setParent(parent, subpath);
                return newNode;
            }
            // nothing to do, we have to create a new node
            return this.instantiate(parent, subpath, undefined, newValue);
        };
        ComplexType.prototype.getSubTypes = function () {
            return null;
        };
        __decorate([
            mobx.action
        ], ComplexType.prototype, "create", null);
        return ComplexType;
    }(BaseType));
    /**
     * @internal
     * @hidden
     */
    var SimpleType = /** @class */ (function (_super) {
        __extends(SimpleType, _super);
        function SimpleType() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        SimpleType.prototype.createNewInstance = function (snapshot) {
            return snapshot;
        };
        SimpleType.prototype.getValue = function (node) {
            // if we ever find a case where scalar nodes can be accessed without iterating through its parent
            // uncomment this to make sure the parent chain is created when this is accessed
            // if (node.parent) {
            //     node.parent.createObservableInstanceIfNeeded()
            // }
            return node.storedValue;
        };
        SimpleType.prototype.getSnapshot = function (node) {
            return node.storedValue;
        };
        SimpleType.prototype.reconcile = function (current, newValue, parent, subpath) {
            // reconcile only if type and value are still the same, and only if the node is not detaching
            if (!current.isDetaching && current.type === this && current.storedValue === newValue) {
                return current;
            }
            var res = this.instantiate(parent, subpath, undefined, newValue);
            current.die(); // noop if detaching
            return res;
        };
        SimpleType.prototype.getSubTypes = function () {
            return null;
        };
        return SimpleType;
    }(BaseType));
    /**
     * Returns if a given value represents a type.
     *
     * @param value Value to check.
     * @returns `true` if the value is a type.
     */
    function isType(value) {
        return typeof value === "object" && value && value.isType === true;
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsType(type, argNumber) {
        assertArg(type, isType, "mobx-state-tree type", argNumber);
    }

    var runningActions = new Map();
    /**
     * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
     *
     * Convenience utility to create action based middleware that supports async processes more easily.
     * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called
     *
     * The create middleware tracks the process of an action (assuming it passes the `filter`).
     * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.
     *
     * See the `atomic` middleware for an example
     *
     * @param hooks
     * @returns
     */
    function createActionTrackingMiddleware(hooks) {
        return function actionTrackingMiddleware(call, next, abort) {
            switch (call.type) {
                case "action": {
                    if (!hooks.filter || hooks.filter(call) === true) {
                        var context = hooks.onStart(call);
                        hooks.onResume(call, context);
                        runningActions.set(call.id, {
                            call: call,
                            context: context,
                            async: false
                        });
                        try {
                            var res = next(call);
                            hooks.onSuspend(call, context);
                            if (runningActions.get(call.id).async === false) {
                                runningActions.delete(call.id);
                                hooks.onSuccess(call, context, res);
                            }
                            return res;
                        }
                        catch (e) {
                            runningActions.delete(call.id);
                            hooks.onFail(call, context, e);
                            throw e;
                        }
                    }
                    else {
                        return next(call);
                    }
                }
                case "flow_spawn": {
                    var root = runningActions.get(call.rootId);
                    root.async = true;
                    return next(call);
                }
                case "flow_resume":
                case "flow_resume_error": {
                    var root = runningActions.get(call.rootId);
                    hooks.onResume(call, root.context);
                    try {
                        return next(call);
                    }
                    finally {
                        hooks.onSuspend(call, root.context);
                    }
                }
                case "flow_throw": {
                    var root = runningActions.get(call.rootId);
                    runningActions.delete(call.rootId);
                    hooks.onFail(call, root.context, call.args[0]);
                    return next(call);
                }
                case "flow_return": {
                    var root = runningActions.get(call.rootId);
                    runningActions.delete(call.rootId);
                    hooks.onSuccess(call, root.context, call.args[0]);
                    return next(call);
                }
            }
        };
    }

    var RunningAction = /** @class */ (function () {
        function RunningAction(hooks, call) {
            this.hooks = hooks;
            this.call = call;
            this.flowsPending = 0;
            this.running = true;
            if (hooks) {
                hooks.onStart(call);
            }
        }
        RunningAction.prototype.finish = function (error) {
            if (this.running) {
                this.running = false;
                if (this.hooks) {
                    this.hooks.onFinish(this.call, error);
                }
            }
        };
        RunningAction.prototype.incFlowsPending = function () {
            this.flowsPending++;
        };
        RunningAction.prototype.decFlowsPending = function () {
            this.flowsPending--;
        };
        Object.defineProperty(RunningAction.prototype, "hasFlowsPending", {
            get: function () {
                return this.flowsPending > 0;
            },
            enumerable: true,
            configurable: true
        });
        return RunningAction;
    }());
    /**
     * Convenience utility to create action based middleware that supports async processes more easily.
     * The flow is like this:
     * - for each action: if filter passes -> `onStart` -> (inner actions recursively) -> `onFinish`
     *
     * Example: if we had an action `a` that called inside an action `b1`, then `b2` the flow would be:
     * - `filter(a)`
     * - `onStart(a)`
     *   - `filter(b1)`
     *   - `onStart(b1)`
     *   - `onFinish(b1)`
     *   - `filter(b2)`
     *   - `onStart(b2)`
     *   - `onFinish(b2)`
     * - `onFinish(a)`
     *
     * The flow is the same no matter if the actions are sync or async.
     *
     * See the `atomic` middleware for an example
     *
     * @param hooks
     * @returns
     */
    function createActionTrackingMiddleware2(middlewareHooks) {
        var runningActions = new WeakMap();
        return function actionTrackingMiddleware(call, next) {
            // find parentRunningAction
            var parentRunningAction = call.parentActionEvent
                ? runningActions.get(call.parentActionEvent)
                : undefined;
            if (call.type === "action") {
                var newCall = __assign(__assign({}, call), { 
                    // make a shallow copy of the parent action env
                    env: parentRunningAction && parentRunningAction.call.env, parentCall: parentRunningAction && parentRunningAction.call });
                var passesFilter = !middlewareHooks.filter || middlewareHooks.filter(newCall);
                var hooks = passesFilter ? middlewareHooks : undefined;
                var runningAction = new RunningAction(hooks, newCall);
                runningActions.set(call, runningAction);
                var res = void 0;
                try {
                    res = next(call);
                }
                catch (e) {
                    runningAction.finish(e);
                    throw e;
                }
                if (!runningAction.hasFlowsPending) {
                    // sync action finished
                    runningAction.finish();
                }
                return res;
            }
            else {
                if (!parentRunningAction) {
                    return next(call);
                }
                switch (call.type) {
                    case "flow_spawn": {
                        parentRunningAction.incFlowsPending();
                        return next(call);
                    }
                    case "flow_resume":
                    case "flow_resume_error": {
                        return next(call);
                    }
                    case "flow_throw": {
                        var error = call.args[0];
                        try {
                            return next(call);
                        }
                        finally {
                            parentRunningAction.decFlowsPending();
                            if (!parentRunningAction.hasFlowsPending) {
                                parentRunningAction.finish(error);
                            }
                        }
                    }
                    case "flow_return": {
                        try {
                            return next(call);
                        }
                        finally {
                            parentRunningAction.decFlowsPending();
                            if (!parentRunningAction.hasFlowsPending) {
                                parentRunningAction.finish();
                            }
                        }
                    }
                }
            }
        };
    }

    function serializeArgument(node, actionName, index, arg) {
        if (arg instanceof Date)
            return { $MST_DATE: arg.getTime() };
        if (isPrimitive(arg))
            return arg;
        // We should not serialize MST nodes, even if we can, because we don't know if the receiving party can handle a raw snapshot instead of an
        // MST type instance. So if one wants to serialize a MST node that was pass in, either explitly pass: 1: an id, 2: a (relative) path, 3: a snapshot
        if (isStateTreeNode(arg))
            return serializeTheUnserializable("[MSTNode: " + getType(arg).name + "]");
        if (typeof arg === "function")
            return serializeTheUnserializable("[function]");
        if (typeof arg === "object" && !isPlainObject(arg) && !isArray(arg))
            return serializeTheUnserializable("[object " + ((arg && arg.constructor && arg.constructor.name) ||
                "Complex Object") + "]");
        try {
            // Check if serializable, cycle free etc...
            // MWE: there must be a better way....
            JSON.stringify(arg); // or throws
            return arg;
        }
        catch (e) {
            return serializeTheUnserializable("" + e);
        }
    }
    function deserializeArgument(adm, value) {
        if (value && typeof value === "object" && "$MST_DATE" in value)
            return new Date(value["$MST_DATE"]);
        return value;
    }
    function serializeTheUnserializable(baseType) {
        return {
            $MST_UNSERIALIZABLE: true,
            type: baseType
        };
    }
    /**
     * Applies an action or a series of actions in a single MobX transaction.
     * Does not return any value
     * Takes an action description as produced by the `onAction` middleware.
     *
     * @param target
     * @param actions
     */
    function applyAction(target, actions) {
        // check all arguments
        assertIsStateTreeNode(target, 1);
        assertArg(actions, function (a) { return typeof a === "object"; }, "object or array", 2);
        mobx.runInAction(function () {
            asArray(actions).forEach(function (action) { return baseApplyAction(target, action); });
        });
    }
    function baseApplyAction(target, action) {
        var resolvedTarget = tryResolve(target, action.path || "");
        if (!resolvedTarget)
            throw fail$1("Invalid action path: " + (action.path || ""));
        var node = getStateTreeNode(resolvedTarget);
        // Reserved functions
        if (action.name === "@APPLY_PATCHES") {
            return applyPatch.call(null, resolvedTarget, action.args[0]);
        }
        if (action.name === "@APPLY_SNAPSHOT") {
            return applySnapshot.call(null, resolvedTarget, action.args[0]);
        }
        if (!(typeof resolvedTarget[action.name] === "function"))
            throw fail$1("Action '" + action.name + "' does not exist in '" + node.path + "'");
        return resolvedTarget[action.name].apply(resolvedTarget, action.args ? action.args.map(function (v) { return deserializeArgument(node, v); }) : []);
    }
    /**
     * Small abstraction around `onAction` and `applyAction`, attaches an action listener to a tree and records all the actions emitted.
     * Returns an recorder object with the following signature:
     *
     * Example:
     * ```ts
     * export interface IActionRecorder {
     *      // the recorded actions
     *      actions: ISerializedActionCall[]
     *      // true if currently recording
     *      recording: boolean
     *      // stop recording actions
     *      stop(): void
     *      // resume recording actions
     *      resume(): void
     *      // apply all the recorded actions on the given object
     *      replay(target: IAnyStateTreeNode): void
     * }
     * ```
     *
     * The optional filter function allows to skip recording certain actions.
     *
     * @param subject
     * @returns
     */
    function recordActions(subject, filter) {
        // check all arguments
        assertIsStateTreeNode(subject, 1);
        var actions = [];
        var listener = function (call) {
            var recordThis = filter ? filter(call, getRunningActionContext()) : true;
            if (recordThis) {
                actions.push(call);
            }
        };
        var disposer;
        var recorder = {
            actions: actions,
            get recording() {
                return !!disposer;
            },
            stop: function () {
                if (disposer) {
                    disposer();
                    disposer = undefined;
                }
            },
            resume: function () {
                if (disposer)
                    return;
                disposer = onAction(subject, listener);
            },
            replay: function (target) {
                applyAction(target, actions);
            }
        };
        recorder.resume();
        return recorder;
    }
    /**
     * Registers a function that will be invoked for each action that is called on the provided model instance, or to any of its children.
     * See [actions](https://github.com/mobxjs/mobx-state-tree#actions) for more details. onAction events are emitted only for the outermost called action in the stack.
     * Action can also be intercepted by middleware using addMiddleware to change the function call before it will be run.
     *
     * Not all action arguments might be serializable. For unserializable arguments, a struct like `{ $MST_UNSERIALIZABLE: true, type: "someType" }` will be generated.
     * MST Nodes are considered non-serializable as well (they could be serialized as there snapshot, but it is uncertain whether an replaying party will be able to handle such a non-instantiated snapshot).
     * Rather, when using `onAction` middleware, one should consider in passing arguments which are 1: an id, 2: a (relative) path, or 3: a snapshot. Instead of a real MST node.
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *   task: types.string
     * })
     *
     * const TodoStore = types.model({
     *   todos: types.array(Todo)
     * }).actions(self => ({
     *   add(todo) {
     *     self.todos.push(todo);
     *   }
     * }))
     *
     * const s = TodoStore.create({ todos: [] })
     *
     * let disposer = onAction(s, (call) => {
     *   console.log(call);
     * })
     *
     * s.add({ task: "Grab a coffee" })
     * // Logs: { name: "add", path: "", args: [{ task: "Grab a coffee" }] }
     * ```
     *
     * @param target
     * @param listener
     * @param attachAfter (default false) fires the listener *after* the action has executed instead of before.
     * @returns
     */
    function onAction(target, listener, attachAfter) {
        if (attachAfter === void 0) { attachAfter = false; }
        // check all arguments
        assertIsStateTreeNode(target, 1);
        {
            if (!isRoot(target))
                warnError("Warning: Attaching onAction listeners to non root nodes is dangerous: No events will be emitted for actions initiated higher up in the tree.");
            if (!isProtected(target))
                warnError("Warning: Attaching onAction listeners to non protected nodes is dangerous: No events will be emitted for direct modifications without action.");
        }
        return addMiddleware(target, function handler(rawCall, next) {
            if (rawCall.type === "action" && rawCall.id === rawCall.rootId) {
                var sourceNode_1 = getStateTreeNode(rawCall.context);
                var info = {
                    name: rawCall.name,
                    path: getRelativePathBetweenNodes(getStateTreeNode(target), sourceNode_1),
                    args: rawCall.args.map(function (arg, index) {
                        return serializeArgument(sourceNode_1, rawCall.name, index, arg);
                    })
                };
                if (attachAfter) {
                    var res = next(rawCall);
                    listener(info);
                    return res;
                }
                else {
                    listener(info);
                    return next(rawCall);
                }
            }
            else {
                return next(rawCall);
            }
        });
    }

    var nextActionId = 1;
    var currentActionContext;
    /**
     * @internal
     * @hidden
     */
    function getCurrentActionContext() {
        return currentActionContext;
    }
    /**
     * @internal
     * @hidden
     */
    function getNextActionId() {
        return nextActionId++;
    }
    // TODO: optimize away entire action context if there is no middleware in tree?
    /**
     * @internal
     * @hidden
     */
    function runWithActionContext(context, fn) {
        var node = getStateTreeNode(context.context);
        if (context.type === "action") {
            node.assertAlive({
                actionContext: context
            });
        }
        var baseIsRunningAction = node._isRunningAction;
        node._isRunningAction = true;
        var previousContext = currentActionContext;
        currentActionContext = context;
        try {
            return runMiddleWares(node, context, fn);
        }
        finally {
            currentActionContext = previousContext;
            node._isRunningAction = baseIsRunningAction;
        }
    }
    /**
     * @internal
     * @hidden
     */
    function getParentActionContext(parentContext) {
        if (!parentContext)
            return undefined;
        if (parentContext.type === "action")
            return parentContext;
        return parentContext.parentActionEvent;
    }
    /**
     * @internal
     * @hidden
     */
    function createActionInvoker(target, name, fn) {
        var res = function () {
            var id = getNextActionId();
            var parentContext = currentActionContext;
            var parentActionContext = getParentActionContext(parentContext);
            return runWithActionContext({
                type: "action",
                name: name,
                id: id,
                args: argsToArray(arguments),
                context: target,
                tree: getRoot(target),
                rootId: parentContext ? parentContext.rootId : id,
                parentId: parentContext ? parentContext.id : 0,
                allParentIds: parentContext
                    ? __spread(parentContext.allParentIds, [parentContext.id]) : [],
                parentEvent: parentContext,
                parentActionEvent: parentActionContext
            }, fn);
        };
        res._isMSTAction = true;
        return res;
    }
    /**
     * Middleware can be used to intercept any action is invoked on the subtree where it is attached.
     * If a tree is protected (by default), this means that any mutation of the tree will pass through your middleware.
     *
     * For more details, see the [middleware docs](../middleware.md)
     *
     * @param target Node to apply the middleware to.
     * @param middleware Middleware to apply.
     * @returns A callable function to dispose the middleware.
     */
    function addMiddleware(target, handler, includeHooks) {
        if (includeHooks === void 0) { includeHooks = true; }
        var node = getStateTreeNode(target);
        {
            if (!node.isProtectionEnabled) {
                warnError("It is recommended to protect the state tree before attaching action middleware, as otherwise it cannot be guaranteed that all changes are passed through middleware. See `protect`");
            }
        }
        return node.addMiddleWare(handler, includeHooks);
    }
    /**
     * Binds middleware to a specific action.
     *
     * Example:
     * ```ts
     * type.actions(self => {
     *   function takeA____() {
     *       self.toilet.donate()
     *       self.wipe()
     *       self.wipe()
     *       self.toilet.flush()
     *   }
     *   return {
     *     takeA____: decorate(atomic, takeA____)
     *   }
     * })
     * ```
     *
     * @param handler
     * @param fn
     * @param includeHooks
     * @returns The original function
     */
    function decorate(handler, fn, includeHooks) {
        if (includeHooks === void 0) { includeHooks = true; }
        var middleware = { handler: handler, includeHooks: includeHooks };
        fn.$mst_middleware = fn.$mst_middleware || [];
        fn.$mst_middleware.push(middleware);
        return fn;
    }
    var CollectedMiddlewares = /** @class */ (function () {
        function CollectedMiddlewares(node, fn) {
            this.arrayIndex = 0;
            this.inArrayIndex = 0;
            this.middlewares = [];
            // we just push middleware arrays into an array of arrays to avoid making copies
            if (fn.$mst_middleware) {
                this.middlewares.push(fn.$mst_middleware);
            }
            var n = node;
            // Find all middlewares. Optimization: cache this?
            while (n) {
                if (n.middlewares)
                    this.middlewares.push(n.middlewares);
                n = n.parent;
            }
        }
        Object.defineProperty(CollectedMiddlewares.prototype, "isEmpty", {
            get: function () {
                return this.middlewares.length <= 0;
            },
            enumerable: true,
            configurable: true
        });
        CollectedMiddlewares.prototype.getNextMiddleware = function () {
            var array = this.middlewares[this.arrayIndex];
            if (!array)
                return undefined;
            var item = array[this.inArrayIndex++];
            if (!item) {
                this.arrayIndex++;
                this.inArrayIndex = 0;
                return this.getNextMiddleware();
            }
            return item;
        };
        return CollectedMiddlewares;
    }());
    function runMiddleWares(node, baseCall, originalFn) {
        var middlewares = new CollectedMiddlewares(node, originalFn);
        // Short circuit
        if (middlewares.isEmpty)
            return mobx.action(originalFn).apply(null, baseCall.args);
        var result = null;
        function runNextMiddleware(call) {
            var middleware = middlewares.getNextMiddleware();
            var handler = middleware && middleware.handler;
            if (!handler) {
                return mobx.action(originalFn).apply(null, call.args);
            }
            // skip hooks if asked to
            if (!middleware.includeHooks && Hook[call.name]) {
                return runNextMiddleware(call);
            }
            var nextInvoked = false;
            function next(call2, callback) {
                nextInvoked = true;
                // the result can contain
                // - the non manipulated return value from an action
                // - the non manipulated abort value
                // - one of the above but manipulated through the callback function
                result = runNextMiddleware(call2);
                if (callback) {
                    result = callback(result);
                }
            }
            var abortInvoked = false;
            function abort(value) {
                abortInvoked = true;
                // overwrite the result
                // can be manipulated through middlewares earlier in the queue using the callback fn
                result = value;
            }
            handler(call, next, abort);
            {
                if (!nextInvoked && !abortInvoked) {
                    var node2 = getStateTreeNode(call.tree);
                    throw fail$1("Neither the next() nor the abort() callback within the middleware " + handler.name + " for the action: \"" + call.name + "\" on the node: " + node2.type.name + " was invoked.");
                }
                else if (nextInvoked && abortInvoked) {
                    var node2 = getStateTreeNode(call.tree);
                    throw fail$1("The next() and abort() callback within the middleware " + handler.name + " for the action: \"" + call.name + "\" on the node: " + node2.type.name + " were invoked.");
                }
            }
            return result;
        }
        return runNextMiddleware(baseCall);
    }

    /**
     * Returns the currently executing MST action context, or undefined if none.
     */
    function getRunningActionContext() {
        var current = getCurrentActionContext();
        while (current && current.type !== "action") {
            current = current.parentActionEvent;
        }
        return current;
    }
    function _isActionContextThisOrChildOf(actionContext, sameOrParent, includeSame) {
        var parentId = typeof sameOrParent === "number" ? sameOrParent : sameOrParent.id;
        var current = includeSame
            ? actionContext
            : actionContext.parentActionEvent;
        while (current) {
            if (current.id === parentId) {
                return true;
            }
            current = current.parentActionEvent;
        }
        return false;
    }
    /**
     * Returns if the given action context is a parent of this action context.
     */
    function isActionContextChildOf(actionContext, parent) {
        return _isActionContextThisOrChildOf(actionContext, parent, false);
    }
    /**
     * Returns if the given action context is this or a parent of this action context.
     */
    function isActionContextThisOrChildOf(actionContext, parentOrThis) {
        return _isActionContextThisOrChildOf(actionContext, parentOrThis, true);
    }

    function safeStringify(value) {
        try {
            return JSON.stringify(value);
        }
        catch (e) {
            // istanbul ignore next
            return "<Unserializable: " + e + ">";
        }
    }
    /**
     * @internal
     * @hidden
     */
    function prettyPrintValue(value) {
        return typeof value === "function"
            ? "<function" + (value.name ? " " + value.name : "") + ">"
            : isStateTreeNode(value)
                ? "<" + value + ">"
                : "`" + safeStringify(value) + "`";
    }
    function shortenPrintValue(valueInString) {
        return valueInString.length < 280
            ? valueInString
            : valueInString.substring(0, 272) + "......" + valueInString.substring(valueInString.length - 8);
    }
    function toErrorString(error) {
        var value = error.value;
        var type = error.context[error.context.length - 1].type;
        var fullPath = error.context
            .map(function (_a) {
            var path = _a.path;
            return path;
        })
            .filter(function (path) { return path.length > 0; })
            .join("/");
        var pathPrefix = fullPath.length > 0 ? "at path \"/" + fullPath + "\" " : "";
        var currentTypename = isStateTreeNode(value)
            ? "value of type " + getStateTreeNode(value).type.name + ":"
            : isPrimitive(value)
                ? "value"
                : "snapshot";
        var isSnapshotCompatible = type && isStateTreeNode(value) && type.is(getStateTreeNode(value).snapshot);
        return ("" + pathPrefix + currentTypename + " " + prettyPrintValue(value) + " is not assignable " + (type ? "to type: `" + type.name + "`" : "") +
            (error.message ? " (" + error.message + ")" : "") +
            (type
                ? isPrimitiveType(type) || isPrimitive(value)
                    ? "."
                    : ", expected an instance of `" + type.name + "` or a snapshot like `" + type.describe() + "` instead." +
                        (isSnapshotCompatible
                            ? " (Note that a snapshot of the provided value is compatible with the targeted type)"
                            : "")
                : "."));
    }
    /**
     * @internal
     * @hidden
     */
    function getContextForPath(context, path, type) {
        return context.concat([{ path: path, type: type }]);
    }
    /**
     * @internal
     * @hidden
     */
    function typeCheckSuccess() {
        return EMPTY_ARRAY;
    }
    /**
     * @internal
     * @hidden
     */
    function typeCheckFailure(context, value, message) {
        return [{ context: context, value: value, message: message }];
    }
    /**
     * @internal
     * @hidden
     */
    function flattenTypeErrors(errors) {
        return errors.reduce(function (a, i) { return a.concat(i); }, []);
    }
    // TODO; doublecheck: typecheck should only needed to be invoked from: type.create and array / map / value.property will change
    /**
     * @internal
     * @hidden
     */
    function typecheckInternal(type, value) {
        // runs typeChecking if it is in dev-mode or through a process.env.ENABLE_TYPE_CHECK flag
        {
            typecheck(type, value);
        }
    }
    /**
     * Run's the typechecker for the given type on the given value, which can be a snapshot or an instance.
     * Throws if the given value is not according the provided type specification.
     * Use this if you need typechecks even in a production build (by default all automatic runtime type checks will be skipped in production builds)
     *
     * @param type Type to check against.
     * @param value Value to be checked, either a snapshot or an instance.
     */
    function typecheck(type, value) {
        var errors = type.validate(value, [{ path: "", type: type }]);
        if (errors.length > 0) {
            throw fail$1(validationErrorsToString(type, value, errors));
        }
    }
    function validationErrorsToString(type, value, errors) {
        if (errors.length === 0) {
            return undefined;
        }
        return ("Error while converting " + shortenPrintValue(prettyPrintValue(value)) + " to `" + type.name + "`:\n\n    " + errors.map(toErrorString).join("\n    "));
    }

    var identifierCacheId = 0;
    /**
     * @internal
     * @hidden
     */
    var IdentifierCache = /** @class */ (function () {
        function IdentifierCache() {
            this.cacheId = identifierCacheId++;
            // n.b. in cache all identifiers are normalized to strings
            this.cache = mobx.observable.map();
            // last time the cache (array) for a given time changed
            // n.b. it is not really the time, but just an integer that gets increased after each modification to the array
            this.lastCacheModificationPerId = mobx.observable.map();
        }
        IdentifierCache.prototype.updateLastCacheModificationPerId = function (identifier) {
            var lcm = this.lastCacheModificationPerId.get(identifier);
            // we start at 1 since 0 means no update since cache creation
            this.lastCacheModificationPerId.set(identifier, lcm === undefined ? 1 : lcm + 1);
        };
        IdentifierCache.prototype.getLastCacheModificationPerId = function (identifier) {
            var modificationId = this.lastCacheModificationPerId.get(identifier) || 0;
            return this.cacheId + "-" + modificationId;
        };
        IdentifierCache.prototype.addNodeToCache = function (node, lastCacheUpdate) {
            if (lastCacheUpdate === void 0) { lastCacheUpdate = true; }
            if (node.identifierAttribute) {
                var identifier = node.identifier;
                if (!this.cache.has(identifier)) {
                    this.cache.set(identifier, mobx.observable.array([], mobxShallow));
                }
                var set = this.cache.get(identifier);
                if (set.indexOf(node) !== -1)
                    throw fail$1("Already registered");
                set.push(node);
                if (lastCacheUpdate) {
                    this.updateLastCacheModificationPerId(identifier);
                }
            }
        };
        IdentifierCache.prototype.mergeCache = function (node) {
            var _this = this;
            mobx.values(node.identifierCache.cache).forEach(function (nodes) {
                return nodes.forEach(function (child) {
                    _this.addNodeToCache(child);
                });
            });
        };
        IdentifierCache.prototype.notifyDied = function (node) {
            if (node.identifierAttribute) {
                var id = node.identifier;
                var set = this.cache.get(id);
                if (set) {
                    set.remove(node);
                    // remove empty sets from cache
                    if (!set.length) {
                        this.cache.delete(id);
                    }
                    this.updateLastCacheModificationPerId(node.identifier);
                }
            }
        };
        IdentifierCache.prototype.splitCache = function (node) {
            var _this = this;
            var res = new IdentifierCache();
            var basePath = node.path;
            mobx.entries(this.cache).forEach(function (_a) {
                var _b = __read(_a, 2), id = _b[0], nodes = _b[1];
                var modified = false;
                for (var i = nodes.length - 1; i >= 0; i--) {
                    if (nodes[i].path.indexOf(basePath) === 0) {
                        res.addNodeToCache(nodes[i], false); // no need to update lastUpdated since it is a whole new cache
                        nodes.splice(i, 1);
                        modified = true;
                    }
                }
                if (modified) {
                    _this.updateLastCacheModificationPerId(id);
                }
            });
            return res;
        };
        IdentifierCache.prototype.has = function (type, identifier) {
            var set = this.cache.get(identifier);
            if (!set)
                return false;
            return set.some(function (candidate) { return type.isAssignableFrom(candidate.type); });
        };
        IdentifierCache.prototype.resolve = function (type, identifier) {
            var set = this.cache.get(identifier);
            if (!set)
                return null;
            var matches = set.filter(function (candidate) { return type.isAssignableFrom(candidate.type); });
            switch (matches.length) {
                case 0:
                    return null;
                case 1:
                    return matches[0];
                default:
                    throw fail$1("Cannot resolve a reference to type '" + type.name + "' with id: '" + identifier + "' unambigously, there are multiple candidates: " + matches
                        .map(function (n) { return n.path; })
                        .join(", "));
            }
        };
        return IdentifierCache;
    }());

    /**
     * @internal
     * @hidden
     */
    function createObjectNode(type, parent, subpath, environment, initialValue) {
        var existingNode = getStateTreeNodeSafe(initialValue);
        if (existingNode) {
            if (existingNode.parent) {
                // istanbul ignore next
                throw fail$1("Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '" + (parent ? parent.path : "") + "/" + subpath + "', but it lives already at '" + existingNode.path + "'");
            }
            if (parent) {
                existingNode.setParent(parent, subpath);
            }
            // else it already has no parent since it is a pre-requisite
            return existingNode;
        }
        // not a node, a snapshot
        return new ObjectNode(type, parent, subpath, environment, initialValue);
    }
    /**
     * @internal
     * @hidden
     */
    function createScalarNode(type, parent, subpath, environment, initialValue) {
        return new ScalarNode(type, parent, subpath, environment, initialValue);
    }
    /**
     * @internal
     * @hidden
     */
    function isNode(value) {
        return value instanceof ScalarNode || value instanceof ObjectNode;
    }

    /**
     * @internal
     * @hidden
     */
    var NodeLifeCycle;
    (function (NodeLifeCycle) {
        NodeLifeCycle[NodeLifeCycle["INITIALIZING"] = 0] = "INITIALIZING";
        NodeLifeCycle[NodeLifeCycle["CREATED"] = 1] = "CREATED";
        NodeLifeCycle[NodeLifeCycle["FINALIZED"] = 2] = "FINALIZED";
        NodeLifeCycle[NodeLifeCycle["DETACHING"] = 3] = "DETACHING";
        NodeLifeCycle[NodeLifeCycle["DEAD"] = 4] = "DEAD"; // no coming back from this one
    })(NodeLifeCycle || (NodeLifeCycle = {}));
    /**
     * Returns true if the given value is a node in a state tree.
     * More precisely, that is, if the value is an instance of a
     * `types.model`, `types.array` or `types.map`.
     *
     * @param value
     * @returns true if the value is a state tree node.
     */
    function isStateTreeNode(value) {
        return !!(value && value.$treenode);
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsStateTreeNode(value, argNumber) {
        assertArg(value, isStateTreeNode, "mobx-state-tree node", argNumber);
    }
    /**
     * @internal
     * @hidden
     */
    function getStateTreeNode(value) {
        if (!isStateTreeNode(value)) {
            // istanbul ignore next
            throw fail$1("Value " + value + " is no MST Node");
        }
        return value.$treenode;
    }
    /**
     * @internal
     * @hidden
     */
    function getStateTreeNodeSafe(value) {
        return (value && value.$treenode) || null;
    }
    /**
     * @internal
     * @hidden
     */
    function toJSON() {
        return getStateTreeNode(this).snapshot;
    }
    var doubleDot = function (_) { return ".."; };
    /**
     * @internal
     * @hidden
     */
    function getRelativePathBetweenNodes(base, target) {
        // PRE condition target is (a child of) base!
        if (base.root !== target.root) {
            throw fail$1("Cannot calculate relative path: objects '" + base + "' and '" + target + "' are not part of the same object tree");
        }
        var baseParts = splitJsonPath(base.path);
        var targetParts = splitJsonPath(target.path);
        var common = 0;
        for (; common < baseParts.length; common++) {
            if (baseParts[common] !== targetParts[common])
                break;
        }
        // TODO: assert that no targetParts paths are "..", "." or ""!
        return (baseParts
            .slice(common)
            .map(doubleDot)
            .join("/") + joinJsonPath(targetParts.slice(common)));
    }
    /**
     * @internal
     * @hidden
     */
    function resolveNodeByPath(base, path, failIfResolveFails) {
        if (failIfResolveFails === void 0) { failIfResolveFails = true; }
        return resolveNodeByPathParts(base, splitJsonPath(path), failIfResolveFails);
    }
    /**
     * @internal
     * @hidden
     */
    function resolveNodeByPathParts(base, pathParts, failIfResolveFails) {
        if (failIfResolveFails === void 0) { failIfResolveFails = true; }
        var current = base;
        for (var i = 0; i < pathParts.length; i++) {
            var part = pathParts[i];
            if (part === "..") {
                current = current.parent;
                if (current)
                    continue; // not everything has a parent
            }
            else if (part === ".") {
                continue;
            }
            else if (current) {
                if (current instanceof ScalarNode) {
                    // check if the value of a scalar resolves to a state tree node (e.g. references)
                    // then we can continue resolving...
                    try {
                        var value = current.value;
                        if (isStateTreeNode(value)) {
                            current = getStateTreeNode(value);
                            // fall through
                        }
                    }
                    catch (e) {
                        if (!failIfResolveFails) {
                            return undefined;
                        }
                        throw e;
                    }
                }
                if (current instanceof ObjectNode) {
                    var subType = current.getChildType(part);
                    if (subType) {
                        current = current.getChildNode(part);
                        if (current)
                            continue;
                    }
                }
            }
            if (failIfResolveFails)
                throw fail$1("Could not resolve '" + part + "' in path '" + (joinJsonPath(pathParts.slice(0, i)) ||
                    "/") + "' while resolving '" + joinJsonPath(pathParts) + "'");
            else
                return undefined;
        }
        return current;
    }
    /**
     * @internal
     * @hidden
     */
    function convertChildNodesToArray(childNodes) {
        if (!childNodes)
            return EMPTY_ARRAY;
        var keys = Object.keys(childNodes);
        if (!keys.length)
            return EMPTY_ARRAY;
        var result = new Array(keys.length);
        keys.forEach(function (key, index) {
            result[index] = childNodes[key];
        });
        return result;
    }

    // based on: https://github.com/mobxjs/mobx-utils/blob/master/src/async-action.ts
    /*
        All contents of this file are deprecated.

        The term `process` has been replaced with `flow` to avoid conflicts with the
        global `process` object.

        Refer to `flow.ts` for any further changes to this implementation.
    */
    var DEPRECATION_MESSAGE = "See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information. " +
        "Note that the middleware event types starting with `process` now start with `flow`.";
    /**
     * @hidden
     *
     * @deprecated has been renamed to `flow()`.
     * See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information.
     * Note that the middleware event types starting with `process` now start with `flow`.
     *
     * @returns {Promise}
     */
    function process(asyncAction) {
        deprecated("process", "`process()` has been renamed to `flow()`. " + DEPRECATION_MESSAGE);
        return flow(asyncAction);
    }

    /**
     * @internal
     * @hidden
     */
    var EMPTY_ARRAY = Object.freeze([]);
    /**
     * @internal
     * @hidden
     */
    var EMPTY_OBJECT = Object.freeze({});
    /**
     * @internal
     * @hidden
     */
    var mobxShallow = typeof mobx.$mobx === "string" ? { deep: false } : { deep: false, proxy: false };
    Object.freeze(mobxShallow);
    /**
     * @internal
     * @hidden
     */
    function fail$1(message) {
        if (message === void 0) { message = "Illegal state"; }
        return new Error("[mobx-state-tree] " + message);
    }
    /**
     * @internal
     * @hidden
     */
    function identity(_) {
        return _;
    }
    /**
     * pollyfill (for IE) suggested in MDN:
     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
     * @internal
     * @hidden
     */
    var isInteger = Number.isInteger ||
        function (value) {
            return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
        };
    /**
     * @internal
     * @hidden
     */
    function isArray(val) {
        return Array.isArray(val) || mobx.isObservableArray(val);
    }
    /**
     * @internal
     * @hidden
     */
    function asArray(val) {
        if (!val)
            return EMPTY_ARRAY;
        if (isArray(val))
            return val;
        return [val];
    }
    /**
     * @internal
     * @hidden
     */
    function extend(a) {
        var b = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            b[_i - 1] = arguments[_i];
        }
        for (var i = 0; i < b.length; i++) {
            var current = b[i];
            for (var key in current)
                a[key] = current[key];
        }
        return a;
    }
    /**
     * @internal
     * @hidden
     */
    function isPlainObject(value) {
        if (value === null || typeof value !== "object")
            return false;
        var proto = Object.getPrototypeOf(value);
        return proto === Object.prototype || proto === null;
    }
    /**
     * @internal
     * @hidden
     */
    function isMutable(value) {
        return (value !== null &&
            typeof value === "object" &&
            !(value instanceof Date) &&
            !(value instanceof RegExp));
    }
    /**
     * @internal
     * @hidden
     */
    function isPrimitive(value, includeDate) {
        if (includeDate === void 0) { includeDate = true; }
        if (value === null || value === undefined)
            return true;
        if (typeof value === "string" ||
            typeof value === "number" ||
            typeof value === "boolean" ||
            (includeDate && value instanceof Date))
            return true;
        return false;
    }
    /**
     * @internal
     * @hidden
     * Freeze a value and return it (if not in production)
     */
    function freeze(value) {
        return isPrimitive(value) || mobx.isObservableArray(value) ? value : Object.freeze(value);
    }
    /**
     * @internal
     * @hidden
     * Recursively freeze a value (if not in production)
     */
    function deepFreeze(value) {
        freeze(value);
        if (isPlainObject(value)) {
            Object.keys(value).forEach(function (propKey) {
                if (!isPrimitive(value[propKey]) &&
                    !Object.isFrozen(value[propKey])) {
                    deepFreeze(value[propKey]);
                }
            });
        }
        return value;
    }
    /**
     * @internal
     * @hidden
     */
    function isSerializable(value) {
        return typeof value !== "function";
    }
    /**
     * @internal
     * @hidden
     */
    function addHiddenFinalProp(object, propName, value) {
        Object.defineProperty(object, propName, {
            enumerable: false,
            writable: false,
            configurable: true,
            value: value
        });
    }
    /**
     * @internal
     * @hidden
     */
    function addHiddenWritableProp(object, propName, value) {
        Object.defineProperty(object, propName, {
            enumerable: false,
            writable: true,
            configurable: true,
            value: value
        });
    }
    /**
     * @internal
     * @hidden
     */
    var EventHandler = /** @class */ (function () {
        function EventHandler() {
            this.handlers = [];
        }
        Object.defineProperty(EventHandler.prototype, "hasSubscribers", {
            get: function () {
                return this.handlers.length > 0;
            },
            enumerable: true,
            configurable: true
        });
        EventHandler.prototype.register = function (fn, atTheBeginning) {
            var _this = this;
            if (atTheBeginning === void 0) { atTheBeginning = false; }
            if (atTheBeginning) {
                this.handlers.unshift(fn);
            }
            else {
                this.handlers.push(fn);
            }
            return function () {
                _this.unregister(fn);
            };
        };
        EventHandler.prototype.has = function (fn) {
            return this.handlers.indexOf(fn) >= 0;
        };
        EventHandler.prototype.unregister = function (fn) {
            var index = this.handlers.indexOf(fn);
            if (index >= 0) {
                this.handlers.splice(index, 1);
            }
        };
        EventHandler.prototype.clear = function () {
            this.handlers.length = 0;
        };
        EventHandler.prototype.emit = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            // make a copy just in case it changes
            var handlers = this.handlers.slice();
            handlers.forEach(function (f) { return f.apply(void 0, __spread(args)); });
        };
        return EventHandler;
    }());
    /**
     * @internal
     * @hidden
     */
    var EventHandlers = /** @class */ (function () {
        function EventHandlers() {
        }
        EventHandlers.prototype.hasSubscribers = function (event) {
            var handler = this.eventHandlers && this.eventHandlers[event];
            return !!handler && handler.hasSubscribers;
        };
        EventHandlers.prototype.register = function (event, fn, atTheBeginning) {
            if (atTheBeginning === void 0) { atTheBeginning = false; }
            if (!this.eventHandlers) {
                this.eventHandlers = {};
            }
            var handler = this.eventHandlers[event];
            if (!handler) {
                handler = this.eventHandlers[event] = new EventHandler();
            }
            return handler.register(fn, atTheBeginning);
        };
        EventHandlers.prototype.has = function (event, fn) {
            var handler = this.eventHandlers && this.eventHandlers[event];
            return !!handler && handler.has(fn);
        };
        EventHandlers.prototype.unregister = function (event, fn) {
            var handler = this.eventHandlers && this.eventHandlers[event];
            if (handler) {
                handler.unregister(fn);
            }
        };
        EventHandlers.prototype.clear = function (event) {
            if (this.eventHandlers) {
                delete this.eventHandlers[event];
            }
        };
        EventHandlers.prototype.clearAll = function () {
            this.eventHandlers = undefined;
        };
        EventHandlers.prototype.emit = function (event) {
            var _a;
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            var handler = this.eventHandlers && this.eventHandlers[event];
            if (handler) {
                (_a = handler).emit.apply(_a, __spread(args));
            }
        };
        return EventHandlers;
    }());
    /**
     * @internal
     * @hidden
     */
    function argsToArray(args) {
        var res = new Array(args.length);
        for (var i = 0; i < args.length; i++)
            res[i] = args[i];
        return res;
    }
    /**
     * @internal
     * @hidden
     */
    function invalidateComputed(target, propName) {
        var atom = mobx.getAtom(target, propName);
        atom.trackAndCompute();
    }
    /**
     * @internal
     * @hidden
     */
    function stringStartsWith(str, beginning) {
        return str.indexOf(beginning) === 0;
    }
    /**
     * @internal
     * @hidden
     */
    var deprecated = function (id, message) {
        // warn if hasn't been warned before
        if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
            warnError("Deprecation warning: " + message);
        }
        // mark as warned to avoid duplicate warn message
        if (deprecated.ids)
            deprecated.ids[id] = true;
    };
    deprecated.ids = {};
    /**
     * @internal
     * @hidden
     */
    function warnError(msg) {
        console.warn(new Error("[mobx-state-tree] " + msg));
    }
    /**
     * @internal
     * @hidden
     */
    function assertArg(value, fn, typeName, argNumber) {
        {
            if (!fn(value)) {
                // istanbul ignore next
                throw fail$1("expected " + typeName + " as argument " + asArray(argNumber).join(" or ") + ", got " + value + " instead");
            }
        }
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsFunction(value, argNumber) {
        assertArg(value, function (fn) { return typeof fn === "function"; }, "function", argNumber);
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsNumber(value, argNumber, min, max) {
        assertArg(value, function (n) { return typeof n === "number"; }, "number", argNumber);
        if (min !== undefined) {
            assertArg(value, function (n) { return n >= min; }, "number greater than " + min, argNumber);
        }
        if (max !== undefined) {
            assertArg(value, function (n) { return n <= max; }, "number lesser than " + max, argNumber);
        }
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsString(value, argNumber, canBeEmpty) {
        if (canBeEmpty === void 0) { canBeEmpty = true; }
        assertArg(value, function (s) { return typeof s === "string"; }, "string", argNumber);
        if (!canBeEmpty) {
            assertArg(value, function (s) { return s !== ""; }, "not empty string", argNumber);
        }
    }

    /**
     * See [asynchronous actions](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/async-actions.md).
     *
     * @returns The flow as a promise.
     */
    function flow(generator) {
        return createFlowSpawner(generator.name, generator);
    }
    /**
     * @deprecated Not needed since TS3.6.
     * Used for TypeScript to make flows that return a promise return the actual promise result.
     *
     * @param val
     * @returns
     */
    function castFlowReturn(val) {
        return val;
    }
    /**
     * @internal
     * @hidden
     */
    function createFlowSpawner(name, generator) {
        var spawner = function flowSpawner() {
            // Implementation based on https://github.com/tj/co/blob/master/index.js
            var runId = getNextActionId();
            var parentContext = getCurrentActionContext();
            if (!parentContext) {
                throw fail$1("a mst flow must always have a parent context");
            }
            var parentActionContext = getParentActionContext(parentContext);
            if (!parentActionContext) {
                throw fail$1("a mst flow must always have a parent action context");
            }
            var contextBase = {
                name: name,
                id: runId,
                tree: parentContext.tree,
                context: parentContext.context,
                parentId: parentContext.id,
                allParentIds: __spread(parentContext.allParentIds, [parentContext.id]),
                rootId: parentContext.rootId,
                parentEvent: parentContext,
                parentActionEvent: parentActionContext
            };
            var args = arguments;
            function wrap(fn, type, arg) {
                fn.$mst_middleware = spawner.$mst_middleware; // pick up any middleware attached to the flow
                runWithActionContext(__assign(__assign({}, contextBase), { type: type, args: [arg] }), fn);
            }
            return new Promise(function (resolve, reject) {
                var gen;
                var init = function asyncActionInit() {
                    gen = generator.apply(null, arguments);
                    onFulfilled(undefined); // kick off the flow
                };
                init.$mst_middleware = spawner.$mst_middleware;
                runWithActionContext(__assign(__assign({}, contextBase), { type: "flow_spawn", args: argsToArray(args) }), init);
                function onFulfilled(res) {
                    var ret;
                    try {
                        // prettier-ignore
                        wrap(function (r) { ret = gen.next(r); }, "flow_resume", res);
                    }
                    catch (e) {
                        // prettier-ignore
                        setImmediate(function () {
                            wrap(function (r) { reject(e); }, "flow_throw", e);
                        });
                        return;
                    }
                    next(ret);
                    return;
                }
                function onRejected(err) {
                    var ret;
                    try {
                        // prettier-ignore
                        wrap(function (r) { ret = gen.throw(r); }, "flow_resume_error", err); // or yieldError?
                    }
                    catch (e) {
                        // prettier-ignore
                        setImmediate(function () {
                            wrap(function (r) { reject(e); }, "flow_throw", e);
                        });
                        return;
                    }
                    next(ret);
                }
                function next(ret) {
                    if (ret.done) {
                        // prettier-ignore
                        setImmediate(function () {
                            wrap(function (r) { resolve(r); }, "flow_return", ret.value);
                        });
                        return;
                    }
                    // TODO: support more type of values? See https://github.com/tj/co/blob/249bbdc72da24ae44076afd716349d2089b31c4c/index.js#L100
                    if (!ret.value || typeof ret.value.then !== "function") {
                        // istanbul ignore next
                        throw fail$1("Only promises can be yielded to `async`, got: " + ret);
                    }
                    return ret.value.then(onFulfilled, onRejected);
                }
            });
        };
        return spawner;
    }

    /**
     * @internal
     * @hidden
     */
    function splitPatch(patch) {
        if (!("oldValue" in patch))
            throw fail$1("Patches without `oldValue` field cannot be inversed");
        return [stripPatch(patch), invertPatch(patch)];
    }
    /**
     * @internal
     * @hidden
     */
    function stripPatch(patch) {
        // strips `oldvalue` information from the patch, so that it becomes a patch conform the json-patch spec
        // this removes the ability to undo the patch
        switch (patch.op) {
            case "add":
                return { op: "add", path: patch.path, value: patch.value };
            case "remove":
                return { op: "remove", path: patch.path };
            case "replace":
                return { op: "replace", path: patch.path, value: patch.value };
        }
    }
    function invertPatch(patch) {
        switch (patch.op) {
            case "add":
                return {
                    op: "remove",
                    path: patch.path
                };
            case "remove":
                return {
                    op: "add",
                    path: patch.path,
                    value: patch.oldValue
                };
            case "replace":
                return {
                    op: "replace",
                    path: patch.path,
                    value: patch.oldValue
                };
        }
    }
    /**
     * Simple simple check to check it is a number.
     */
    function isNumber(x) {
        return typeof x === "number";
    }
    /**
     * Escape slashes and backslashes.
     *
     * http://tools.ietf.org/html/rfc6901
     */
    function escapeJsonPath(path) {
        if (isNumber(path) === true) {
            return "" + path;
        }
        if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
            return path;
        return path.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    /**
     * Unescape slashes and backslashes.
     */
    function unescapeJsonPath(path) {
        return path.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    /**
     * Generates a json-path compliant json path from path parts.
     *
     * @param path
     * @returns
     */
    function joinJsonPath(path) {
        // `/` refers to property with an empty name, while `` refers to root itself!
        if (path.length === 0)
            return "";
        var getPathStr = function (p) { return p.map(escapeJsonPath).join("/"); };
        if (path[0] === "." || path[0] === "..") {
            // relative
            return getPathStr(path);
        }
        else {
            // absolute
            return "/" + getPathStr(path);
        }
    }
    /**
     * Splits and decodes a json path into several parts.
     *
     * @param path
     * @returns
     */
    function splitJsonPath(path) {
        // `/` refers to property with an empty name, while `` refers to root itself!
        var parts = path.split("/").map(unescapeJsonPath);
        var valid = path === "" ||
            path === "." ||
            path === ".." ||
            stringStartsWith(path, "/") ||
            stringStartsWith(path, "./") ||
            stringStartsWith(path, "../");
        if (!valid) {
            throw fail$1("a json path must be either rooted, empty or relative, but got '" + path + "'");
        }
        // '/a/b/c' -> ["a", "b", "c"]
        // '../../b/c' -> ["..", "..", "b", "c"]
        // '' -> []
        // '/' -> ['']
        // './a' -> [".", "a"]
        // /./a' -> [".", "a"] equivalent to './a'
        if (parts[0] === "") {
            parts.shift();
        }
        return parts;
    }

    var SnapshotProcessor = /** @class */ (function (_super) {
        __extends(SnapshotProcessor, _super);
        function SnapshotProcessor(_subtype, _processors, name) {
            var _this = _super.call(this, name || _subtype.name) || this;
            _this._subtype = _subtype;
            _this._processors = _processors;
            return _this;
        }
        Object.defineProperty(SnapshotProcessor.prototype, "flags", {
            get: function () {
                return this._subtype.flags | TypeFlags.SnapshotProcessor;
            },
            enumerable: true,
            configurable: true
        });
        SnapshotProcessor.prototype.describe = function () {
            return "snapshotProcessor(" + this._subtype.describe() + ")";
        };
        SnapshotProcessor.prototype.preProcessSnapshot = function (sn) {
            if (this._processors.preProcessor) {
                return this._processors.preProcessor.call(null, sn);
            }
            return sn;
        };
        SnapshotProcessor.prototype.postProcessSnapshot = function (sn) {
            if (this._processors.postProcessor) {
                return this._processors.postProcessor.call(null, sn);
            }
            return sn;
        };
        SnapshotProcessor.prototype._fixNode = function (node) {
            var _this = this;
            // the node has to use these methods rather than the original type ones
            proxyNodeTypeMethods(node.type, this, "isAssignableFrom", "create");
            var oldGetSnapshot = node.getSnapshot;
            node.getSnapshot = function () {
                return _this.postProcessSnapshot(oldGetSnapshot.call(node));
            };
        };
        SnapshotProcessor.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            var processedInitialValue = isStateTreeNode(initialValue)
                ? initialValue
                : this.preProcessSnapshot(initialValue);
            var node = this._subtype.instantiate(parent, subpath, environment, processedInitialValue);
            this._fixNode(node);
            return node;
        };
        SnapshotProcessor.prototype.reconcile = function (current, newValue, parent, subpath) {
            var node = this._subtype.reconcile(current, isStateTreeNode(newValue) ? newValue : this.preProcessSnapshot(newValue), parent, subpath);
            if (node !== current) {
                this._fixNode(node);
            }
            return node;
        };
        SnapshotProcessor.prototype.getSnapshot = function (node, applyPostProcess) {
            if (applyPostProcess === void 0) { applyPostProcess = true; }
            var sn = this._subtype.getSnapshot(node);
            return applyPostProcess ? this.postProcessSnapshot(sn) : sn;
        };
        SnapshotProcessor.prototype.isValidSnapshot = function (value, context) {
            var processedSn = this.preProcessSnapshot(value);
            return this._subtype.validate(processedSn, context);
        };
        SnapshotProcessor.prototype.getSubTypes = function () {
            return this._subtype;
        };
        SnapshotProcessor.prototype.is = function (thing) {
            return (this._subtype.validate(isType(thing) ? this._subtype : this.preProcessSnapshot(thing), [
                { path: "", type: this._subtype }
            ]).length === 0);
        };
        return SnapshotProcessor;
    }(BaseType));
    function proxyNodeTypeMethods(nodeType, snapshotProcessorType) {
        var e_1, _a;
        var methods = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            methods[_i - 2] = arguments[_i];
        }
        try {
            for (var methods_1 = __values(methods), methods_1_1 = methods_1.next(); !methods_1_1.done; methods_1_1 = methods_1.next()) {
                var method = methods_1_1.value;
                nodeType[method] = snapshotProcessorType[method].bind(snapshotProcessorType);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (methods_1_1 && !methods_1_1.done && (_a = methods_1.return)) _a.call(methods_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    }
    /**
     * `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(sn: BackendTodo) {
     *         return {
     *             text: sn.text || "";
     *         }
     *     },
     *     // from instance to snapshot
     *     postProcessor(sn): 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) {
        assertIsType(type, 1);
        {
            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);
    }

    var needsIdentifierError = "Map.put can only be used to store complex values that have an identifier type attribute";
    function tryCollectModelTypes(type, modelTypes) {
        var e_1, _a;
        var subtypes = type.getSubTypes();
        if (subtypes === cannotDetermineSubtype) {
            return false;
        }
        if (subtypes) {
            var subtypesArray = asArray(subtypes);
            try {
                for (var subtypesArray_1 = __values(subtypesArray), subtypesArray_1_1 = subtypesArray_1.next(); !subtypesArray_1_1.done; subtypesArray_1_1 = subtypesArray_1.next()) {
                    var subtype = subtypesArray_1_1.value;
                    if (!tryCollectModelTypes(subtype, modelTypes))
                        return false;
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (subtypesArray_1_1 && !subtypesArray_1_1.done && (_a = subtypesArray_1.return)) _a.call(subtypesArray_1);
                }
                finally { if (e_1) throw e_1.error; }
            }
        }
        if (type instanceof ModelType) {
            modelTypes.push(type);
        }
        return true;
    }
    /**
     * @internal
     * @hidden
     */
    var MapIdentifierMode;
    (function (MapIdentifierMode) {
        MapIdentifierMode[MapIdentifierMode["UNKNOWN"] = 0] = "UNKNOWN";
        MapIdentifierMode[MapIdentifierMode["YES"] = 1] = "YES";
        MapIdentifierMode[MapIdentifierMode["NO"] = 2] = "NO";
    })(MapIdentifierMode || (MapIdentifierMode = {}));
    var MSTMap = /** @class */ (function (_super) {
        __extends(MSTMap, _super);
        function MSTMap(initialData) {
            return _super.call(this, initialData, mobx.observable.ref.enhancer) || this;
        }
        MSTMap.prototype.get = function (key) {
            // maybe this is over-enthousiastic? normalize numeric keys to strings
            return _super.prototype.get.call(this, "" + key);
        };
        MSTMap.prototype.has = function (key) {
            return _super.prototype.has.call(this, "" + key);
        };
        MSTMap.prototype.delete = function (key) {
            return _super.prototype.delete.call(this, "" + key);
        };
        MSTMap.prototype.set = function (key, value) {
            return _super.prototype.set.call(this, "" + key, value);
        };
        MSTMap.prototype.put = function (value) {
            if (!value)
                throw fail$1("Map.put cannot be used to set empty values");
            if (isStateTreeNode(value)) {
                var node = getStateTreeNode(value);
                {
                    if (!node.identifierAttribute) {
                        throw fail$1(needsIdentifierError);
                    }
                }
                if (node.identifier === null) {
                    throw fail$1(needsIdentifierError);
                }
                this.set(node.identifier, value);
                return value;
            }
            else if (!isMutable(value)) {
                throw fail$1("Map.put can only be used to store complex values");
            }
            else {
                var mapNode = getStateTreeNode(this);
                var mapType = mapNode.type;
                if (mapType.identifierMode !== MapIdentifierMode.YES) {
                    throw fail$1(needsIdentifierError);
                }
                var idAttr = mapType.mapIdentifierAttribute;
                var id = value[idAttr];
                if (!isValidIdentifier(id)) {
                    // try again but this time after creating a node for the value
                    // since it might be an optional identifier
                    var newNode = this.put(mapType.getChildType().create(value, mapNode.environment));
                    return this.put(getSnapshot(newNode));
                }
                var key = normalizeIdentifier(id);
                this.set(key, value);
                return this.get(key);
            }
        };
        return MSTMap;
    }(mobx.ObservableMap));
    /**
     * @internal
     * @hidden
     */
    var MapType = /** @class */ (function (_super) {
        __extends(MapType, _super);
        function MapType(name, _subType, hookInitializers) {
            if (hookInitializers === void 0) { hookInitializers = []; }
            var _this = _super.call(this, name) || this;
            _this._subType = _subType;
            _this.identifierMode = MapIdentifierMode.UNKNOWN;
            _this.mapIdentifierAttribute = undefined;
            _this.flags = TypeFlags.Map;
            _this.hookInitializers = [];
            _this._determineIdentifierMode();
            _this.hookInitializers = hookInitializers;
            return _this;
        }
        MapType.prototype.hooks = function (hooks) {
            var hookInitializers = this.hookInitializers.length > 0 ? this.hookInitializers.concat(hooks) : [hooks];
            return new MapType(this.name, this._subType, hookInitializers);
        };
        MapType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            this._determineIdentifierMode();
            return createObjectNode(this, parent, subpath, environment, initialValue);
        };
        MapType.prototype._determineIdentifierMode = function () {
            if (this.identifierMode !== MapIdentifierMode.UNKNOWN) {
                return;
            }
            var modelTypes = [];
            if (tryCollectModelTypes(this._subType, modelTypes)) {
                var identifierAttribute_1 = undefined;
                modelTypes.forEach(function (type) {
                    if (type.identifierAttribute) {
                        if (identifierAttribute_1 && identifierAttribute_1 !== type.identifierAttribute) {
                            throw fail$1("The objects in a map should all have the same identifier attribute, expected '" + identifierAttribute_1 + "', but child of type '" + type.name + "' declared attribute '" + type.identifierAttribute + "' as identifier");
                        }
                        identifierAttribute_1 = type.identifierAttribute;
                    }
                });
                if (identifierAttribute_1) {
                    this.identifierMode = MapIdentifierMode.YES;
                    this.mapIdentifierAttribute = identifierAttribute_1;
                }
                else {
                    this.identifierMode = MapIdentifierMode.NO;
                }
            }
        };
        MapType.prototype.initializeChildNodes = function (objNode, initialSnapshot) {
            if (initialSnapshot === void 0) { initialSnapshot = {}; }
            var subType = objNode.type._subType;
            var result = {};
            Object.keys(initialSnapshot).forEach(function (name) {
                result[name] = subType.instantiate(objNode, name, undefined, initialSnapshot[name]);
            });
            return result;
        };
        MapType.prototype.createNewInstance = function (childNodes) {
            return new MSTMap(childNodes);
        };
        MapType.prototype.finalizeNewInstance = function (node, instance) {
            mobx._interceptReads(instance, node.unbox);
            var type = node.type;
            type.hookInitializers.forEach(function (initializer) {
                var hooks = initializer(instance);
                Object.keys(hooks).forEach(function (name) {
                    var hook = hooks[name];
                    var actionInvoker = createActionInvoker(instance, name, hook);
                    ( addHiddenWritableProp)(instance, name, actionInvoker);
                });
            });
            mobx.intercept(instance, this.willChange);
            mobx.observe(instance, this.didChange);
        };
        MapType.prototype.describe = function () {
            return "Map<string, " + this._subType.describe() + ">";
        };
        MapType.prototype.getChildren = function (node) {
            // return (node.storedValue as ObservableMap<any>).values()
            return mobx.values(node.storedValue);
        };
        MapType.prototype.getChildNode = function (node, key) {
            var childNode = node.storedValue.get("" + key);
            if (!childNode)
                throw fail$1("Not a child " + key);
            return childNode;
        };
        MapType.prototype.willChange = function (change) {
            var node = getStateTreeNode(change.object);
            var key = change.name;
            node.assertWritable({ subpath: key });
            var mapType = node.type;
            var subType = mapType._subType;
            switch (change.type) {
                case "update":
                    {
                        var newValue = change.newValue;
                        var oldValue = change.object.get(key);
                        if (newValue === oldValue)
                            return null;
                        typecheckInternal(subType, newValue);
                        change.newValue = subType.reconcile(node.getChildNode(key), change.newValue, node, key);
                        mapType.processIdentifier(key, change.newValue);
                    }
                    break;
                case "add":
                    {
                        typecheckInternal(subType, change.newValue);
                        change.newValue = subType.instantiate(node, key, undefined, change.newValue);
                        mapType.processIdentifier(key, change.newValue);
                    }
                    break;
            }
            return change;
        };
        MapType.prototype.processIdentifier = function (expected, node) {
            if (this.identifierMode === MapIdentifierMode.YES && node instanceof ObjectNode) {
                var identifier = node.identifier;
                if (identifier !== expected)
                    throw fail$1("A map of objects containing an identifier should always store the object under their own identifier. Trying to store key '" + identifier + "', but expected: '" + expected + "'");
            }
        };
        MapType.prototype.getSnapshot = function (node) {
            var res = {};
            node.getChildren().forEach(function (childNode) {
                res[childNode.subpath] = childNode.snapshot;
            });
            return res;
        };
        MapType.prototype.processInitialSnapshot = function (childNodes) {
            var processed = {};
            Object.keys(childNodes).forEach(function (key) {
                processed[key] = childNodes[key].getSnapshot();
            });
            return processed;
        };
        MapType.prototype.didChange = function (change) {
            var node = getStateTreeNode(change.object);
            switch (change.type) {
                case "update":
                    return void node.emitPatch({
                        op: "replace",
                        path: escapeJsonPath(change.name),
                        value: change.newValue.snapshot,
                        oldValue: change.oldValue ? change.oldValue.snapshot : undefined
                    }, node);
                case "add":
                    return void node.emitPatch({
                        op: "add",
                        path: escapeJsonPath(change.name),
                        value: change.newValue.snapshot,
                        oldValue: undefined
                    }, node);
                case "delete":
                    // a node got deleted, get the old snapshot and make the node die
                    var oldSnapshot = change.oldValue.snapshot;
                    change.oldValue.die();
                    // emit the patch
                    return void node.emitPatch({
                        op: "remove",
                        path: escapeJsonPath(change.name),
                        oldValue: oldSnapshot
                    }, node);
            }
        };
        MapType.prototype.applyPatchLocally = function (node, subpath, patch) {
            var target = node.storedValue;
            switch (patch.op) {
                case "add":
                case "replace":
                    target.set(subpath, patch.value);
                    break;
                case "remove":
                    target.delete(subpath);
                    break;
            }
        };
        MapType.prototype.applySnapshot = function (node, snapshot) {
            typecheckInternal(this, snapshot);
            var target = node.storedValue;
            var currentKeys = {};
            Array.from(target.keys()).forEach(function (key) {
                currentKeys[key] = false;
            });
            if (snapshot) {
                // Don't use target.replace, as it will throw away all existing items first
                for (var key in snapshot) {
                    target.set(key, snapshot[key]);
                    currentKeys["" + key] = true;
                }
            }
            Object.keys(currentKeys).forEach(function (key) {
                if (currentKeys[key] === false)
                    target.delete(key);
            });
        };
        MapType.prototype.getChildType = function () {
            return this._subType;
        };
        MapType.prototype.isValidSnapshot = function (value, context) {
            var _this = this;
            if (!isPlainObject(value)) {
                return typeCheckFailure(context, value, "Value is not a plain object");
            }
            return flattenTypeErrors(Object.keys(value).map(function (path) {
                return _this._subType.validate(value[path], getContextForPath(context, path, _this._subType));
            }));
        };
        MapType.prototype.getDefaultSnapshot = function () {
            return EMPTY_OBJECT;
        };
        MapType.prototype.removeChild = function (node, subpath) {
            node.storedValue.delete(subpath);
        };
        __decorate([
            mobx.action
        ], MapType.prototype, "applySnapshot", null);
        return MapType;
    }(ComplexType));
    /**
     * `types.map` - Creates a key based collection type who's children are all of a uniform declared type.
     * If the type stored in a map has an identifier, it is mandatory to store the child under that identifier in the map.
     *
     * This type will always produce [observable maps](https://mobx.js.org/refguide/map.html)
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *   id: types.identifier,
     *   task: types.string
     * })
     *
     * const TodoStore = types.model({
     *   todos: types.map(Todo)
     * })
     *
     * const s = TodoStore.create({ todos: {} })
     * unprotect(s)
     * s.todos.set(17, { task: "Grab coffee", id: 17 })
     * s.todos.put({ task: "Grab cookie", id: 18 }) // put will infer key from the identifier
     * console.log(s.todos.get(17).task) // prints: "Grab coffee"
     * ```
     *
     * @param subtype
     * @returns
     */
    function map(subtype) {
        return new MapType("map<string, " + subtype.name + ">", subtype);
    }
    /**
     * Returns if a given value represents a map type.
     *
     * @param type
     * @returns `true` if it is a map type.
     */
    function isMapType(type) {
        return isType(type) && (type.flags & TypeFlags.Map) > 0;
    }

    /**
     * @internal
     * @hidden
     */
    var ArrayType = /** @class */ (function (_super) {
        __extends(ArrayType, _super);
        function ArrayType(name, _subType, hookInitializers) {
            if (hookInitializers === void 0) { hookInitializers = []; }
            var _this = _super.call(this, name) || this;
            _this._subType = _subType;
            _this.flags = TypeFlags.Array;
            _this.hookInitializers = [];
            _this.hookInitializers = hookInitializers;
            return _this;
        }
        ArrayType.prototype.hooks = function (hooks) {
            var hookInitializers = this.hookInitializers.length > 0 ? this.hookInitializers.concat(hooks) : [hooks];
            return new ArrayType(this.name, this._subType, hookInitializers);
        };
        ArrayType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            return createObjectNode(this, parent, subpath, environment, initialValue);
        };
        ArrayType.prototype.initializeChildNodes = function (objNode, snapshot) {
            if (snapshot === void 0) { snapshot = []; }
            var subType = objNode.type._subType;
            var result = {};
            snapshot.forEach(function (item, index) {
                var subpath = "" + index;
                result[subpath] = subType.instantiate(objNode, subpath, undefined, item);
            });
            return result;
        };
        ArrayType.prototype.createNewInstance = function (childNodes) {
            return mobx.observable.array(convertChildNodesToArray(childNodes), mobxShallow);
        };
        ArrayType.prototype.finalizeNewInstance = function (node, instance) {
            mobx._getAdministration(instance).dehancer = node.unbox;
            var type = node.type;
            type.hookInitializers.forEach(function (initializer) {
                var hooks = initializer(instance);
                Object.keys(hooks).forEach(function (name) {
                    var hook = hooks[name];
                    var actionInvoker = createActionInvoker(instance, name, hook);
                    ( addHiddenWritableProp)(instance, name, actionInvoker);
                });
            });
            mobx.intercept(instance, this.willChange);
            mobx.observe(instance, this.didChange);
        };
        ArrayType.prototype.describe = function () {
            return this._subType.describe() + "[]";
        };
        ArrayType.prototype.getChildren = function (node) {
            return node.storedValue.slice();
        };
        ArrayType.prototype.getChildNode = function (node, key) {
            var index = Number(key);
            if (index < node.storedValue.length)
                return node.storedValue[index];
            throw fail$1("Not a child: " + key);
        };
        ArrayType.prototype.willChange = function (change) {
            var node = getStateTreeNode(change.object);
            node.assertWritable({ subpath: "" + change.index });
            var subType = node.type._subType;
            var childNodes = node.getChildren();
            switch (change.type) {
                case "update":
                    {
                        if (change.newValue === change.object[change.index])
                            return null;
                        var updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], [change.index]);
                        if (!updatedNodes) {
                            return null;
                        }
                        change.newValue = updatedNodes[0];
                    }
                    break;
                case "splice":
                    {
                        var index_1 = change.index, removedCount = change.removedCount, added = change.added;
                        var addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index_1, index_1 + removedCount), added, added.map(function (_, i) { return index_1 + i; }));
                        if (!addedNodes) {
                            return null;
                        }
                        change.added = addedNodes;
                        // update paths of remaining items
                        for (var i = index_1 + removedCount; i < childNodes.length; i++) {
                            childNodes[i].setParent(node, "" + (i + added.length - removedCount));
                        }
                    }
                    break;
            }
            return change;
        };
        ArrayType.prototype.getSnapshot = function (node) {
            return node.getChildren().map(function (childNode) { return childNode.snapshot; });
        };
        ArrayType.prototype.processInitialSnapshot = function (childNodes) {
            var processed = [];
            Object.keys(childNodes).forEach(function (key) {
                processed.push(childNodes[key].getSnapshot());
            });
            return processed;
        };
        ArrayType.prototype.didChange = function (change) {
            var node = getStateTreeNode(change.object);
            switch (change.type) {
                case "update":
                    return void node.emitPatch({
                        op: "replace",
                        path: "" + change.index,
                        value: change.newValue.snapshot,
                        oldValue: change.oldValue ? change.oldValue.snapshot : undefined
                    }, node);
                case "splice":
                    for (var i = change.removedCount - 1; i >= 0; i--)
                        node.emitPatch({
                            op: "remove",
                            path: "" + (change.index + i),
                            oldValue: change.removed[i].snapshot
                        }, node);
                    for (var i = 0; i < change.addedCount; i++)
                        node.emitPatch({
                            op: "add",
                            path: "" + (change.index + i),
                            value: node.getChildNode("" + (change.index + i)).snapshot,
                            oldValue: undefined
                        }, node);
                    return;
            }
        };
        ArrayType.prototype.applyPatchLocally = function (node, subpath, patch) {
            var target = node.storedValue;
            var index = subpath === "-" ? target.length : Number(subpath);
            switch (patch.op) {
                case "replace":
                    target[index] = patch.value;
                    break;
                case "add":
                    target.splice(index, 0, patch.value);
                    break;
                case "remove":
                    target.splice(index, 1);
                    break;
            }
        };
        ArrayType.prototype.applySnapshot = function (node, snapshot) {
            typecheckInternal(this, snapshot);
            var target = node.storedValue;
            target.replace(snapshot);
        };
        ArrayType.prototype.getChildType = function () {
            return this._subType;
        };
        ArrayType.prototype.isValidSnapshot = function (value, context) {
            var _this = this;
            if (!isArray(value)) {
                return typeCheckFailure(context, value, "Value is not an array");
            }
            return flattenTypeErrors(value.map(function (item, index) {
                return _this._subType.validate(item, getContextForPath(context, "" + index, _this._subType));
            }));
        };
        ArrayType.prototype.getDefaultSnapshot = function () {
            return EMPTY_ARRAY;
        };
        ArrayType.prototype.removeChild = function (node, subpath) {
            node.storedValue.splice(Number(subpath), 1);
        };
        __decorate([
            mobx.action
        ], ArrayType.prototype, "applySnapshot", null);
        return ArrayType;
    }(ComplexType));
    /**
     * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
     *
     * This type will always produce [observable arrays](https://mobx.js.org/refguide/array.html)
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *   task: types.string
     * })
     *
     * const TodoStore = types.model({
     *   todos: types.array(Todo)
     * })
     *
     * const s = TodoStore.create({ todos: [] })
     * unprotect(s) // needed to allow modifying outside of an action
     * s.todos.push({ task: "Grab coffee" })
     * console.log(s.todos[0]) // prints: "Grab coffee"
     * ```
     *
     * @param subtype
     * @returns
     */
    function array(subtype) {
        assertIsType(subtype, 1);
        return new ArrayType(subtype.name + "[]", subtype);
    }
    function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
        var nothingChanged = true;
        for (var i = 0;; i++) {
            var hasNewNode = i <= newValues.length - 1;
            var oldNode = oldNodes[i];
            var newValue = hasNewNode ? newValues[i] : undefined;
            var newPath = "" + newPaths[i];
            // for some reason, instead of newValue we got a node, fallback to the storedValue
            // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
            if (isNode(newValue))
                newValue = newValue.storedValue;
            if (!oldNode && !hasNewNode) {
                // both are empty, end
                break;
            }
            else if (!hasNewNode) {
                // new one does not exists
                nothingChanged = false;
                oldNodes.splice(i, 1);
                if (oldNode instanceof ObjectNode) {
                    // since it is going to be returned by pop/splice/shift better create it before killing it
                    // so it doesn't end up in an undead state
                    oldNode.createObservableInstanceIfNeeded();
                }
                oldNode.die();
                i--;
            }
            else if (!oldNode) {
                // there is no old node, create it
                // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.
                if (isStateTreeNode(newValue) && getStateTreeNode(newValue).parent === parent) {
                    // this node is owned by this parent, but not in the reconcilable set, so it must be double
                    throw fail$1("Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '" + parent.path + "/" + newPath + "', but it lives already at '" + getStateTreeNode(newValue).path + "'");
                }
                nothingChanged = false;
                var newNode = valueAsNode(childType, parent, newPath, newValue);
                oldNodes.splice(i, 0, newNode);
            }
            else if (areSame(oldNode, newValue)) {
                // both are the same, reconcile
                oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
            }
            else {
                // nothing to do, try to reorder
                var oldMatch = undefined;
                // find a possible candidate to reuse
                for (var j = i; j < oldNodes.length; j++) {
                    if (areSame(oldNodes[j], newValue)) {
                        oldMatch = oldNodes.splice(j, 1)[0];
                        break;
                    }
                }
                nothingChanged = false;
                var newNode = valueAsNode(childType, parent, newPath, newValue, oldMatch);
                oldNodes.splice(i, 0, newNode);
            }
        }
        return nothingChanged ? null : oldNodes;
    }
    /**
     * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.
     */
    function valueAsNode(childType, parent, subpath, newValue, oldNode) {
        // ensure the value is valid-ish
        typecheckInternal(childType, newValue);
        function getNewNode() {
            // the new value has a MST node
            if (isStateTreeNode(newValue)) {
                var childNode = getStateTreeNode(newValue);
                childNode.assertAlive(EMPTY_OBJECT);
                // the node lives here
                if (childNode.parent !== null && childNode.parent === parent) {
                    childNode.setParent(parent, subpath);
                    return childNode;
                }
            }
            // there is old node and new one is a value/snapshot
            if (oldNode) {
                return childType.reconcile(oldNode, newValue, parent, subpath);
            }
            // nothing to do, create from scratch
            return childType.instantiate(parent, subpath, undefined, newValue);
        }
        var newNode = getNewNode();
        if (oldNode && oldNode !== newNode) {
            if (oldNode instanceof ObjectNode) {
                // since it is going to be returned by pop/splice/shift better create it before killing it
                // so it doesn't end up in an undead state
                oldNode.createObservableInstanceIfNeeded();
            }
            oldNode.die();
        }
        return newNode;
    }
    /**
     * Check if a node holds a value.
     */
    function areSame(oldNode, newValue) {
        // never consider dead old nodes for reconciliation
        if (!oldNode.isAlive) {
            return false;
        }
        // the new value has the same node
        if (isStateTreeNode(newValue)) {
            var newNode = getStateTreeNode(newValue);
            return newNode.isAlive && newNode === oldNode;
        }
        // the provided value is the snapshot of the old node
        if (oldNode.snapshot === newValue) {
            return true;
        }
        // new value is a snapshot with the correct identifier
        return (oldNode instanceof ObjectNode &&
            oldNode.identifier !== null &&
            oldNode.identifierAttribute &&
            isPlainObject(newValue) &&
            oldNode.identifier === normalizeIdentifier(newValue[oldNode.identifierAttribute]) &&
            oldNode.type.is(newValue));
    }
    /**
     * Returns if a given value represents an array type.
     *
     * @param type
     * @returns `true` if the type is an array type.
     */
    function isArrayType(type) {
        return isType(type) && (type.flags & TypeFlags.Array) > 0;
    }

    var PRE_PROCESS_SNAPSHOT = "preProcessSnapshot";
    var POST_PROCESS_SNAPSHOT = "postProcessSnapshot";
    function objectTypeToString() {
        return getStateTreeNode(this).toString();
    }
    var defaultObjectOptions = {
        name: "AnonymousModel",
        properties: {},
        initializers: EMPTY_ARRAY
    };
    function toPropertiesObject(declaredProps) {
        // loop through properties and ensures that all items are types
        return Object.keys(declaredProps).reduce(function (props, key) {
            var _a, _b, _c;
            // warn if user intended a HOOK
            if (key in Hook)
                throw fail$1("Hook '" + key + "' was defined as property. Hooks should be defined as part of the actions");
            // the user intended to use a view
            var descriptor = Object.getOwnPropertyDescriptor(props, key);
            if ("get" in descriptor) {
                throw fail$1("Getters are not supported as properties. Please use views instead");
            }
            // undefined and null are not valid
            var value = descriptor.value;
            if (value === null || value === undefined) {
                throw fail$1("The default value of an attribute cannot be null or undefined as the type cannot be inferred. Did you mean `types.maybe(someType)`?");
                // its a primitive, convert to its type
            }
            else if (isPrimitive(value)) {
                return Object.assign({}, props, (_a = {},
                    _a[key] = optional(getPrimitiveFactoryFromValue(value), value),
                    _a));
                // map defaults to empty object automatically for models
            }
            else if (value instanceof MapType) {
                return Object.assign({}, props, (_b = {},
                    _b[key] = optional(value, {}),
                    _b));
            }
            else if (value instanceof ArrayType) {
                return Object.assign({}, props, (_c = {}, _c[key] = optional(value, []), _c));
                // its already a type
            }
            else if (isType(value)) {
                return props;
                // its a function, maybe the user wanted a view?
            }
            else if ( typeof value === "function") {
                throw fail$1("Invalid type definition for property '" + key + "', it looks like you passed a function. Did you forget to invoke it, or did you intend to declare a view / action?");
                // no other complex values
            }
            else if ( typeof value === "object") {
                throw fail$1("Invalid type definition for property '" + key + "', it looks like you passed an object. Try passing another model type or a types.frozen.");
                // WTF did you pass in mate?
            }
            else {
                throw fail$1("Invalid type definition for property '" + key + "', cannot infer a type from a value like '" + value + "' (" + typeof value + ")");
            }
        }, declaredProps);
    }
    /**
     * @internal
     * @hidden
     */
    var ModelType = /** @class */ (function (_super) {
        __extends(ModelType, _super);
        function ModelType(opts) {
            var _this = _super.call(this, opts.name || defaultObjectOptions.name) || this;
            _this.flags = TypeFlags.Object;
            _this.named = function (name) {
                return _this.cloneAndEnhance({ name: name });
            };
            _this.props = function (properties) {
                return _this.cloneAndEnhance({ properties: properties });
            };
            _this.preProcessSnapshot = function (preProcessor) {
                var currentPreprocessor = _this.preProcessor;
                if (!currentPreprocessor)
                    return _this.cloneAndEnhance({ preProcessor: preProcessor });
                else
                    return _this.cloneAndEnhance({
                        preProcessor: function (snapshot) { return currentPreprocessor(preProcessor(snapshot)); }
                    });
            };
            _this.postProcessSnapshot = function (postProcessor) {
                var currentPostprocessor = _this.postProcessor;
                if (!currentPostprocessor)
                    return _this.cloneAndEnhance({ postProcessor: postProcessor });
                else
                    return _this.cloneAndEnhance({
                        postProcessor: function (snapshot) { return postProcessor(currentPostprocessor(snapshot)); }
                    });
            };
            Object.assign(_this, defaultObjectOptions, opts);
            // ensures that any default value gets converted to its related type
            _this.properties = toPropertiesObject(_this.properties);
            freeze(_this.properties); // make sure nobody messes with it
            _this.propertyNames = Object.keys(_this.properties);
            _this.identifierAttribute = _this._getIdentifierAttribute();
            return _this;
        }
        ModelType.prototype._getIdentifierAttribute = function () {
            var identifierAttribute = undefined;
            this.forAllProps(function (propName, propType) {
                if (propType.flags & TypeFlags.Identifier) {
                    if (identifierAttribute)
                        throw fail$1("Cannot define property '" + propName + "' as object identifier, property '" + identifierAttribute + "' is already defined as identifier property");
                    identifierAttribute = propName;
                }
            });
            return identifierAttribute;
        };
        ModelType.prototype.cloneAndEnhance = function (opts) {
            return new ModelType({
                name: opts.name || this.name,
                properties: Object.assign({}, this.properties, opts.properties),
                initializers: this.initializers.concat(opts.initializers || []),
                preProcessor: opts.preProcessor || this.preProcessor,
                postProcessor: opts.postProcessor || this.postProcessor
            });
        };
        ModelType.prototype.actions = function (fn) {
            var _this = this;
            var actionInitializer = function (self) {
                _this.instantiateActions(self, fn(self));
                return self;
            };
            return this.cloneAndEnhance({ initializers: [actionInitializer] });
        };
        ModelType.prototype.instantiateActions = function (self, actions) {
            // check if return is correct
            if (!isPlainObject(actions))
                throw fail$1("actions initializer should return a plain object containing actions");
            // bind actions to the object created
            Object.keys(actions).forEach(function (name) {
                // warn if preprocessor was given
                if (name === PRE_PROCESS_SNAPSHOT)
                    throw fail$1("Cannot define action '" + PRE_PROCESS_SNAPSHOT + "', it should be defined using 'type.preProcessSnapshot(fn)' instead");
                // warn if postprocessor was given
                if (name === POST_PROCESS_SNAPSHOT)
                    throw fail$1("Cannot define action '" + POST_PROCESS_SNAPSHOT + "', it should be defined using 'type.postProcessSnapshot(fn)' instead");
                var action2 = actions[name];
                // apply hook composition
                var baseAction = self[name];
                if (name in Hook && baseAction) {
                    var specializedAction_1 = action2;
                    action2 = function () {
                        baseAction.apply(null, arguments);
                        specializedAction_1.apply(null, arguments);
                    };
                }
                // the goal of this is to make sure actions using "this" can call themselves,
                // while still allowing the middlewares to register them
                var middlewares = action2.$mst_middleware; // make sure middlewares are not lost
                var boundAction = action2.bind(actions);
                boundAction.$mst_middleware = middlewares;
                var actionInvoker = createActionInvoker(self, name, boundAction);
                actions[name] = actionInvoker;
                ( addHiddenWritableProp)(self, name, actionInvoker);
            });
        };
        ModelType.prototype.volatile = function (fn) {
            var _this = this;
            var stateInitializer = function (self) {
                _this.instantiateVolatileState(self, fn(self));
                return self;
            };
            return this.cloneAndEnhance({ initializers: [stateInitializer] });
        };
        ModelType.prototype.instantiateVolatileState = function (self, state) {
            // check views return
            if (!isPlainObject(state))
                throw fail$1("volatile state initializer should return a plain object containing state");
            mobx.set(self, state);
        };
        ModelType.prototype.extend = function (fn) {
            var _this = this;
            var initializer = function (self) {
                var _a = fn(self), actions = _a.actions, views = _a.views, state = _a.state, rest = __rest(_a, ["actions", "views", "state"]);
                for (var key in rest)
                    throw fail$1("The `extend` function should return an object with a subset of the fields 'actions', 'views' and 'state'. Found invalid key '" + key + "'");
                if (state)
                    _this.instantiateVolatileState(self, state);
                if (views)
                    _this.instantiateViews(self, views);
                if (actions)
                    _this.instantiateActions(self, actions);
                return self;
            };
            return this.cloneAndEnhance({ initializers: [initializer] });
        };
        ModelType.prototype.views = function (fn) {
            var _this = this;
            var viewInitializer = function (self) {
                _this.instantiateViews(self, fn(self));
                return self;
            };
            return this.cloneAndEnhance({ initializers: [viewInitializer] });
        };
        ModelType.prototype.instantiateViews = function (self, views) {
            // check views return
            if (!isPlainObject(views))
                throw fail$1("views initializer should return a plain object containing views");
            Object.keys(views).forEach(function (key) {
                // is this a computed property?
                var descriptor = Object.getOwnPropertyDescriptor(views, key);
                if ("get" in descriptor) {
                    if (mobx.isComputedProp(self, key)) {
                        var computedValue = mobx._getAdministration(self, key);
                        // TODO: mobx currently does not allow redefining computes yet, pending #1121
                        // FIXME: this binds to the internals of mobx!
                        computedValue.derivation = descriptor.get;
                        computedValue.scope = self;
                        if (descriptor.set)
                            computedValue.setter = mobx.action(computedValue.name + "-setter", descriptor.set);
                    }
                    else {
                        mobx.computed(self, key, descriptor, true);
                    }
                }
                else if (typeof descriptor.value === "function") {
                    ( addHiddenWritableProp)(self, key, descriptor.value);
                }
                else {
                    throw fail$1("A view member should either be a function or getter based property");
                }
            });
        };
        ModelType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            var value = isStateTreeNode(initialValue)
                ? initialValue
                : this.applySnapshotPreProcessor(initialValue);
            return createObjectNode(this, parent, subpath, environment, value);
            // Optimization: record all prop- view- and action names after first construction, and generate an optimal base class
            // that pre-reserves all these fields for fast object-member lookups
        };
        ModelType.prototype.initializeChildNodes = function (objNode, initialSnapshot) {
            if (initialSnapshot === void 0) { initialSnapshot = {}; }
            var type = objNode.type;
            var result = {};
            type.forAllProps(function (name, childType) {
                result[name] = childType.instantiate(objNode, name, undefined, initialSnapshot[name]);
            });
            return result;
        };
        ModelType.prototype.createNewInstance = function (childNodes) {
            return mobx.observable.object(childNodes, EMPTY_OBJECT, mobxShallow);
        };
        ModelType.prototype.finalizeNewInstance = function (node, instance) {
            addHiddenFinalProp(instance, "toString", objectTypeToString);
            this.forAllProps(function (name) {
                mobx._interceptReads(instance, name, node.unbox);
            });
            this.initializers.reduce(function (self, fn) { return fn(self); }, instance);
            mobx.intercept(instance, this.willChange);
            mobx.observe(instance, this.didChange);
        };
        ModelType.prototype.willChange = function (chg) {
            // TODO: mobx typings don't seem to take into account that newValue can be set even when removing a prop
            var change = chg;
            var node = getStateTreeNode(change.object);
            var subpath = change.name;
            node.assertWritable({ subpath: subpath });
            var childType = node.type.properties[subpath];
            // only properties are typed, state are stored as-is references
            if (childType) {
                typecheckInternal(childType, change.newValue);
                change.newValue = childType.reconcile(node.getChildNode(subpath), change.newValue, node, subpath);
            }
            return change;
        };
        ModelType.prototype.didChange = function (chg) {
            // TODO: mobx typings don't seem to take into account that newValue can be set even when removing a prop
            var change = chg;
            var childNode = getStateTreeNode(change.object);
            var childType = childNode.type.properties[change.name];
            if (!childType) {
                // don't emit patches for volatile state
                return;
            }
            var oldChildValue = change.oldValue ? change.oldValue.snapshot : undefined;
            childNode.emitPatch({
                op: "replace",
                path: escapeJsonPath(change.name),
                value: change.newValue.snapshot,
                oldValue: oldChildValue
            }, childNode);
        };
        ModelType.prototype.getChildren = function (node) {
            var _this = this;
            var res = [];
            this.forAllProps(function (name) {
                res.push(_this.getChildNode(node, name));
            });
            return res;
        };
        ModelType.prototype.getChildNode = function (node, key) {
            if (!(key in this.properties))
                throw fail$1("Not a value property: " + key);
            var childNode = mobx._getAdministration(node.storedValue, key).value; // TODO: blegh!
            if (!childNode)
                throw fail$1("Node not available for property " + key);
            return childNode;
        };
        ModelType.prototype.getSnapshot = function (node, applyPostProcess) {
            var _this = this;
            if (applyPostProcess === void 0) { applyPostProcess = true; }
            var res = {};
            this.forAllProps(function (name, type) {
                mobx.getAtom(node.storedValue, name).reportObserved();
                res[name] = _this.getChildNode(node, name).snapshot;
            });
            if (applyPostProcess) {
                return this.applySnapshotPostProcessor(res);
            }
            return res;
        };
        ModelType.prototype.processInitialSnapshot = function (childNodes) {
            var processed = {};
            Object.keys(childNodes).forEach(function (key) {
                processed[key] = childNodes[key].getSnapshot();
            });
            return this.applySnapshotPostProcessor(processed);
        };
        ModelType.prototype.applyPatchLocally = function (node, subpath, patch) {
            if (!(patch.op === "replace" || patch.op === "add")) {
                throw fail$1("object does not support operation " + patch.op);
            }
            node.storedValue[subpath] = patch.value;
        };
        ModelType.prototype.applySnapshot = function (node, snapshot) {
            var preProcessedSnapshot = this.applySnapshotPreProcessor(snapshot);
            typecheckInternal(this, preProcessedSnapshot);
            this.forAllProps(function (name) {
                node.storedValue[name] = preProcessedSnapshot[name];
            });
        };
        ModelType.prototype.applySnapshotPreProcessor = function (snapshot) {
            var processor = this.preProcessor;
            return processor ? processor.call(null, snapshot) : snapshot;
        };
        ModelType.prototype.applySnapshotPostProcessor = function (snapshot) {
            var postProcessor = this.postProcessor;
            if (postProcessor)
                return postProcessor.call(null, snapshot);
            return snapshot;
        };
        ModelType.prototype.getChildType = function (propertyName) {
            assertIsString(propertyName, 1);
            return this.properties[propertyName];
        };
        ModelType.prototype.isValidSnapshot = function (value, context) {
            var _this = this;
            var snapshot = this.applySnapshotPreProcessor(value);
            if (!isPlainObject(snapshot)) {
                return typeCheckFailure(context, snapshot, "Value is not a plain object");
            }
            return flattenTypeErrors(this.propertyNames.map(function (key) {
                return _this.properties[key].validate(snapshot[key], getContextForPath(context, key, _this.properties[key]));
            }));
        };
        ModelType.prototype.forAllProps = function (fn) {
            var _this = this;
            this.propertyNames.forEach(function (key) { return fn(key, _this.properties[key]); });
        };
        ModelType.prototype.describe = function () {
            var _this = this;
            // optimization: cache
            return ("{ " +
                this.propertyNames.map(function (key) { return key + ": " + _this.properties[key].describe(); }).join("; ") +
                " }");
        };
        ModelType.prototype.getDefaultSnapshot = function () {
            return EMPTY_OBJECT;
        };
        ModelType.prototype.removeChild = function (node, subpath) {
            node.storedValue[subpath] = undefined;
        };
        __decorate([
            mobx.action
        ], ModelType.prototype, "applySnapshot", null);
        return ModelType;
    }(ComplexType));
    /**
     * `types.model` - Creates a new model type by providing a name, properties, volatile state and actions.
     *
     * See the [model type](https://github.com/mobxjs/mobx-state-tree#creating-models) description or the [getting started](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/getting-started.md#getting-started-1) tutorial.
     */
    function model() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        var name = typeof args[0] === "string" ? args.shift() : "AnonymousModel";
        var properties = args.shift() || {};
        return new ModelType({ name: name, properties: properties });
    }
    /**
     * `types.compose` - Composes a new model from one or more existing model types.
     * This method can be invoked in two forms:
     * Given 2 or more model types, the types are composed into a new Type.
     * Given first parameter as a string and 2 or more model types,
     * the types are composed into a new Type with the given name
     */
    function compose() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        // TODO: just join the base type names if no name is provided
        var hasTypename = typeof args[0] === "string";
        var typeName = hasTypename ? args[0] : "AnonymousModel";
        if (hasTypename) {
            args.shift();
        }
        // check all parameters
        {
            args.forEach(function (type, i) {
                assertArg(type, isModelType, "mobx-state-tree model type", hasTypename ? i + 2 : i + 1);
            });
        }
        return args
            .reduce(function (prev, cur) {
            return prev.cloneAndEnhance({
                name: prev.name + "_" + cur.name,
                properties: cur.properties,
                initializers: cur.initializers,
                preProcessor: function (snapshot) {
                    return cur.applySnapshotPreProcessor(prev.applySnapshotPreProcessor(snapshot));
                },
                postProcessor: function (snapshot) {
                    return cur.applySnapshotPostProcessor(prev.applySnapshotPostProcessor(snapshot));
                }
            });
        })
            .named(typeName);
    }
    /**
     * Returns if a given value represents a model type.
     *
     * @param type
     * @returns
     */
    function isModelType(type) {
        return isType(type) && (type.flags & TypeFlags.Object) > 0;
    }

    // TODO: implement CoreType using types.custom ?
    /**
     * @internal
     * @hidden
     */
    var CoreType = /** @class */ (function (_super) {
        __extends(CoreType, _super);
        function CoreType(name, flags, checker, initializer) {
            if (initializer === void 0) { initializer = identity; }
            var _this = _super.call(this, name) || this;
            _this.flags = flags;
            _this.checker = checker;
            _this.initializer = initializer;
            _this.flags = flags;
            return _this;
        }
        CoreType.prototype.describe = function () {
            return this.name;
        };
        CoreType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            return createScalarNode(this, parent, subpath, environment, initialValue);
        };
        CoreType.prototype.createNewInstance = function (snapshot) {
            return this.initializer(snapshot);
        };
        CoreType.prototype.isValidSnapshot = function (value, context) {
            if (isPrimitive(value) && this.checker(value)) {
                return typeCheckSuccess();
            }
            var typeName = this.name === "Date" ? "Date or a unix milliseconds timestamp" : this.name;
            return typeCheckFailure(context, value, "Value is not a " + typeName);
        };
        return CoreType;
    }(SimpleType));
    /**
     * `types.string` - Creates a type that can only contain a string value.
     * This type is used for string values by default
     *
     * Example:
     * ```ts
     * const Person = types.model({
     *   firstName: types.string,
     *   lastName: "Doe"
     * })
     * ```
     */
    // tslint:disable-next-line:variable-name
    var string = new CoreType("string", TypeFlags.String, function (v) { return typeof v === "string"; });
    /**
     * `types.number` - Creates a type that can only contain a numeric value.
     * This type is used for numeric values by default
     *
     * Example:
     * ```ts
     * const Vector = types.model({
     *   x: types.number,
     *   y: 1.5
     * })
     * ```
     */
    // tslint:disable-next-line:variable-name
    var number = new CoreType("number", TypeFlags.Number, function (v) { return typeof v === "number"; });
    /**
     * `types.integer` - Creates a type that can only contain an integer value.
     * This type is used for integer values by default
     *
     * Example:
     * ```ts
     * const Size = types.model({
     *   width: types.integer,
     *   height: 10
     * })
     * ```
     */
    // tslint:disable-next-line:variable-name
    var integer = new CoreType("integer", TypeFlags.Integer, function (v) { return isInteger(v); });
    /**
     * `types.boolean` - Creates a type that can only contain a boolean value.
     * This type is used for boolean values by default
     *
     * Example:
     * ```ts
     * const Thing = types.model({
     *   isCool: types.boolean,
     *   isAwesome: false
     * })
     * ```
     */
    // tslint:disable-next-line:variable-name
    var boolean = new CoreType("boolean", TypeFlags.Boolean, function (v) { return typeof v === "boolean"; });
    /**
     * `types.null` - The type of the value `null`
     */
    var nullType = new CoreType("null", TypeFlags.Null, function (v) { return v === null; });
    /**
     * `types.undefined` - The type of the value `undefined`
     */
    var undefinedType = new CoreType("undefined", TypeFlags.Undefined, function (v) { return v === undefined; });
    var _DatePrimitive = new CoreType("Date", TypeFlags.Date, function (v) { return typeof v === "number" || v instanceof Date; }, function (v) { return (v instanceof Date ? v : new Date(v)); });
    _DatePrimitive.getSnapshot = function (node) {
        return node.storedValue.getTime();
    };
    /**
     * `types.Date` - Creates a type that can only contain a javascript Date value.
     *
     * Example:
     * ```ts
     * const LogLine = types.model({
     *   timestamp: types.Date,
     * })
     *
     * LogLine.create({ timestamp: new Date() })
     * ```
     */
    var DatePrimitive = _DatePrimitive;
    /**
     * @internal
     * @hidden
     */
    function getPrimitiveFactoryFromValue(value) {
        switch (typeof value) {
            case "string":
                return string;
            case "number":
                return number; // In the future, isInteger(value) ? integer : number would be interesting, but would be too breaking for now
            case "boolean":
                return boolean;
            case "object":
                if (value instanceof Date)
                    return DatePrimitive;
        }
        throw fail$1("Cannot determine primitive type from value " + value);
    }
    /**
     * Returns if a given value represents a primitive type.
     *
     * @param type
     * @returns
     */
    function isPrimitiveType(type) {
        return (isType(type) &&
            (type.flags &
                (TypeFlags.String |
                    TypeFlags.Number |
                    TypeFlags.Integer |
                    TypeFlags.Boolean |
                    TypeFlags.Date)) >
                0);
    }

    /**
     * @internal
     * @hidden
     */
    var Literal = /** @class */ (function (_super) {
        __extends(Literal, _super);
        function Literal(value) {
            var _this = _super.call(this, JSON.stringify(value)) || this;
            _this.flags = TypeFlags.Literal;
            _this.value = value;
            return _this;
        }
        Literal.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            return createScalarNode(this, parent, subpath, environment, initialValue);
        };
        Literal.prototype.describe = function () {
            return JSON.stringify(this.value);
        };
        Literal.prototype.isValidSnapshot = function (value, context) {
            if (isPrimitive(value) && value === this.value) {
                return typeCheckSuccess();
            }
            return typeCheckFailure(context, value, "Value is not a literal " + JSON.stringify(this.value));
        };
        return Literal;
    }(SimpleType));
    /**
     * `types.literal` - The literal type will return a type that will match only the exact given type.
     * The given value must be a primitive, in order to be serialized to a snapshot correctly.
     * You can use literal to match exact strings for example the exact male or female string.
     *
     * Example:
     * ```ts
     * const Person = types.model({
     *     name: types.string,
     *     gender: types.union(types.literal('male'), types.literal('female'))
     * })
     * ```
     *
     * @param value The value to use in the strict equal check
     * @returns
     */
    function literal(value) {
        // check that the given value is a primitive
        assertArg(value, isPrimitive, "primitive", 1);
        return new Literal(value);
    }
    /**
     * Returns if a given value represents a literal type.
     *
     * @param type
     * @returns
     */
    function isLiteralType(type) {
        return isType(type) && (type.flags & TypeFlags.Literal) > 0;
    }

    var Refinement = /** @class */ (function (_super) {
        __extends(Refinement, _super);
        function Refinement(name, _subtype, _predicate, _message) {
            var _this = _super.call(this, name) || this;
            _this._subtype = _subtype;
            _this._predicate = _predicate;
            _this._message = _message;
            return _this;
        }
        Object.defineProperty(Refinement.prototype, "flags", {
            get: function () {
                return this._subtype.flags | TypeFlags.Refinement;
            },
            enumerable: true,
            configurable: true
        });
        Refinement.prototype.describe = function () {
            return this.name;
        };
        Refinement.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            // create the child type
            return this._subtype.instantiate(parent, subpath, environment, initialValue);
        };
        Refinement.prototype.isAssignableFrom = function (type) {
            return this._subtype.isAssignableFrom(type);
        };
        Refinement.prototype.isValidSnapshot = function (value, context) {
            var subtypeErrors = this._subtype.validate(value, context);
            if (subtypeErrors.length > 0)
                return subtypeErrors;
            var snapshot = isStateTreeNode(value) ? getStateTreeNode(value).snapshot : value;
            if (!this._predicate(snapshot)) {
                return typeCheckFailure(context, value, this._message(value));
            }
            return typeCheckSuccess();
        };
        Refinement.prototype.reconcile = function (current, newValue, parent, subpath) {
            return this._subtype.reconcile(current, newValue, parent, subpath);
        };
        Refinement.prototype.getSubTypes = function () {
            return this._subtype;
        };
        return Refinement;
    }(BaseType));
    /**
     * `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() {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        var name = typeof args[0] === "string" ? args.shift() : isType(args[0]) ? args[0].name : null;
        var type = args[0];
        var predicate = args[1];
        var message = args[2]
            ? args[2]
            : function (v) { return "Value does not respect the refinement predicate"; };
        // ensures all parameters are correct
        assertIsType(type, [1, 2]);
        assertIsString(name, 1);
        assertIsFunction(predicate, [2, 3]);
        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 & TypeFlags.Refinement) > 0;
    }

    /**
     * `types.enumeration` - Can be used to create an string based enumeration.
     * (note: this methods is just sugar for a union of string literals)
     *
     * Example:
     * ```ts
     * const TrafficLight = types.model({
     *   color: types.enumeration("Color", ["Red", "Orange", "Green"])
     * })
     * ```
     *
     * @param name descriptive name of the enumeration (optional)
     * @param options possible values this enumeration can have
     * @returns
     */
    function enumeration(name, options) {
        var realOptions = typeof name === "string" ? options : name;
        // check all options
        {
            realOptions.forEach(function (option, i) {
                assertIsString(option, i + 1);
            });
        }
        var type = union.apply(void 0, __spread(realOptions.map(function (option) { return literal("" + option); })));
        if (typeof name === "string")
            type.name = name;
        return type;
    }

    /**
     * @internal
     * @hidden
     */
    var Union = /** @class */ (function (_super) {
        __extends(Union, _super);
        function Union(name, _types, options) {
            var _this = _super.call(this, name) || this;
            _this._types = _types;
            _this._eager = true;
            options = __assign({ eager: true, dispatcher: undefined }, options);
            _this._dispatcher = options.dispatcher;
            if (!options.eager)
                _this._eager = false;
            return _this;
        }
        Object.defineProperty(Union.prototype, "flags", {
            get: function () {
                var result = TypeFlags.Union;
                this._types.forEach(function (type) {
                    result |= type.flags;
                });
                return result;
            },
            enumerable: true,
            configurable: true
        });
        Union.prototype.isAssignableFrom = function (type) {
            return this._types.some(function (subType) { return subType.isAssignableFrom(type); });
        };
        Union.prototype.describe = function () {
            return "(" + this._types.map(function (factory) { return factory.describe(); }).join(" | ") + ")";
        };
        Union.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            var type = this.determineType(initialValue, undefined);
            if (!type)
                throw fail$1("No matching type for union " + this.describe()); // can happen in prod builds
            return type.instantiate(parent, subpath, environment, initialValue);
        };
        Union.prototype.reconcile = function (current, newValue, parent, subpath) {
            var type = this.determineType(newValue, current.type);
            if (!type)
                throw fail$1("No matching type for union " + this.describe()); // can happen in prod builds
            return type.reconcile(current, newValue, parent, subpath);
        };
        Union.prototype.determineType = function (value, reconcileCurrentType) {
            // try the dispatcher, if defined
            if (this._dispatcher) {
                return this._dispatcher(value);
            }
            // find the most accomodating type
            // if we are using reconciliation try the current node type first (fix for #1045)
            if (reconcileCurrentType) {
                if (reconcileCurrentType.is(value)) {
                    return reconcileCurrentType;
                }
                return this._types.filter(function (t) { return t !== reconcileCurrentType; }).find(function (type) { return type.is(value); });
            }
            else {
                return this._types.find(function (type) { return type.is(value); });
            }
        };
        Union.prototype.isValidSnapshot = function (value, context) {
            if (this._dispatcher) {
                return this._dispatcher(value).validate(value, context);
            }
            var allErrors = [];
            var applicableTypes = 0;
            for (var i = 0; i < this._types.length; i++) {
                var type = this._types[i];
                var errors = type.validate(value, context);
                if (errors.length === 0) {
                    if (this._eager)
                        return typeCheckSuccess();
                    else
                        applicableTypes++;
                }
                else {
                    allErrors.push(errors);
                }
            }
            if (applicableTypes === 1)
                return typeCheckSuccess();
            return typeCheckFailure(context, value, "No type is applicable for the union").concat(flattenTypeErrors(allErrors));
        };
        Union.prototype.getSubTypes = function () {
            return this._types;
        };
        return Union;
    }(BaseType));
    /**
     * `types.union` - Create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function of the form `(snapshot) => Type`.
     *
     * @param optionsOrType
     * @param otherTypes
     * @returns
     */
    function union(optionsOrType) {
        var otherTypes = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            otherTypes[_i - 1] = arguments[_i];
        }
        var options = isType(optionsOrType) ? undefined : optionsOrType;
        var types = isType(optionsOrType) ? __spread([optionsOrType], otherTypes) : otherTypes;
        var name = "(" + types.map(function (type) { return type.name; }).join(" | ") + ")";
        // check all options
        {
            if (options) {
                assertArg(options, function (o) { return isPlainObject(o); }, "object { eager?: boolean, dispatcher?: Function }", 1);
            }
            types.forEach(function (type, i) {
                assertIsType(type, options ? i + 2 : i + 1);
            });
        }
        return new Union(name, types, options);
    }
    /**
     * Returns if a given value represents a union type.
     *
     * @param type
     * @returns
     */
    function isUnionType(type) {
        return (type.flags & TypeFlags.Union) > 0;
    }

    /**
     * @hidden
     * @internal
     */
    var OptionalValue = /** @class */ (function (_super) {
        __extends(OptionalValue, _super);
        function OptionalValue(_subtype, _defaultValue, optionalValues) {
            var _this = _super.call(this, _subtype.name) || this;
            _this._subtype = _subtype;
            _this._defaultValue = _defaultValue;
            _this.optionalValues = optionalValues;
            return _this;
        }
        Object.defineProperty(OptionalValue.prototype, "flags", {
            get: function () {
                return this._subtype.flags | TypeFlags.Optional;
            },
            enumerable: true,
            configurable: true
        });
        OptionalValue.prototype.describe = function () {
            return this._subtype.describe() + "?";
        };
        OptionalValue.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            if (this.optionalValues.indexOf(initialValue) >= 0) {
                var defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot();
                return this._subtype.instantiate(parent, subpath, environment, defaultInstanceOrSnapshot);
            }
            return this._subtype.instantiate(parent, subpath, environment, initialValue);
        };
        OptionalValue.prototype.reconcile = function (current, newValue, parent, subpath) {
            return this._subtype.reconcile(current, this.optionalValues.indexOf(newValue) < 0 && this._subtype.is(newValue)
                ? newValue
                : this.getDefaultInstanceOrSnapshot(), parent, subpath);
        };
        OptionalValue.prototype.getDefaultInstanceOrSnapshot = function () {
            var defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
                ? this._defaultValue()
                : this._defaultValue;
            // while static values are already snapshots and checked on types.optional
            // generator functions must always be rechecked just in case
            if (typeof this._defaultValue === "function") {
                typecheckInternal(this, defaultInstanceOrSnapshot);
            }
            return defaultInstanceOrSnapshot;
        };
        OptionalValue.prototype.isValidSnapshot = function (value, context) {
            // defaulted values can be skipped
            if (this.optionalValues.indexOf(value) >= 0) {
                return typeCheckSuccess();
            }
            // bounce validation to the sub-type
            return this._subtype.validate(value, context);
        };
        OptionalValue.prototype.isAssignableFrom = function (type) {
            return this._subtype.isAssignableFrom(type);
        };
        OptionalValue.prototype.getSubTypes = function () {
            return this._subtype;
        };
        return OptionalValue;
    }(BaseType));
    function checkOptionalPreconditions(type, defaultValueOrFunction) {
        // make sure we never pass direct instances
        if (typeof defaultValueOrFunction !== "function" && isStateTreeNode(defaultValueOrFunction)) {
            throw fail$1("default value cannot be an instance, pass a snapshot or a function that creates an instance/snapshot instead");
        }
        assertIsType(type, 1);
        {
            // we only check default values if they are passed directly
            // if they are generator functions they will be checked once they are generated
            // we don't check generator function results here to avoid generating a node just for type-checking purposes
            // which might generate side-effects
            if (typeof defaultValueOrFunction !== "function") {
                typecheckInternal(type, defaultValueOrFunction);
            }
        }
    }
    /**
     * `types.optional` - Can be used to create a property with a default value.
     *
     * Depending on the third argument (`optionalValues`) there are two ways of operation:
     * - If the argument is not provided, then if a value is not provided in the snapshot (`undefined` or missing),
     *   it will default to the provided `defaultValue`
     * - If the argument is provided, then if the value in the snapshot matches one of the optional values inside the array then it will
     *   default to the provided `defaultValue`. Additionally, if one of the optional values inside the array is `undefined` then a missing
     *   property is also valid.
     *
     *   Note that it is also possible to include values of the same type as the intended subtype as optional values,
     *   in this case the optional value will be transformed into the `defaultValue` (e.g. `types.optional(types.string, "unnamed", [undefined, ""])`
     *   will transform the snapshot values `undefined` (and therefore missing) and empty strings into the string `"unnamed"` when it gets
     *   instantiated).
     *
     * If `defaultValue` is a function, the function will be invoked for every new instance.
     * Applying a snapshot in which the optional value is one of the optional values (or `undefined`/_not_ present if none are provided) causes the
     * value to be reset.
     *
     * Example:
     * ```ts
     * const Todo = types.model({
     *   title: types.string,
     *   subtitle1: types.optional(types.string, "", [null]),
     *   subtitle2: types.optional(types.string, "", [null, undefined]),
     *   done: types.optional(types.boolean, false),
     *   created: types.optional(types.Date, () => new Date()),
     * })
     *
     * // if done is missing / undefined it will become false
     * // if created is missing / undefined it will get a freshly generated timestamp
     * // if subtitle1 is null it will default to "", but it cannot be missing or undefined
     * // if subtitle2 is null or undefined it will default to ""; since it can be undefined it can also be missing
     * const todo = Todo.create({ title: "Get coffee", subtitle1: null })
     * ```
     *
     * @param type
     * @param defaultValueOrFunction
     * @param optionalValues an optional array with zero or more primitive values (string, number, boolean, null or undefined)
     *                       that will be converted into the default. `[ undefined ]` is assumed when none is provided
     * @returns
     */
    function optional(type, defaultValueOrFunction, optionalValues) {
        checkOptionalPreconditions(type, defaultValueOrFunction);
        return new OptionalValue(type, defaultValueOrFunction, optionalValues ? optionalValues : undefinedAsOptionalValues);
    }
    var undefinedAsOptionalValues = [undefined];
    /**
     * Returns if a value represents an optional type.
     *
     * @template IT
     * @param type
     * @returns
     */
    function isOptionalType(type) {
        return isType(type) && (type.flags & TypeFlags.Optional) > 0;
    }

    var optionalUndefinedType = optional(undefinedType, undefined);
    var optionalNullType = optional(nullType, null);
    /**
     * `types.maybe` - Maybe will make a type nullable, and also optional.
     * The value `undefined` will be used to represent nullability.
     *
     * @param type
     * @returns
     */
    function maybe(type) {
        assertIsType(type, 1);
        return union(type, optionalUndefinedType);
    }
    /**
     * `types.maybeNull` - Maybe will make a type nullable, and also optional.
     * The value `null` will be used to represent no value.
     *
     * @param type
     * @returns
     */
    function maybeNull(type) {
        assertIsType(type, 1);
        return union(type, optionalNullType);
    }

    var Late = /** @class */ (function (_super) {
        __extends(Late, _super);
        function Late(name, _definition) {
            var _this = _super.call(this, name) || this;
            _this._definition = _definition;
            return _this;
        }
        Object.defineProperty(Late.prototype, "flags", {
            get: function () {
                return (this._subType ? this._subType.flags : 0) | TypeFlags.Late;
            },
            enumerable: true,
            configurable: true
        });
        Late.prototype.getSubType = function (mustSucceed) {
            if (!this._subType) {
                var t = undefined;
                try {
                    t = this._definition();
                }
                catch (e) {
                    if (e instanceof ReferenceError)
                        // can happen in strict ES5 code when a definition is self refering
                        t = undefined;
                    else
                        throw e;
                }
                if (mustSucceed && t === undefined)
                    throw fail$1("Late type seems to be used too early, the definition (still) returns undefined");
                if (t) {
                    if ( !isType(t))
                        throw fail$1("Failed to determine subtype, make sure types.late returns a type definition.");
                    this._subType = t;
                }
            }
            return this._subType;
        };
        Late.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            return this.getSubType(true).instantiate(parent, subpath, environment, initialValue);
        };
        Late.prototype.reconcile = function (current, newValue, parent, subpath) {
            return this.getSubType(true).reconcile(current, newValue, parent, subpath);
        };
        Late.prototype.describe = function () {
            var t = this.getSubType(false);
            return t ? t.name : "<uknown late type>";
        };
        Late.prototype.isValidSnapshot = function (value, context) {
            var t = this.getSubType(false);
            if (!t) {
                // See #916; the variable the definition closure is pointing to wasn't defined yet, so can't be evaluted yet here
                return typeCheckSuccess();
            }
            return t.validate(value, context);
        };
        Late.prototype.isAssignableFrom = function (type) {
            var t = this.getSubType(false);
            return t ? t.isAssignableFrom(type) : false;
        };
        Late.prototype.getSubTypes = function () {
            var subtype = this.getSubType(false);
            return subtype ? subtype : cannotDetermineSubtype;
        };
        return Late;
    }(BaseType));
    /**
     * `types.late` - Defines a type that gets implemented later. This is useful when you have to deal with circular dependencies.
     * Please notice that when defining circular dependencies TypeScript isn't smart enough to inference them.
     *
     * Example:
     * ```ts
     *   // TypeScript isn't smart enough to infer self referencing types.
     *  const Node = types.model({
     *       children: types.array(types.late((): IAnyModelType => Node)) // then typecast each array element to Instance<typeof Node>
     *  })
     * ```
     *
     * @param name The name to use for the type that will be returned.
     * @param type A function that returns the type that will be defined.
     * @returns
     */
    function late(nameOrType, maybeType) {
        var name = typeof nameOrType === "string" ? nameOrType : "late(" + nameOrType.toString() + ")";
        var type = typeof nameOrType === "string" ? maybeType : nameOrType;
        // checks that the type is actually a late type
        {
            if (!(typeof type === "function" && type.length === 0))
                throw fail$1("Invalid late type, expected a function with zero arguments that returns a type, got: " +
                    type);
        }
        return new Late(name, type);
    }
    /**
     * Returns if a given value represents a late type.
     *
     * @param type
     * @returns
     */
    function isLateType(type) {
        return isType(type) && (type.flags & TypeFlags.Late) > 0;
    }

    /**
     * @internal
     * @hidden
     */
    var Frozen = /** @class */ (function (_super) {
        __extends(Frozen, _super);
        function Frozen(subType) {
            var _this = _super.call(this, subType ? "frozen(" + subType.name + ")" : "frozen") || this;
            _this.subType = subType;
            _this.flags = TypeFlags.Frozen;
            return _this;
        }
        Frozen.prototype.describe = function () {
            return "<any immutable value>";
        };
        Frozen.prototype.instantiate = function (parent, subpath, environment, value) {
            // create the node
            return createScalarNode(this, parent, subpath, environment, deepFreeze(value));
        };
        Frozen.prototype.isValidSnapshot = function (value, context) {
            if (!isSerializable(value)) {
                return typeCheckFailure(context, value, "Value is not serializable and cannot be frozen");
            }
            if (this.subType)
                return this.subType.validate(value, context);
            return typeCheckSuccess();
        };
        return Frozen;
    }(SimpleType));
    var untypedFrozenInstance = new Frozen();
    /**
     * `types.frozen` - Frozen can be used to store any value that is serializable in itself (that is valid JSON).
     * Frozen values need to be immutable or treated as if immutable. They need be serializable as well.
     * Values stored in frozen will snapshotted as-is by MST, and internal changes will not be tracked.
     *
     * This is useful to store complex, but immutable values like vectors etc. It can form a powerful bridge to parts of your application that should be immutable, or that assume data to be immutable.
     *
     * Note: if you want to store free-form state that is mutable, or not serializeable, consider using volatile state instead.
     *
     * Frozen properties can be defined in three different ways
     * 1. `types.frozen(SubType)` - provide a valid MST type and frozen will check if the provided data conforms the snapshot for that type
     * 2. `types.frozen({ someDefaultValue: true})` - provide a primitive value, object or array, and MST will infer the type from that object, and also make it the default value for the field
     * 3. `types.frozen<TypeScriptType>()` - provide a typescript type, to help in strongly typing the field (design time only)
     *
     * Example:
     * ```ts
     * const GameCharacter = types.model({
     *   name: string,
     *   location: types.frozen({ x: 0, y: 0})
     * })
     *
     * const hero = GameCharacter.create({
     *   name: "Mario",
     *   location: { x: 7, y: 4 }
     * })
     *
     * hero.location = { x: 10, y: 2 } // OK
     * hero.location.x = 7 // Not ok!
     * ```
     *
     * ```ts
     * type Point = { x: number, y: number }
     *    const Mouse = types.model({
     *         loc: types.frozen<Point>()
     *    })
     * ```
     *
     * @param defaultValueOrType
     * @returns
     */
    function frozen(arg) {
        if (arguments.length === 0)
            return untypedFrozenInstance;
        else if (isType(arg))
            return new Frozen(arg);
        else
            return optional(untypedFrozenInstance, arg);
    }
    /**
     * Returns if a given value represents a frozen type.
     *
     * @param type
     * @returns
     */
    function isFrozenType(type) {
        return isType(type) && (type.flags & TypeFlags.Frozen) > 0;
    }

    function getInvalidationCause(hook) {
        switch (hook) {
            case Hook.beforeDestroy:
                return "destroy";
            case Hook.beforeDetach:
                return "detach";
            default:
                return undefined;
        }
    }
    var StoredReference = /** @class */ (function () {
        function StoredReference(value, targetType) {
            this.targetType = targetType;
            if (isValidIdentifier(value)) {
                this.identifier = value;
            }
            else if (isStateTreeNode(value)) {
                var targetNode = getStateTreeNode(value);
                if (!targetNode.identifierAttribute)
                    throw fail$1("Can only store references with a defined identifier attribute.");
                var id = targetNode.unnormalizedIdentifier;
                if (id === null || id === undefined) {
                    throw fail$1("Can only store references to tree nodes with a defined identifier.");
                }
                this.identifier = id;
            }
            else {
                throw fail$1("Can only store references to tree nodes or identifiers, got: '" + value + "'");
            }
        }
        StoredReference.prototype.updateResolvedReference = function (node) {
            var normalizedId = normalizeIdentifier(this.identifier);
            var root = node.root;
            var lastCacheModification = root.identifierCache.getLastCacheModificationPerId(normalizedId);
            if (!this.resolvedReference ||
                this.resolvedReference.lastCacheModification !== lastCacheModification) {
                var targetType = this.targetType;
                // reference was initialized with the identifier of the target
                var target = root.identifierCache.resolve(targetType, normalizedId);
                if (!target) {
                    throw new InvalidReferenceError("[mobx-state-tree] Failed to resolve reference '" + this.identifier + "' to type '" + this.targetType.name + "' (from node: " + node.path + ")");
                }
                this.resolvedReference = {
                    node: target,
                    lastCacheModification: lastCacheModification
                };
            }
        };
        Object.defineProperty(StoredReference.prototype, "resolvedValue", {
            get: function () {
                this.updateResolvedReference(this.node);
                return this.resolvedReference.node.value;
            },
            enumerable: true,
            configurable: true
        });
        return StoredReference;
    }());
    /**
     * @internal
     * @hidden
     */
    var InvalidReferenceError = /** @class */ (function (_super) {
        __extends(InvalidReferenceError, _super);
        function InvalidReferenceError(m) {
            var _this = _super.call(this, m) || this;
            Object.setPrototypeOf(_this, InvalidReferenceError.prototype);
            return _this;
        }
        return InvalidReferenceError;
    }(Error));
    /**
     * @internal
     * @hidden
     */
    var BaseReferenceType = /** @class */ (function (_super) {
        __extends(BaseReferenceType, _super);
        function BaseReferenceType(targetType, onInvalidated) {
            var _this = _super.call(this, "reference(" + targetType.name + ")") || this;
            _this.targetType = targetType;
            _this.onInvalidated = onInvalidated;
            _this.flags = TypeFlags.Reference;
            return _this;
        }
        BaseReferenceType.prototype.describe = function () {
            return this.name;
        };
        BaseReferenceType.prototype.isAssignableFrom = function (type) {
            return this.targetType.isAssignableFrom(type);
        };
        BaseReferenceType.prototype.isValidSnapshot = function (value, context) {
            return isValidIdentifier(value)
                ? typeCheckSuccess()
                : typeCheckFailure(context, value, "Value is not a valid identifier, which is a string or a number");
        };
        BaseReferenceType.prototype.fireInvalidated = function (cause, storedRefNode, referenceId, refTargetNode) {
            // to actually invalidate a reference we need an alive parent,
            // since it is a scalar value (immutable-ish) and we need to change it
            // from the parent
            var storedRefParentNode = storedRefNode.parent;
            if (!storedRefParentNode || !storedRefParentNode.isAlive) {
                return;
            }
            var storedRefParentValue = storedRefParentNode.storedValue;
            if (!storedRefParentValue) {
                return;
            }
            this.onInvalidated({
                cause: cause,
                parent: storedRefParentValue,
                invalidTarget: refTargetNode ? refTargetNode.storedValue : undefined,
                invalidId: referenceId,
                replaceRef: function (newRef) {
                    applyPatch(storedRefNode.root.storedValue, {
                        op: "replace",
                        value: newRef,
                        path: storedRefNode.path
                    });
                },
                removeRef: function () {
                    if (isModelType(storedRefParentNode.type)) {
                        this.replaceRef(undefined);
                    }
                    else {
                        applyPatch(storedRefNode.root.storedValue, {
                            op: "remove",
                            path: storedRefNode.path
                        });
                    }
                }
            });
        };
        BaseReferenceType.prototype.addTargetNodeWatcher = function (storedRefNode, referenceId) {
            var _this = this;
            // this will make sure the target node becomes created
            var refTargetValue = this.getValue(storedRefNode);
            if (!refTargetValue) {
                return undefined;
            }
            var refTargetNode = getStateTreeNode(refTargetValue);
            var hookHandler = function (_, refTargetNodeHook) {
                var cause = getInvalidationCause(refTargetNodeHook);
                if (!cause) {
                    return;
                }
                _this.fireInvalidated(cause, storedRefNode, referenceId, refTargetNode);
            };
            var refTargetDetachHookDisposer = refTargetNode.registerHook(Hook.beforeDetach, hookHandler);
            var refTargetDestroyHookDisposer = refTargetNode.registerHook(Hook.beforeDestroy, hookHandler);
            return function () {
                refTargetDetachHookDisposer();
                refTargetDestroyHookDisposer();
            };
        };
        BaseReferenceType.prototype.watchTargetNodeForInvalidations = function (storedRefNode, identifier, customGetSet) {
            var _this = this;
            if (!this.onInvalidated) {
                return;
            }
            var onRefTargetDestroyedHookDisposer;
            // get rid of the watcher hook when the stored ref node is destroyed
            // detached is ignored since scalar nodes (where the reference resides) cannot be detached
            storedRefNode.registerHook(Hook.beforeDestroy, function () {
                if (onRefTargetDestroyedHookDisposer) {
                    onRefTargetDestroyedHookDisposer();
                }
            });
            var startWatching = function (sync) {
                // re-create hook in case the stored ref gets reattached
                if (onRefTargetDestroyedHookDisposer) {
                    onRefTargetDestroyedHookDisposer();
                }
                // make sure the target node is actually there and initialized
                var storedRefParentNode = storedRefNode.parent;
                var storedRefParentValue = storedRefParentNode && storedRefParentNode.storedValue;
                if (storedRefParentNode && storedRefParentNode.isAlive && storedRefParentValue) {
                    var refTargetNodeExists = void 0;
                    if (customGetSet) {
                        refTargetNodeExists = !!customGetSet.get(identifier, storedRefParentValue);
                    }
                    else {
                        refTargetNodeExists = storedRefNode.root.identifierCache.has(_this.targetType, normalizeIdentifier(identifier));
                    }
                    if (!refTargetNodeExists) {
                        // we cannot change the reference in sync mode
                        // since we are in the middle of a reconciliation/instantiation and the change would be overwritten
                        // for those cases just let the wrong reference be assigned and fail upon usage
                        // (like current references do)
                        // this means that effectively this code will only run when it is created from a snapshot
                        if (!sync) {
                            _this.fireInvalidated("invalidSnapshotReference", storedRefNode, identifier, null);
                        }
                    }
                    else {
                        onRefTargetDestroyedHookDisposer = _this.addTargetNodeWatcher(storedRefNode, identifier);
                    }
                }
            };
            if (storedRefNode.state === NodeLifeCycle.FINALIZED) {
                // already attached, so the whole tree is ready
                startWatching(true);
            }
            else {
                if (!storedRefNode.isRoot) {
                    // start watching once the whole tree is ready
                    storedRefNode.root.registerHook(Hook.afterCreationFinalization, function () {
                        // make sure to attach it so it can start listening
                        if (storedRefNode.parent) {
                            storedRefNode.parent.createObservableInstanceIfNeeded();
                        }
                    });
                }
                // start watching once the node is attached somewhere / parent changes
                storedRefNode.registerHook(Hook.afterAttach, function () {
                    startWatching(false);
                });
            }
        };
        return BaseReferenceType;
    }(SimpleType));
    /**
     * @internal
     * @hidden
     */
    var IdentifierReferenceType = /** @class */ (function (_super) {
        __extends(IdentifierReferenceType, _super);
        function IdentifierReferenceType(targetType, onInvalidated) {
            return _super.call(this, targetType, onInvalidated) || this;
        }
        IdentifierReferenceType.prototype.getValue = function (storedRefNode) {
            if (!storedRefNode.isAlive)
                return undefined;
            var storedRef = storedRefNode.storedValue;
            return storedRef.resolvedValue;
        };
        IdentifierReferenceType.prototype.getSnapshot = function (storedRefNode) {
            var ref = storedRefNode.storedValue;
            return ref.identifier;
        };
        IdentifierReferenceType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            var identifier = isStateTreeNode(initialValue)
                ? getIdentifier(initialValue)
                : initialValue;
            var storedRef = new StoredReference(initialValue, this.targetType);
            var storedRefNode = createScalarNode(this, parent, subpath, environment, storedRef);
            storedRef.node = storedRefNode;
            this.watchTargetNodeForInvalidations(storedRefNode, identifier, undefined);
            return storedRefNode;
        };
        IdentifierReferenceType.prototype.reconcile = function (current, newValue, parent, subpath) {
            if (!current.isDetaching && current.type === this) {
                var compareByValue = isStateTreeNode(newValue);
                var ref = current.storedValue;
                if ((!compareByValue && ref.identifier === newValue) ||
                    (compareByValue && ref.resolvedValue === newValue)) {
                    current.setParent(parent, subpath);
                    return current;
                }
            }
            var newNode = this.instantiate(parent, subpath, undefined, newValue);
            current.die(); // noop if detaching
            return newNode;
        };
        return IdentifierReferenceType;
    }(BaseReferenceType));
    /**
     * @internal
     * @hidden
     */
    var CustomReferenceType = /** @class */ (function (_super) {
        __extends(CustomReferenceType, _super);
        function CustomReferenceType(targetType, options, onInvalidated) {
            var _this = _super.call(this, targetType, onInvalidated) || this;
            _this.options = options;
            return _this;
        }
        CustomReferenceType.prototype.getValue = function (storedRefNode) {
            if (!storedRefNode.isAlive)
                return undefined;
            var referencedNode = this.options.get(storedRefNode.storedValue, storedRefNode.parent ? storedRefNode.parent.storedValue : null);
            return referencedNode;
        };
        CustomReferenceType.prototype.getSnapshot = function (storedRefNode) {
            return storedRefNode.storedValue;
        };
        CustomReferenceType.prototype.instantiate = function (parent, subpath, environment, newValue) {
            var identifier = isStateTreeNode(newValue)
                ? this.options.set(newValue, parent ? parent.storedValue : null)
                : newValue;
            var storedRefNode = createScalarNode(this, parent, subpath, environment, identifier);
            this.watchTargetNodeForInvalidations(storedRefNode, identifier, this.options);
            return storedRefNode;
        };
        CustomReferenceType.prototype.reconcile = function (current, newValue, parent, subpath) {
            var newIdentifier = isStateTreeNode(newValue)
                ? this.options.set(newValue, current ? current.storedValue : null)
                : newValue;
            if (!current.isDetaching &&
                current.type === this &&
                current.storedValue === newIdentifier) {
                current.setParent(parent, subpath);
                return current;
            }
            var newNode = this.instantiate(parent, subpath, undefined, newIdentifier);
            current.die(); // noop if detaching
            return newNode;
        };
        return CustomReferenceType;
    }(BaseReferenceType));
    /**
     * `types.reference` - Creates a reference to another type, which should have defined an identifier.
     * See also the [reference and identifiers](https://github.com/mobxjs/mobx-state-tree#references-and-identifiers) section.
     */
    function reference(subType, options) {
        assertIsType(subType, 1);
        {
            if (arguments.length === 2 && typeof arguments[1] === "string") {
                // istanbul ignore next
                throw fail$1("References with base path are no longer supported. Please remove the base path.");
            }
        }
        var getSetOptions = options ? options : undefined;
        var onInvalidated = options
            ? options.onInvalidated
            : undefined;
        if (getSetOptions && (getSetOptions.get || getSetOptions.set)) {
            {
                if (!getSetOptions.get || !getSetOptions.set) {
                    throw fail$1("reference options must either contain both a 'get' and a 'set' method or none of them");
                }
            }
            return new CustomReferenceType(subType, {
                get: getSetOptions.get,
                set: getSetOptions.set
            }, onInvalidated);
        }
        else {
            return new IdentifierReferenceType(subType, onInvalidated);
        }
    }
    /**
     * Returns if a given value represents a reference type.
     *
     * @param type
     * @returns
     */
    function isReferenceType(type) {
        return (type.flags & TypeFlags.Reference) > 0;
    }
    /**
     * `types.safeReference` - A safe reference is like a standard reference, except that it accepts the undefined value by default
     * and automatically sets itself to undefined (when the parent is a model) / removes itself from arrays and maps
     * when the reference it is pointing to gets detached/destroyed.
     *
     * The optional options parameter object accepts a parameter named `acceptsUndefined`, which is set to true by default, so it is suitable
     * for model properties.
     * When used inside collections (arrays/maps), it is recommended to set this option to false so it can't take undefined as value,
     * which is usually the desired in those cases.
     *
     * Strictly speaking it is a `types.maybe(types.reference(X))` (when `acceptsUndefined` is set to true, the default) and
     * `types.reference(X)` (when `acceptsUndefined` is set to false), both of them with a customized `onInvalidated` option.
     *
     * @param subType
     * @param options
     * @returns
     */
    function safeReference(subType, options) {
        var refType = reference(subType, __assign(__assign({}, options), { onInvalidated: function (ev) {
                ev.removeRef();
            } }));
        if (options && options.acceptsUndefined === false) {
            return refType;
        }
        else {
            return maybe(refType);
        }
    }

    var BaseIdentifierType = /** @class */ (function (_super) {
        __extends(BaseIdentifierType, _super);
        function BaseIdentifierType(name, validType) {
            var _this = _super.call(this, name) || this;
            _this.validType = validType;
            _this.flags = TypeFlags.Identifier;
            return _this;
        }
        BaseIdentifierType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            if (!parent || !(parent.type instanceof ModelType))
                throw fail$1("Identifier types can only be instantiated as direct child of a model type");
            return createScalarNode(this, parent, subpath, environment, initialValue);
        };
        BaseIdentifierType.prototype.reconcile = function (current, newValue, parent, subpath) {
            // we don't consider detaching here since identifier are scalar nodes, and scalar nodes cannot be detached
            if (current.storedValue !== newValue)
                throw fail$1("Tried to change identifier from '" + current.storedValue + "' to '" + newValue + "'. Changing identifiers is not allowed.");
            current.setParent(parent, subpath);
            return current;
        };
        BaseIdentifierType.prototype.isValidSnapshot = function (value, context) {
            if (typeof value !== this.validType) {
                return typeCheckFailure(context, value, "Value is not a valid " + this.describe() + ", expected a " + this.validType);
            }
            return typeCheckSuccess();
        };
        return BaseIdentifierType;
    }(SimpleType));
    /**
     * @internal
     * @hidden
     */
    var IdentifierType = /** @class */ (function (_super) {
        __extends(IdentifierType, _super);
        function IdentifierType() {
            var _this = _super.call(this, "identifier", "string") || this;
            _this.flags = TypeFlags.Identifier;
            return _this;
        }
        IdentifierType.prototype.describe = function () {
            return "identifier";
        };
        return IdentifierType;
    }(BaseIdentifierType));
    /**
     * @internal
     * @hidden
     */
    var IdentifierNumberType = /** @class */ (function (_super) {
        __extends(IdentifierNumberType, _super);
        function IdentifierNumberType() {
            return _super.call(this, "identifierNumber", "number") || this;
        }
        IdentifierNumberType.prototype.getSnapshot = function (node) {
            return node.storedValue;
        };
        IdentifierNumberType.prototype.describe = function () {
            return "identifierNumber";
        };
        return IdentifierNumberType;
    }(BaseIdentifierType));
    /**
     * `types.identifier` - Identifiers are used to make references, lifecycle events and reconciling works.
     * Inside a state tree, for each type can exist only one instance for each given identifier.
     * For example there couldn't be 2 instances of user with id 1. If you need more, consider using references.
     * Identifier can be used only as type property of a model.
     * This type accepts as parameter the value type of the identifier field that can be either string or number.
     *
     * Example:
     * ```ts
     *  const Todo = types.model("Todo", {
     *      id: types.identifier,
     *      title: types.string
     *  })
     * ```
     *
     * @returns
     */
    var identifier = new IdentifierType();
    /**
     * `types.identifierNumber` - Similar to `types.identifier`. This one will serialize from / to a number when applying snapshots
     *
     * Example:
     * ```ts
     *  const Todo = types.model("Todo", {
     *      id: types.identifierNumber,
     *      title: types.string
     *  })
     * ```
     *
     * @returns
     */
    var identifierNumber = new IdentifierNumberType();
    /**
     * Returns if a given value represents an identifier type.
     *
     * @param type
     * @returns
     */
    function isIdentifierType(type) {
        return isType(type) && (type.flags & TypeFlags.Identifier) > 0;
    }
    /**
     * @internal
     * @hidden
     */
    function normalizeIdentifier(id) {
        return "" + id;
    }
    /**
     * @internal
     * @hidden
     */
    function isValidIdentifier(id) {
        return typeof id === "string" || typeof id === "number";
    }
    /**
     * @internal
     * @hidden
     */
    function assertIsValidIdentifier(id, argNumber) {
        assertArg(id, isValidIdentifier, "string or number (identifier)", argNumber);
    }

    /**
     * `types.custom` - Creates a custom type. Custom types can be used for arbitrary immutable values, that have a serializable representation. For example, to create your own Date representation, Decimal type etc.
     *
     * The signature of the options is:
     * ```ts
     * export interface CustomTypeOptions<S, T> {
     *     // Friendly name
     *     name: string
     *     // given a serialized value, how to turn it into the target type
     *     fromSnapshot(snapshot: S): T
     *     // return the serialization of the current value
     *     toSnapshot(value: T): S
     *     // if true, this is a converted value, if false, it's a snapshot
     *     isTargetType(value: T | S): value is T
     *     // a non empty string is assumed to be a validation error
     *     getValidationMessage?(snapshot: S): string
     * }
     * ```
     *
     * Example:
     * ```ts
     * const DecimalPrimitive = types.custom<string, Decimal>({
     *     name: "Decimal",
     *     fromSnapshot(value: string) {
     *         return new Decimal(value)
     *     },
     *     toSnapshot(value: Decimal) {
     *         return value.toString()
     *     },
     *     isTargetType(value: string | Decimal): boolean {
     *         return value instanceof Decimal
     *     },
     *     getValidationMessage(value: string): string {
     *         if (/^-?\d+\.\d+$/.test(value)) return "" // OK
     *         return `'${value}' doesn't look like a valid decimal number`
     *     }
     * })
     *
     * const Wallet = types.model({
     *     balance: DecimalPrimitive
     * })
     * ```
     *
     * @param options
     * @returns
     */
    function custom(options) {
        return new CustomType(options);
    }
    /**
     * @internal
     * @hidden
     */
    var CustomType = /** @class */ (function (_super) {
        __extends(CustomType, _super);
        function CustomType(options) {
            var _this = _super.call(this, options.name) || this;
            _this.options = options;
            _this.flags = TypeFlags.Custom;
            return _this;
        }
        CustomType.prototype.describe = function () {
            return this.name;
        };
        CustomType.prototype.isValidSnapshot = function (value, context) {
            if (this.options.isTargetType(value))
                return typeCheckSuccess();
            var typeError = this.options.getValidationMessage(value);
            if (typeError) {
                return typeCheckFailure(context, value, "Invalid value for type '" + this.name + "': " + typeError);
            }
            return typeCheckSuccess();
        };
        CustomType.prototype.getSnapshot = function (node) {
            return this.options.toSnapshot(node.storedValue);
        };
        CustomType.prototype.instantiate = function (parent, subpath, environment, initialValue) {
            var valueToStore = this.options.isTargetType(initialValue)
                ? initialValue
                : this.options.fromSnapshot(initialValue);
            return createScalarNode(this, parent, subpath, environment, valueToStore);
        };
        CustomType.prototype.reconcile = function (current, value, parent, subpath) {
            var isSnapshot = !this.options.isTargetType(value);
            // in theory customs use scalar nodes which cannot be detached, but still...
            if (!current.isDetaching) {
                var unchanged = current.type === this &&
                    (isSnapshot ? value === current.snapshot : value === current.storedValue);
                if (unchanged) {
                    current.setParent(parent, subpath);
                    return current;
                }
            }
            var valueToStore = isSnapshot ? this.options.fromSnapshot(value) : value;
            var newNode = this.instantiate(parent, subpath, undefined, valueToStore);
            current.die(); // noop if detaching
            return newNode;
        };
        return CustomType;
    }(SimpleType));

    // we import the types to re-export them inside types.
    var types = {
        enumeration: enumeration,
        model: model,
        compose: compose,
        custom: custom,
        reference: reference,
        safeReference: safeReference,
        union: union,
        optional: optional,
        literal: literal,
        maybe: maybe,
        maybeNull: maybeNull,
        refinement: refinement,
        string: string,
        boolean: boolean,
        number: number,
        integer: integer,
        Date: DatePrimitive,
        map: map,
        array: array,
        frozen: frozen,
        identifier: identifier,
        identifierNumber: identifierNumber,
        late: late,
        undefined: undefinedType,
        null: nullType,
        snapshotProcessor: snapshotProcessor
    };

    exports.addDisposer = addDisposer;
    exports.addMiddleware = addMiddleware;
    exports.applyAction = applyAction;
    exports.applyPatch = applyPatch;
    exports.applySnapshot = applySnapshot;
    exports.cast = cast;
    exports.castFlowReturn = castFlowReturn;
    exports.castToReferenceSnapshot = castToReferenceSnapshot;
    exports.castToSnapshot = castToSnapshot;
    exports.clone = clone;
    exports.createActionTrackingMiddleware = createActionTrackingMiddleware;
    exports.createActionTrackingMiddleware2 = createActionTrackingMiddleware2;
    exports.decorate = decorate;
    exports.destroy = destroy;
    exports.detach = detach;
    exports.escapeJsonPath = escapeJsonPath;
    exports.flow = flow;
    exports.getChildType = getChildType;
    exports.getEnv = getEnv;
    exports.getIdentifier = getIdentifier;
    exports.getLivelinessChecking = getLivelinessChecking;
    exports.getMembers = getMembers;
    exports.getNodeId = getNodeId;
    exports.getParent = getParent;
    exports.getParentOfType = getParentOfType;
    exports.getPath = getPath;
    exports.getPathParts = getPathParts;
    exports.getPropertyMembers = getPropertyMembers;
    exports.getRelativePath = getRelativePath;
    exports.getRoot = getRoot;
    exports.getRunningActionContext = getRunningActionContext;
    exports.getSnapshot = getSnapshot;
    exports.getType = getType;
    exports.hasParent = hasParent;
    exports.hasParentOfType = hasParentOfType;
    exports.isActionContextChildOf = isActionContextChildOf;
    exports.isActionContextThisOrChildOf = isActionContextThisOrChildOf;
    exports.isAlive = isAlive;
    exports.isArrayType = isArrayType;
    exports.isFrozenType = isFrozenType;
    exports.isIdentifierType = isIdentifierType;
    exports.isLateType = isLateType;
    exports.isLiteralType = isLiteralType;
    exports.isMapType = isMapType;
    exports.isModelType = isModelType;
    exports.isOptionalType = isOptionalType;
    exports.isPrimitiveType = isPrimitiveType;
    exports.isProtected = isProtected;
    exports.isReferenceType = isReferenceType;
    exports.isRefinementType = isRefinementType;
    exports.isRoot = isRoot;
    exports.isStateTreeNode = isStateTreeNode;
    exports.isType = isType;
    exports.isUnionType = isUnionType;
    exports.isValidReference = isValidReference;
    exports.joinJsonPath = joinJsonPath;
    exports.onAction = onAction;
    exports.onPatch = onPatch;
    exports.onSnapshot = onSnapshot;
    exports.process = process;
    exports.protect = protect;
    exports.recordActions = recordActions;
    exports.recordPatches = recordPatches;
    exports.resolveIdentifier = resolveIdentifier;
    exports.resolvePath = resolvePath;
    exports.setLivelinessChecking = setLivelinessChecking;
    exports.setLivelynessChecking = setLivelynessChecking;
    exports.splitJsonPath = splitJsonPath;
    exports.tryReference = tryReference;
    exports.tryResolve = tryResolve;
    exports.typecheck = typecheck;
    exports.types = types;
    exports.unescapeJsonPath = unescapeJsonPath;
    exports.unprotect = unprotect;
    exports.walk = walk;

    Object.defineProperty(exports, '__esModule', { value: true });

}));