breeze-client 2.1.3 → 2.1.4-mjs

package/esm2020/src/entity-manager.mjs

@@ -0,0 +1,2094 @@
+import { core } from './core';
+import { assertParam, assertConfig } from './assert-param';
+import { config } from './config';
+import { BreezeEvent } from './event';
+import { EntityAspect } from './entity-aspect';
+import { MetadataStore, EntityType, DataProperty, AutoGeneratedKeyType } from './entity-metadata';
+import { EntityKey } from './entity-key';
+import { EntityAction } from './entity-action';
+import { EntityState } from './entity-state';
+import { DataService } from './data-service';
+import { DataType } from './data-type';
+import { ValidationError } from './validate';
+import { ValidationOptions } from './validation-options';
+import { QueryOptions, MergeStrategy, FetchStrategy } from './query-options';
+import { SaveOptions } from './save-options';
+import { KeyGenerator } from './key-generator';
+import { EntityGroup } from './entity-group';
+import { MappingContext } from './mapping-context';
+import { EntityQuery } from './entity-query';
+import { UnattachedChildrenMap } from './unattached-children-map';
+/**
+Instances of the EntityManager contain and manage collections of entities, either retrieved from a backend datastore or created on the client.
+**/
+export class EntityManager {
+    /**
+    EntityManager constructor.
+  
+    At its most basic an EntityManager can be constructed with just a service name
+    >     let entityManager = new EntityManager( "breeze/NorthwindIBModel");
+  
+    This is the same as calling it with the following configuration object
+    >     let entityManager = new EntityManager( {serviceName: "breeze/NorthwindIBModel" });
+  
+    Usually however, configuration objects will contain more than just the 'serviceName';
+    >     let metadataStore = new MetadataStore();
+    >     let entityManager = new EntityManager( {
+    >       serviceName: "breeze/NorthwindIBModel",
+    >       metadataStore: metadataStore
+    >     });
+  
+    or
+    >     return new QueryOptions({
+    >         mergeStrategy: obj,
+    >         fetchStrategy: this.fetchStrategy
+    >     });
+    >     let queryOptions = new QueryOptions({
+    >         mergeStrategy: MergeStrategy.OverwriteChanges,
+    >         fetchStrategy: FetchStrategy.FromServer
+    >     });
+    >     let validationOptions = new ValidationOptions({
+    >         validateOnAttach: true,
+    >         validateOnSave: true,
+    >         validateOnQuery: false
+    >     });
+    >     let entityManager = new EntityManager({
+    >         serviceName: "breeze/NorthwindIBModel",
+    >         queryOptions: queryOptions,
+    >         validationOptions: validationOptions
+    >     });
+    @param emConfig - Configuration settings or a service name.
+    **/
+    constructor(emConfig) {
+        this.helper = {
+            unwrapInstance: unwrapInstance,
+            unwrapOriginalValues: unwrapOriginalValues,
+            unwrapChangedValues: unwrapChangedValues
+        };
+        if (arguments.length > 1) {
+            throw new Error("The EntityManager ctor has a single optional argument that is either a 'serviceName' or a configuration object.");
+        }
+        let config;
+        if (arguments.length === 0) {
+            config = { serviceName: "" };
+        }
+        else if (typeof emConfig === 'string') {
+            config = { serviceName: emConfig };
+        }
+        else {
+            config = emConfig || {};
+        }
+        EntityManager._updateWithConfig(this, config, true);
+        this.entityChanged = new BreezeEvent("entityChanged", this);
+        this.validationErrorsChanged = new BreezeEvent("validationErrorsChanged", this);
+        this.hasChangesChanged = new BreezeEvent("hasChangesChanged", this);
+        this.clear();
+    }
+    /**
+    General purpose property set method.  Any of the properties in the [[EntityManagerConfig]]
+    may be set.
+    >      // assume em1 is a previously created EntityManager
+    >      // where we want to change some of its settings.
+    >      em1.setProperties( {
+    >          serviceName: "breeze/foo"
+    >      });
+    @param config - An object containing the selected properties and values to set.
+    **/
+    setProperties(config) {
+        EntityManager._updateWithConfig(this, config, false);
+    }
+    /** @hidden @internal */
+    static _updateWithConfig(em, config, isCtor) {
+        let defaultQueryOptions = isCtor ? QueryOptions.defaultInstance : em.queryOptions;
+        let defaultSaveOptions = isCtor ? SaveOptions.defaultInstance : em.saveOptions;
+        let defaultValidationOptions = isCtor ? ValidationOptions.defaultInstance : em.validationOptions;
+        let configParam = assertConfig(config)
+            .whereParam("serviceName").isOptional().isString()
+            .whereParam("dataService").isOptional().isInstanceOf(DataService)
+            .whereParam("queryOptions").isInstanceOf(QueryOptions).isOptional().withDefault(defaultQueryOptions)
+            .whereParam("saveOptions").isInstanceOf(SaveOptions).isOptional().withDefault(defaultSaveOptions)
+            .whereParam("validationOptions").isInstanceOf(ValidationOptions).isOptional().withDefault(defaultValidationOptions)
+            .whereParam("keyGeneratorCtor").isFunction().isOptional();
+        if (isCtor) {
+            configParam = configParam
+                .whereParam("metadataStore").isInstanceOf(MetadataStore).isOptional().withDefault(new MetadataStore());
+        }
+        configParam.applyAll(em);
+        // insure that entityManager's options versions are completely populated
+        core.updateWithDefaults(em.queryOptions, defaultQueryOptions);
+        core.updateWithDefaults(em.saveOptions, defaultSaveOptions);
+        core.updateWithDefaults(em.validationOptions, defaultValidationOptions);
+        if (config.serviceName) {
+            em.dataService = new DataService({
+                serviceName: em.serviceName
+            });
+        }
+        em.serviceName = em.dataService && em.dataService.serviceName;
+        em.keyGeneratorCtor = em.keyGeneratorCtor || KeyGenerator;
+        if (isCtor || config.keyGeneratorCtor) {
+            em.keyGenerator = new em.keyGeneratorCtor();
+        }
+    }
+    /**
+    Creates a new entity of a specified type and optionally initializes it. By default the new entity is created with an EntityState of Added
+    but you can also optionally specify an EntityState.  An EntityState of 'Detached' will insure that the entity is created but not yet added
+    to the EntityManager.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      // create and add an entity;
+    >      let emp1 = em1.createEntity("Employee");
+    >      // create and add an initialized entity;
+    >      let emp2 = em1.createEntity("Employee", { lastName: "Smith", firstName: "John" });
+    >      // create and attach (not add) an initialized entity
+    >      let emp3 = em1.createEntity("Employee", { id: 435, lastName: "Smith", firstName: "John" }, EntityState.Unchanged);
+    >      // create but don't attach an entity;
+    >      let emp4 = em1.createEntity("Employee", { id: 435, lastName: "Smith", firstName: "John" }, EntityState.Detached);
+    @param typeName - The name of the EntityType for which an instance should be created.
+    @param entityType - The EntityType of the type for which an instance should be created.
+    @param initialValues - (default=null) Configuration object of the properties to set immediately after creation.
+    @param entityState - (default = [[EntityState.Added]]) The EntityState of the entity after being created and added to this EntityManager.
+    @param mergeStrategy - (default = [[MergeStrategy.Disallowed]]) - How to handle conflicts if an entity with the same key already exists within this EntityManager.
+    @return {Entity} A new Entity of the specified type.
+    */
+    createEntity(entityType, initialValues, entityState, mergeStrategy) {
+        assertParam(entityType, "entityType").isString().or().isInstanceOf(EntityType).check();
+        assertParam(entityState, "entityState").isEnumOf(EntityState).isOptional().check();
+        assertParam(mergeStrategy, "mergeStrategy").isEnumOf(MergeStrategy).isOptional().check();
+        let et = (typeof entityType === "string") ? this.metadataStore._getStructuralType(entityType) : entityType;
+        entityState = entityState || EntityState.Added;
+        let entity = {};
+        core.using(this, "isLoading", true, function () {
+            entity = et.createEntity(initialValues);
+        });
+        if (entityState !== EntityState.Detached) {
+            entity = this.attachEntity(entity, entityState, mergeStrategy);
+        }
+        return entity;
+    }
+    /**
+    Creates a new EntityManager and imports a previously exported result into it.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let bundle = em1.exportEntities();
+    >      // can be stored via the web storage api
+    >      window.localStorage.setItem("myEntityManager", bundle);
+    >      // assume the code below occurs in a different session.
+    >      let bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    >      // and imported
+    >      let em2 = EntityManager.importEntities(bundleFromStorage);
+    >      // em2 will now have a complete copy of what was in em1
+    @param exportedString - The result of a previous 'exportEntities' call as a string
+    @param exportedData - The result of a previous 'exportEntities' call as an Object.
+    @param config - A configuration object.
+    @param config.mergeStrategy - A  [[MergeStrategy]] to use when
+    merging into an existing EntityManager.
+    @param config.metadataVersionFn - A function that takes two arguments (the current metadataVersion and the imported store's 'name')
+    and may be used to perform version checking.
+    @return A new EntityManager.  Note that the return value of this method call is different from that
+    provided by the same named method on an EntityManager instance. Use that method if you need additional information
+    regarding the imported entities.
+    **/
+    static importEntities(exported, config) {
+        let em = new EntityManager();
+        em.importEntities(exported, config);
+        return em;
+    }
+    // instance methods
+    /**
+    Calls [[EntityAspect.acceptChanges]] on every changed entity in this EntityManager.
+    **/
+    acceptChanges() {
+        this.getChanges().map(function (entity) {
+            return entity.entityAspect._checkOperation("acceptChanges");
+        }).forEach(function (aspect) {
+            aspect.acceptChanges();
+        });
+    }
+    /**
+    Exports selected entities, all entities of selected types, or an entire EntityManager cache.
+  
+    This method takes a snapshot of an EntityManager that can be stored offline or held in memory.
+    Use the [[EntityManager.importEntities]] method to restore or merge the snapshot
+    into another EntityManager at some later time.
+    >      // let em1 be an EntityManager containing a number of existing entities.
+    >     // export every entity in em1.
+    >     let bundle = em1.exportEntities();
+    >     // save to the browser's local storage
+    >     window.localStorage.setItem("myEntityManager", bundle);
+    >     // later retrieve the export
+    >     let bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    >     // import the retrieved export bundle into another manager
+    >     let em2 = em1.createEmptyCopy();
+    >     em2.importEntities(bundleFromStorage);
+    >     // em2 now has a complete, faithful copy of the entities that were in em1
+  
+    You can also control exactly which entities are exported.
+    >     // get em1's unsaved changes (an array) and export them.
+    >     let changes = em1.getChanges();
+    >     let bundle = em1.exportEntities(changes);
+    >     // merge these entities into em2 which may contains some of the same entities.
+    >     // do NOT overwrite the entities in em2 if they themselves have unsaved changes.
+    >     em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges} );
+  
+    Metadata are included in an export by default. You may want to exclude the metadata
+    especially if you're exporting just a few entities for local storage.
+    >     let bundle = em1.exportEntities(arrayOfSelectedEntities, {includeMetadata: false});
+    >     window.localStorage.setItem("goodStuff", bundle);
+  
+    You may still express this option as a boolean value although this older syntax is deprecated.
+    >     // Exclude the metadata (deprecated syntax)
+    >     let bundle = em1.exportEntities(arrayOfSelectedEntities, false);
+  
+    You can export all entities of one or more specified EntityTypes.
+    >     // Export all Customer and Employee entities (and also exclude metadata)
+    >     let bundle = em1.exportEntities(['Customer', 'Employee'], {includeMetadata: false});
+  
+    All of the above examples return an export bundle as a string which is the default format.
+    You can export the bundle as JSON if you prefer by setting the `asString` option to false.
+    >     // Export all Customer and Employee entities as JSON and exclude the metadata
+    >     let bundle = em1.exportEntities(['Customer', 'Employee'],
+    >                                     {asString: false, includeMetadata: false});
+    >     // store JSON bundle somewhere ... perhaps indexDb ... and later import as we do here.
+    >     em2.importEntities(bundle);
+    @param entities - The entities to export or the EntityType(s) of the entities to export;
+      all entities are exported if this parameter is omitted or null.
+    @param exportConfig - Export configuration options or a boolean
+      - asString - (boolean) - If true (default), return export bundle as a string.
+      - includeMetadata - (boolean) - If true (default), include metadata in the export bundle.
+    @return The export bundle either serialized as a string (default) or as a JSON object.
+    The bundle contains the metadata (unless excluded) and the entity data grouped by type.
+    The entity data include property values, change-state, and temporary key mappings (if any).
+  
+    The export bundle internals are deliberately undocumented.  This Breeze-internal representation of entity data is
+    suitable for export, storage, and import. The schema and contents of the bundle may change in future versions of Breeze.
+    Manipulate it at your own risk with appropriate caution.
+    **/
+    exportEntities(entities, exportConfig) {
+        assertParam(entities, "entities").isArray().isEntity()
+            .or().isNonEmptyArray().isInstanceOf(EntityType)
+            .or().isNonEmptyArray().isString()
+            .or().isOptional().check();
+        // assertParam(exportConfig, "exportConfig").isObject()
+        //   .or().isBoolean()
+        //   .or().isOptional().check();
+        if (exportConfig == null) {
+            exportConfig = { includeMetadata: true, asString: true };
+        }
+        else if (typeof exportConfig === 'boolean') { // deprecated
+            exportConfig = { includeMetadata: exportConfig, asString: true };
+        }
+        assertConfig(exportConfig)
+            .whereParam("asString").isBoolean().isOptional().withDefault(true)
+            .whereParam("includeMetadata").isBoolean().isOptional().withDefault(true)
+            .applyAll(exportConfig);
+        let exportBundle = exportEntityGroups(this, entities);
+        let json = core.extend({}, exportBundle, ["tempKeys", "entityGroupMap"]);
+        if (exportConfig.includeMetadata) {
+            json = core.extend(json, this, ["dataService", "saveOptions", "queryOptions", "validationOptions"]);
+            json.metadataStore = this.metadataStore.exportMetadata();
+        }
+        else {
+            json.metadataVersion = MetadataStore.metadataVersion;
+            json.metadataStoreName = this.metadataStore.name;
+        }
+        let result = exportConfig.asString ? JSON.stringify(json, null, config.stringifyPad) : json;
+        return result;
+    }
+    /**
+    Imports a previously exported result into this EntityManager.
+  
+    This method can be used to make a complete copy of any previously created entityManager, even if created
+    in a previous session and stored in localStorage. The static version of this method performs a
+    very similar process.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     let bundle = em1.exportEntities();
+    >     // bundle can be stored in window.localStorage or just held in memory.
+    >     let em2 = new EntityManager({
+    >         serviceName: em1.serviceName,
+    >         metadataStore: em1.metadataStore
+    >     });
+    >     em2.importEntities(bundle);
+    >     // em2 will now have a complete copy of what was in em1
+  
+    It can also be used to merge the contents of a previously created EntityManager with an
+    existing EntityManager with control over how the two are merged.
+    >     let bundle = em1.exportEntities();
+    >     // assume em2 is another entityManager containing some of the same entities possibly with modifications.
+    >     em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges} );
+    >     // em2 will now contain all of the entities from both em1 and em2.  Any em2 entities with previously
+    >     // made modifications will not have been touched, but all other entities from em1 will have been imported.
+    @param exportedString - The result of a previous 'export' call.
+    @param importConfig - A configuration object.
+    @param importConfig.mergeStrategy -  A [[MergeStrategy]] to use when
+    merging into an existing EntityManager.
+    @param importConfig.metadataVersionFn - A function that takes two arguments (the current metadataVersion and the imported store's 'name')
+    and may be used to perform version checking.
+    @return result
+      - result.entities {Array of Entities} The entities that were imported.
+      - result.tempKeyMap {Object} Mapping from original EntityKey in the import bundle to its corresponding EntityKey in this EntityManager.
+    **/
+    importEntities(exported, importConfig) {
+        importConfig = importConfig || {};
+        assertConfig(importConfig)
+            .whereParam("mergeStrategy").isEnumOf(MergeStrategy).isOptional().withDefault(this.queryOptions.mergeStrategy)
+            .whereParam("metadataVersionFn").isFunction().isOptional()
+            .whereParam("mergeAdds").isBoolean().isOptional()
+            .applyAll(importConfig);
+        let json = (typeof exported === "string") ? JSON.parse(exported) : exported;
+        if (json.metadataStore) {
+            this.metadataStore.importMetadata(json.metadataStore);
+            // the || clause is for backwards compat with an earlier serialization format.
+            this.dataService = (json.dataService && DataService.fromJSON(json.dataService)) || new DataService({ serviceName: json.serviceName });
+            this.saveOptions = new SaveOptions(json.saveOptions);
+            this.queryOptions = QueryOptions.fromJSON(json.queryOptions);
+            this.validationOptions = new ValidationOptions(json.validationOptions);
+        }
+        else {
+            importConfig.metadataVersionFn && importConfig.metadataVersionFn({
+                metadataVersion: json.metadataVersion,
+                metadataStoreName: json.metadataStoreName
+            });
+        }
+        let tempKeyMap = {};
+        json.tempKeys.forEach((k) => {
+            let oldKey = EntityKey.fromJSON(k, this.metadataStore);
+            // try to use oldKey if not already used in this keyGenerator.
+            tempKeyMap[oldKey.toString()] = new EntityKey(oldKey.entityType, this.keyGenerator.generateTempKeyValue(oldKey.entityType, oldKey.values[0]));
+        });
+        let entitiesToLink = [];
+        let impConfig = importConfig;
+        impConfig.tempKeyMap = tempKeyMap;
+        core.wrapExecution(() => {
+            this._pendingPubs = [];
+        }, (state) => {
+            this._pendingPubs.forEach((fn) => fn());
+            this._pendingPubs = undefined;
+            this._hasChangesAction && this._hasChangesAction();
+        }, () => {
+            core.objectForEach(json.entityGroupMap, (entityTypeName, jsonGroup) => {
+                let entityType = this.metadataStore._getStructuralType(entityTypeName, false);
+                let targetEntityGroup = findOrCreateEntityGroup(this, entityType);
+                let entities = importEntityGroup(targetEntityGroup, jsonGroup, impConfig);
+                if (entities && entities.length) {
+                    entitiesToLink = entitiesToLink.concat(entities);
+                }
+            });
+            entitiesToLink.forEach((entity) => {
+                if (!entity.entityAspect.entityState.isDeleted()) {
+                    this._linkRelatedEntities(entity);
+                }
+            });
+        });
+        return {
+            entities: entitiesToLink,
+            tempKeyMapping: tempKeyMap
+        };
+    }
+    /**
+    Clears this EntityManager's cache but keeps all other settings. Note that this
+    method is not as fast as creating a new EntityManager via 'new EntityManager'.
+    This is because clear actually detaches all of the entities from the EntityManager.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     em1.clear();
+    >     // em1 is will now contain no entities, but all other setting will be maintained.
+    **/
+    clear() {
+        core.objectMap(this._entityGroupMap, function (key, entityGroup) {
+            return entityGroup._checkOperation('clear');
+        }).forEach((entityGroup) => {
+            entityGroup._clear();
+        });
+        this._entityGroupMap = {};
+        this._unattachedChildrenMap = new UnattachedChildrenMap();
+        this.keyGenerator = new this.keyGeneratorCtor();
+        this.entityChanged.publish({ entityAction: EntityAction.Clear });
+        this._setHasChanges(false);
+    }
+    /**
+    Creates an empty copy of this EntityManager but with the same DataService, MetadataStore, QueryOptions, SaveOptions, ValidationOptions, etc.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     let em2 = em1.createEmptyCopy();
+    >     // em2 is a new EntityManager with all of em1's settings
+    >     // but no entities.
+    @return A new EntityManager.
+    **/
+    createEmptyCopy() {
+        let copy = new EntityManager(core.extend({}, this, ["dataService", "metadataStore", "queryOptions", "saveOptions", "validationOptions", "keyGeneratorCtor"]));
+        return copy;
+    }
+    /**
+    Attaches an entity to this EntityManager with an  [[EntityState]] of 'Added'.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     let custType = em1.metadataStore.getEntityType("Customer");
+    >     let cust1 = custType.createEntity();
+    >     em1.addEntity(cust1);
+  
+    Note that this is the same as using 'attachEntity' with an [[EntityState]] of 'Added'.
+  
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     let custType = em1.metadataStore.getEntityType("Customer");
+    >     let cust1 = custType.createEntity();
+    >     em1.attachEntity(cust1, EntityState.Added);
+    @param entity - The entity to add.
+    @return The added entity.
+    **/
+    addEntity(entity) {
+        return this.attachEntity(entity, EntityState.Added);
+    }
+    /**
+    Attaches an entity to this EntityManager with a specified [[EntityState]].
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     let custType = em1.metadataStore.getEntityType("Customer");
+    >     let cust1 = custType.createEntity();
+    >     em1.attachEntity(cust1, EntityState.Added);
+    @param entity - The entity to add.
+    @param entityState - (default=EntityState.Unchanged) The EntityState of the newly attached entity. If omitted this defaults to EntityState.Unchanged.
+    @param mergeStrategy - (default = MergeStrategy.Disallowed) How the specified entity should be merged into the EntityManager if this EntityManager already contains an entity with the same key.
+    @return The attached entity.
+    **/
+    attachEntity(entity, entityState, mergeStrategy) {
+        assertParam(entity, "entity").isRequired().check();
+        this.metadataStore._checkEntityType(entity);
+        let esSymbol = assertParam(entityState, "entityState").isEnumOf(EntityState).isOptional().check(EntityState.Unchanged);
+        let msSymbol = assertParam(mergeStrategy, "mergeStrategy").isEnumOf(MergeStrategy).isOptional().check(MergeStrategy.Disallowed);
+        if (entity.entityType.metadataStore !== this.metadataStore) {
+            throw new Error("Cannot attach this entity because the EntityType (" + entity.entityType.name +
+                ") and MetadataStore associated with this entity does not match this EntityManager's MetadataStore.");
+        }
+        let aspect = entity.entityAspect;
+        if (aspect) {
+            // to avoid reattaching an entity in progress
+            if (aspect._inProcessEntity)
+                return aspect._inProcessEntity;
+        }
+        else {
+            // this occur's when attaching an entity created via new instead of via createEntity.
+            aspect = new EntityAspect(entity);
+        }
+        let manager = aspect.entityManager;
+        if (manager) {
+            if (manager === this) {
+                return entity;
+            }
+            else {
+                throw new Error("This entity already belongs to another EntityManager");
+            }
+        }
+        let attachedEntity = {};
+        core.using(this, "isLoading", true, () => {
+            if (esSymbol.isAdded()) {
+                checkEntityKey(this, entity);
+            }
+            // attachedEntity === entity EXCEPT in the case of a merge.
+            attachedEntity = this._attachEntityCore(entity, esSymbol, msSymbol);
+            aspect._inProcessEntity = attachedEntity;
+            try {
+                // entity ( not attachedEntity) is deliberate here.
+                attachRelatedEntities(this, entity, esSymbol, msSymbol);
+            }
+            finally {
+                // insure that _inProcessEntity is cleared.
+                aspect._inProcessEntity = undefined;
+            }
+        });
+        if (this.validationOptions.validateOnAttach) {
+            attachedEntity.entityAspect.validateEntity();
+        }
+        if (!esSymbol.isUnchanged()) {
+            this._notifyStateChange(attachedEntity, true);
+        }
+        this.entityChanged.publish({ entityAction: EntityAction.Attach, entity: attachedEntity });
+        return attachedEntity;
+    }
+    /**
+    Detaches an entity from this EntityManager.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     // assume cust1 is a customer Entity previously attached to em1
+    >     em1.detachEntity(cust1);
+    >     // em1 will now no longer contain cust1 and cust1 will have an
+    >     // entityAspect.entityState of EntityState.Detached
+    @param entity - The entity to detach.
+    @return Whether the entity could be detached. This will return false if the entity is already detached or was never attached.
+    **/
+    detachEntity(entity) {
+        assertParam(entity, "entity").isEntity().check();
+        let aspect = entity.entityAspect;
+        if (!aspect) {
+            // no aspect means in couldn't appear in any group
+            return false;
+        }
+        if (aspect.entityManager !== this) {
+            throw new Error("This entity does not belong to this EntityManager.");
+        }
+        return aspect.setDetached();
+    }
+    /**
+    Fetches the metadata associated with the EntityManager's current 'serviceName'.  This call
+    occurs internally before the first query to any service if the metadata hasn't already been
+    loaded. __Async__
+  
+    Usually you will not actually process the results of a fetchMetadata call directly, but will instead
+    ask for the metadata from the EntityManager after the fetchMetadata call returns.
+    >     let em1 = new EntityManager( "breeze/NorthwindIBModel");
+    >     em1.fetchMetadata()
+    >       .then(function() {
+    >           let metadataStore = em1.metadataStore;
+    >           // do something with the metadata
+    >       }).catch(function(exception) {
+    >           // handle exception here
+    >       });
+    
+    @param callback - Function called on success.
+    @param errorCallback - Function called on failure.
+    @return {Promise}
+      - schema {Object} The raw Schema object from metadata provider - Because this schema will differ depending on the metadata provider
+          it is usually better to access metadata via the 'metadataStore' property of the EntityManager instead of using this 'raw' data.
+    **/
+    fetchMetadata(dataService, callback, errorCallback) {
+        if (typeof (dataService) === "function") {
+            // legacy support for when dataService was not an arg. i.e. first arg was callback
+            errorCallback = callback;
+            callback = dataService;
+            dataService = undefined;
+        }
+        else {
+            assertParam(dataService, "dataService").isInstanceOf(DataService).isOptional().check();
+            assertParam(callback, "callback").isFunction().isOptional().check();
+            assertParam(errorCallback, "errorCallback").isFunction().isOptional().check();
+        }
+        let promise = this.metadataStore.fetchMetadata(dataService || this.dataService);
+        return promiseWithCallbacks(promise, callback, errorCallback);
+    }
+    /**
+    Executes the specified query. __Async__
+    
+    >     let em = new EntityManager(serviceName);
+    >     let query = new EntityQuery("Orders");
+    >     em.executeQuery(query).then( function(data) {
+    >         let orders = data.results;
+    >         ... query results processed here
+    >     }).catch( function(err) {
+    >         ... query failure processed here
+    >     });
+  
+    or with callbacks
+    >     let em = new EntityManager(serviceName);
+    >     let query = new EntityQuery("Orders");
+    >     em.executeQuery(query,
+    >         function(data) {
+    >             let orders = data.results;
+    >             ... query results processed here
+    >         },
+    >         function(err) {
+    >             ... query failure processed here
+    >         });
+  
+    Either way this method is the same as calling the The [[EntityQuery]] 'execute' method.
+    >     let em = new EntityManager(serviceName);
+    >     let query = new EntityQuery("Orders").using(em);
+    >     query.execute().then( function(data) {
+    >         let orders = data.results;
+    >         ... query results processed here
+    >     }).catch( function(err) {
+    >         ... query failure processed here
+    >     });
+    @param query - The [[EntityQuery]] or OData query string to execute.
+    @param callback - Function called on success.
+    @param errorCallback - {Function} Function called on failure.
+    @return Promise of
+      - results - An array of entities
+      - retrievedEntities - A array of all of the entities returned by the query.  Differs from results (above) when .expand() is used.
+      - query - The original [[EntityQuery]] or query string
+      - entityManager -  The EntityManager.
+      - httpResponse - The [[IHttpResponse]] returned from the server.
+      - inlineCount -  Only available if 'inlineCount(true)' was applied to the query.  Returns the count of
+      items that would have been returned by the query before applying any skip or take operators, but after any filter/where predicates
+      would have been applied.
+    **/
+    executeQuery(query, callback, errorCallback) {
+        assertParam(query, "query").isInstanceOf(EntityQuery).or().isString().check();
+        assertParam(callback, "callback").isFunction().isOptional().check();
+        assertParam(errorCallback, "errorCallback").isFunction().isOptional().check();
+        let promise;
+        // 'resolve' methods create a new typed object with all of its properties fully resolved against a list of sources.
+        // Thought about creating a 'normalized' query with these 'resolved' objects
+        // but decided not to because the 'query' may not be an EntityQuery (it can be a string) and hence might not have a queryOptions or dataServices property on it.
+        let queryOptions = QueryOptions.resolve([query.queryOptions, this.queryOptions, QueryOptions.defaultInstance]);
+        let dataService = DataService.resolve([query.dataService, this.dataService]);
+        if ((!dataService.hasServerMetadata) || this.metadataStore.hasMetadataFor(dataService.serviceName)) {
+            promise = executeQueryCore(this, query, queryOptions, dataService);
+        }
+        else {
+            promise = this.fetchMetadata(dataService).then(() => {
+                return executeQueryCore(this, query, queryOptions, dataService);
+            });
+        }
+        return promiseWithCallbacks(promise, callback, errorCallback);
+    }
+    /**
+    Executes the specified query against this EntityManager's local cache.
+  
+    Because this method is executed immediately there is no need for a promise or a callback
+    >     let em = new EntityManager(serviceName);
+    >     let query = new EntityQuery("Orders");
+    >     let orders = em.executeQueryLocally(query);
+  
+    Note that this can also be accomplished using the 'executeQuery' method with
+    a FetchStrategy of FromLocalCache and making use of the Promise or callback
+    >     let em = new EntityManager(serviceName);
+    >     let query = new EntityQuery("Orders").using(FetchStrategy.FromLocalCache);
+    >     em.executeQuery(query).then( function(data) {
+    >         let orders = data.results;
+    >         ... query results processed here
+    >     }).catch( function(err) {
+    >         ... query failure processed here
+    >     });
+    @param query - The [[EntityQuery]] to execute.
+    @return  {Array of Entity}  Array of entities from cache that satisfy the query
+    **/
+    executeQueryLocally(query) {
+        return executeQueryLocallyCore(this, query).results;
+    }
+    /**
+    Saves either a list of specified entities or all changed entities within this EntityManager. If there are no changes to any of the entities
+    specified then there will be no server side call made but a valid 'empty' saveResult will still be returned. __Async__
+  
+    Often we will be saving all of the entities within an EntityManager that are either added, modified or deleted
+    and we will let the 'saveChanges' call determine which entities these are.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      // This could include added, modified and deleted entities.
+    >      em.saveChanges().then(function(saveResult) {
+    >          let savedEntities = saveResult.entities;
+    >          let keyMappings = saveResult.keyMappings;
+    >      }).catch(function (e) {
+    >          // e is any exception that was thrown.
+    >      });
+  
+    But we can also control exactly which entities to save and can specify specific SaveOptions
+  
+    >      // assume entitiesToSave is an array of entities to save.
+    >      let saveOptions = new SaveOptions({ allowConcurrentSaves: true });
+    >      em.saveChanges(entitiesToSave, saveOptions).then(function(saveResult) {
+    >          let savedEntities = saveResult.entities;
+    >          let keyMappings = saveResult.keyMappings;
+    >      }).catch(function (e) {
+    >          // e is any exception that was thrown.
+    >      });
+  
+    Callback methods can also be used
+    >      em.saveChanges(entitiesToSave, null,
+    >          function(saveResult) {
+    >              let savedEntities = saveResult.entities;
+    >              let keyMappings = saveResult.keyMappings;
+    >          }, function (e) {
+    >              // e is any exception that was thrown.
+    >          }
+    >      );
+  
+    @param entities - The list of entities to save.
+    Every entity in that list will be sent to the server, whether changed or unchanged,
+    as long as it is attached to this EntityManager.
+    If this parameter is omitted, null or empty (the usual case),
+    every entity with pending changes in this EntityManager will be saved.
+    @param saveOptions - [[SaveOptions]] for the save - will default to
+    [[EntityManager.saveOptions]] if null.
+    @param callback -  Function called on success.
+    @param errorCallback - Function called on failure.
+    @return {Promise} Promise
+    **/
+    saveChanges(entities, saveOptions, callback, errorCallback) {
+        assertParam(entities, "entities").isOptional().isArray().isEntity().check();
+        assertParam(saveOptions, "saveOptions").isInstanceOf(SaveOptions).isOptional().check();
+        assertParam(callback, "callback").isFunction().isOptional().check();
+        assertParam(errorCallback, "errorCallback").isFunction().isOptional().check();
+        saveOptions = saveOptions || this.saveOptions || SaveOptions.defaultInstance;
+        let entitiesToSave = getEntitiesToSave(this, entities ? entities : undefined);
+        if (entitiesToSave.length === 0) {
+            let result = { entities: [], keyMappings: [] };
+            if (callback)
+                callback(result);
+            return Promise.resolve(result);
+        }
+        if (!saveOptions.allowConcurrentSaves) {
+            let anyPendingSaves = entitiesToSave.some(function (entity) {
+                return entity.entityAspect.isBeingSaved;
+            });
+            if (anyPendingSaves) {
+                let err = new Error("Concurrent saves not allowed - SaveOptions.allowConcurrentSaves is false");
+                if (errorCallback)
+                    errorCallback(err);
+                return Promise.reject(err);
+            }
+        }
+        clearServerErrors(entitiesToSave);
+        let valError = this.saveChangesValidateOnClient(entitiesToSave);
+        if (valError) {
+            if (errorCallback)
+                errorCallback(valError);
+            return Promise.reject(valError);
+        }
+        let dataService = DataService.resolve([saveOptions.dataService, this.dataService]);
+        let saveContext = {
+            entityManager: this,
+            dataService: dataService,
+            processSavedEntities: processSavedEntities,
+            resourceName: saveOptions.resourceName || this.saveOptions.resourceName || "SaveChanges"
+        };
+        // TODO: need to check that if we are doing a partial save that all entities whose temp keys
+        // are referenced are also in the partial save group
+        let saveBundle = { entities: entitiesToSave, saveOptions: saveOptions };
+        try { // Guard against exception thrown in dataservice adapter before it goes async
+            updateConcurrencyProperties(entitiesToSave);
+            return dataService.adapterInstance.saveChanges(saveContext, saveBundle)
+                .then(saveSuccess).then((r) => r, saveFail);
+        }
+        catch (err) {
+            // undo the marking by updateConcurrencyProperties
+            markIsBeingSaved(entitiesToSave, false);
+            if (errorCallback)
+                errorCallback(err);
+            return Promise.reject(err);
+        }
+        function saveSuccess(saveResult) {
+            let em = saveContext.entityManager;
+            markIsBeingSaved(entitiesToSave, false);
+            let savedEntities = saveContext.processSavedEntities(saveResult);
+            saveResult.entities = savedEntities;
+            // update _hasChanges after save.
+            em._setHasChanges();
+            // can't do this anymore because other changes might have been made while saved entities in flight.
+            //      let hasChanges = (isFullSave && haveSameContents(entitiesToSave, savedEntities)) ? false : null;
+            //      em._setHasChanges(hasChanges);
+            if (callback)
+                callback(saveResult);
+            return Promise.resolve(saveResult);
+        }
+        function processSavedEntities(saveResult) {
+            let savedEntities = saveResult.entities;
+            let deletedKeys = saveResult.deletedKeys || [];
+            if (savedEntities.length === 0 && deletedKeys.length === 0) {
+                return [];
+            }
+            let keyMappings = saveResult.keyMappings;
+            let em = saveContext.entityManager;
+            // must occur outside of isLoading block
+            fixupKeys(em, keyMappings);
+            core.using(em, "isLoading", true, () => {
+                let mappingContext = new MappingContext({
+                    query: undefined,
+                    entityManager: em,
+                    mergeOptions: { mergeStrategy: MergeStrategy.OverwriteChanges },
+                    dataService: dataService
+                });
+                // The visitAndMerge operation has been optimized so that we do not actually perform a merge if the
+                // the save operation did not actually return the entity - i.e. during OData and Mongo updates and deletes.
+                savedEntities = mappingContext.visitAndMerge(savedEntities, { nodeType: "root" });
+            });
+            // detach any entities found in the em that appear in the deletedKeys list. 
+            deletedKeys.forEach(key => {
+                let entityType = em.metadataStore._getStructuralType(key.entityTypeName);
+                let ekey = new EntityKey(entityType, key.keyValues);
+                let entity = em.getEntityByKey(ekey);
+                if (entity) {
+                    entity.entityAspect.setDetached();
+                }
+            });
+            return savedEntities;
+        }
+        function saveFail(serverError) {
+            markIsBeingSaved(entitiesToSave, false);
+            let clientError = processServerErrors(saveContext, serverError);
+            if (errorCallback)
+                errorCallback(clientError);
+            return Promise.reject(clientError);
+        }
+    }
+    /**
+    Run the "saveChanges" pre-save client validation logic.
+    
+    This is NOT a general purpose validation method.
+    It is intended for utilities that must know if saveChanges
+    would reject the save due to client validation errors.
+    
+    It only validates entities if the EntityManager's
+    [[ValidationOptions]].validateOnSave is true.
+    
+    @param entitiesToSave {Array of Entity} The list of entities to save (to validate).
+    @return {Error} Validation error or null if no error
+    **/
+    saveChangesValidateOnClient(entitiesToSave) {
+        if (this.validationOptions.validateOnSave) {
+            let failedEntities = entitiesToSave.filter(function (entity) {
+                let aspect = entity.entityAspect;
+                let isValid = aspect.entityState.isDeleted() || aspect.validateEntity();
+                return !isValid;
+            });
+            if (failedEntities.length > 0) {
+                let valError = new Error("Client side validation errors encountered - see the entityErrors collection on this object for more detail");
+                valError.entityErrors = createEntityErrors(failedEntities);
+                return valError; // TODO: type this.
+            }
+        }
+        return null;
+    }
+    /** @hidden @internal */
+    _findEntityGroup(entityType) {
+        return this._entityGroupMap[entityType.name];
+    }
+    /**
+    Attempts to locate an entity within this EntityManager by its [EntityKey].
+    @param entityKey - The [[EntityKey]] of the Entity to be located.
+    @param type - The [[EntityType]] for this key.
+    @param typeName - The EntityType name for this key.
+    @param keyValues - The values for this key - will usually just be a single value; an array is only needed for multipart keys.
+    @return An Entity or null;
+    **/
+    getEntityByKey(...args) {
+        let entityKey = createEntityKey(this, args).entityKey;
+        let entityTypes = entityKey._subtypes || [entityKey.entityType];
+        let e;
+        // hack use of some to simulate mapFirst logic.
+        entityTypes.some((et) => {
+            let group = this._findEntityGroup(et);
+            // group version of findEntityByKey doesn't care about entityType
+            e = group && group.findEntityByKey(entityKey);
+            return e != null;
+        });
+        return e || null;
+    }
+    /**
+    Attempts to fetch an entity from the server by its [[EntityKey]] with
+    an option to check the local cache first. Note the this EntityManager's queryOptions.mergeStrategy
+    will be used to merge any server side entity returned by this method.
+    >     // assume em1 is an EntityManager containing a number of preexisting entities.
+    >     let employeeType = em1.metadataStore.getEntityType("Employee");
+    >     let employeeKey = new EntityKey(employeeType, 1);
+    >     em1.fetchEntityByKey(employeeKey).then(function(result) {
+    >       let employee = result.entity;
+    >       let entityKey = result.entityKey;
+    >       let fromCache = result.fromCache;
+    >     });
+    @param typeName  - The EntityType name for this key.
+    @param entityType  - The EntityType for this key.
+    @param keyValues - The values for this key - will usually just be a single value; an array is only needed for multipart keys.
+    @param entityKey - The [[EntityKey]] of the Entity to be located.
+    @param checkLocalCacheFirst - (default = false) - Whether to check this EntityManager first before going to the server. By default, the query will NOT do this.
+    @return {Promise}
+      - Properties on the promise success result
+        - entity {Object} The entity returned or null
+        - entityKey {EntityKey} The entityKey of the entity to fetch.
+        - fromCache {Boolean} Whether this entity was fetched from the server or was found in the local cache.
+    **/
+    fetchEntityByKey(...args) {
+        let dataService = DataService.resolve([this.dataService]);
+        if ((!dataService.hasServerMetadata) || this.metadataStore.hasMetadataFor(dataService.serviceName)) {
+            return fetchEntityByKeyCore(this, args);
+        }
+        else {
+            return this.fetchMetadata(dataService).then(() => {
+                return fetchEntityByKeyCore(this, args);
+            });
+        }
+    }
+    /**
+    [Deprecated] - Attempts to locate an entity within this EntityManager by its  [[EntityKey]].
+    >     // assume em1 is an EntityManager containing a number of preexisting entities.
+    >     let employeeType = em1.metadataStore.getEntityType("Employee");
+    >     let employeeKey = new EntityKey(employeeType, 1);
+    >     let employee = em1.findEntityByKey(employeeKey);
+    >     // employee will either be an entity or null.
+    @deprecated    Use getEntityByKey instead
+    @param entityKey - The  [[EntityKey]] of the Entity to be located.
+    @return An Entity or null;
+    **/
+    findEntityByKey(entityKey) {
+        return this.getEntityByKey(entityKey);
+    }
+    /**
+    Generates a temporary key for the specified entity.  This is used to insure that newly
+    created entities have unique keys and to register that these keys are temporary and
+    need to be automatically replaced with 'real' key values once these entities are saved.
+    
+    The [[EntityManager.keyGeneratorCtor]] property is used internally by this method to actually generate
+    the keys - See the  KeyGenerator interface interface description to see
+    how a custom key generator can be plugged in.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let customer = custType.createEntity();
+    >      let customerId = em.generateTempKeyValue(customer);
+    >      // The 'customer' entity 'CustomerID' property is now set to a newly generated unique id value
+    >      // This property will change again after a successful save of the 'customer' entity.
+    >
+    >      em1.saveChanges().then( function( data) {
+    >          let sameCust1 = data.results[0];
+    >          // cust1 === sameCust1;
+    >          // but cust1.getProperty("CustomerId") != customerId
+    >          // because the server will have generated a new id
+    >          // and the client will have been updated with this
+    >          // new id.
+    >      })
+    @param entity - The Entity to generate a key for.
+    @return The new key value
+    **/
+    generateTempKeyValue(entity) {
+        // TODO - check if this entity is attached to this EntityManager.
+        assertParam(entity, "entity").isEntity().check();
+        let entityType = entity.entityType;
+        let nextKeyValue = this.keyGenerator.generateTempKeyValue(entityType);
+        let keyProp = entityType.keyProperties[0];
+        entity.setProperty(keyProp.name, nextKeyValue);
+        entity.entityAspect.hasTempKey = true;
+        return nextKeyValue;
+    }
+    /**
+    Returns whether there are any changed entities of the specified [[EntityType]]s. A 'changed' Entity has
+    has an [[EntityState]] of either Added, Modified or Deleted.
+  
+    This method can be used to determine if an EntityManager has any changes
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      if ( em1.hasChanges() {
+    >          // do something interesting
+    >      }
+  
+    or if it has any changes on to a specific [[EntityType]].
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      if ( em1.hasChanges(custType) {
+    >          // do something interesting
+    >      }
+  
+    or to a collection of [[EntityType]]s
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let orderType = em1.metadataStore.getEntityType("Order");
+    >      if ( em1.hasChanges( [custType, orderType]) {
+    >          // do something interesting
+    >      }
+    @param entityTypes - The [[EntityType]] or EntityTypes for which 'changed' entities will be found.
+    @param entityTypeNames - The [[EntityType]] name or names for which 'changed' entities will be found.
+    @return Whether there are any changed entities that match the types specified..
+    **/
+    hasChanges(entityTypes) {
+        if (!this._hasChanges)
+            return false;
+        if (entityTypes === undefined)
+            return this._hasChanges;
+        return this._hasChangesCore(entityTypes);
+    }
+    /** @hidden @internal */
+    // backdoor to "really" check for changes.
+    _hasChangesCore(entityTypes) {
+        let ets = checkEntityTypes(this, entityTypes);
+        let entityGroups = getEntityGroups(this, ets);
+        return entityGroups.some(function (eg) {
+            return eg && eg.hasChanges();
+        });
+    }
+    /**
+    Returns a array of all changed entities of the specified [[EntityType]]s. A 'changed' Entity has
+    has an [[EntityState]] of either Added, Modified or Deleted.
+    
+    This method can be used to get all of the changed entities within an EntityManager
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let changedEntities = em1.getChanges();
+  
+    or you can specify that you only want the changes on a specific [[EntityType]]
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let changedCustomers = em1.getChanges(custType);
+  
+    or to a collection of [[EntityType]]s
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let orderType = em1.metadataStore.getEntityType("Order");
+    >      let changedCustomersAndOrders = em1.getChanges([custType, orderType]);
+    @param entityTypes - The [[EntityType]] or EntityTypes for which 'changed' entities will be found.
+    @param entityTypeNames - The [[EntityType]] name or names for which 'changed' entities will be found.
+    @return An array of Entities
+    **/
+    getChanges(entityTypes) {
+        let ets = checkEntityTypes(this, entityTypes);
+        return getChangesCore(this, ets);
+    }
+    /**
+    Rejects (reverses the effects) all of the additions, modifications and deletes from this EntityManager.
+    Calls [[EntityAspect.rejectChanges]] on every changed entity in this EntityManager.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let entities = em1.rejectChanges();
+    @return The entities whose changes were rejected. These entities will all have EntityStates of
+    either 'Unchanged' or 'Detached'
+    **/
+    rejectChanges() {
+        if (!this._hasChanges)
+            return [];
+        let changes = getChangesCore(this);
+        // next line stops individual reject changes from each calling _hasChangesCore
+        let aspects = changes.map(function (e) {
+            return e.entityAspect._checkOperation("rejectChanges");
+        });
+        this._hasChanges = false;
+        aspects.forEach(function (aspect) {
+            aspect.rejectChanges();
+        });
+        this.hasChangesChanged.publish({ entityManager: this, hasChanges: false });
+        return changes;
+    }
+    /**
+    Returns a array of all entities of the specified [[EntityType]]s with the specified [[EntityState]]s.
+  
+    This method can be used to get all of the entities within an EntityManager
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let entities = em1.getEntities();
+  
+    or you can specify that you only want the changes on a specific [[EntityType]]
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let customers = em1.getEntities(custType);
+  
+    or to a collection of [[EntityType]]s
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let orderType = em1.metadataStore.getEntityType("Order");
+    >      let customersAndOrders = em1.getChanges([custType, orderType]);
+  
+    You can also ask for entities with a particular [[EntityState]] or EntityStates.
+    >      // assume em1 is an EntityManager containing a number of preexisting entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let orderType = em1.metadataStore.getEntityType("Order");
+    >      let addedCustomersAndOrders = em1.getEntities([custType, orderType], EntityState.Added);
+   
+    @param entityTypeName - The [[EntityType]] name or names for which entities will be found.
+    If this parameter is omitted, all EntityTypes are searched.
+    @param entityTypes - The [[EntityType]] or EntityTypes for which entities will be found.
+    If this parameter is omitted, all EntityTypes are searched.
+    @param entityStates - The [[EntityState]]s for which entities will be found.
+    If this parameter is omitted, entities of all EntityStates are returned.
+    @return An array of Entities
+    **/
+    getEntities(entityTypes, entityStates) {
+        let entTypes = checkEntityTypes(this, entityTypes);
+        assertParam(entityStates, "entityStates").isOptional().isEnumOf(EntityState).or().isNonEmptyArray().isEnumOf(EntityState).check();
+        let states = validateEntityStates(this, entityStates);
+        return getEntitiesCore(this, entTypes, states);
+    }
+    // protected methods
+    /** @hidden @internal */
+    _notifyStateChange(entity, needsSave) {
+        let ecArgs = { entityAction: EntityAction.EntityStateChange, entity: entity };
+        if (needsSave) {
+            if (!this._hasChanges)
+                this._setHasChanges(true);
+        }
+        else {
+            // called when rejecting a change or merging an unchanged record.
+            // NOTE: this can be slow with lots of entities in the cache.
+            // so defer it during a query/import or save and call it once when complete ( if needed).
+            if (this._hasChanges) {
+                if (this.isLoading) {
+                    this._hasChangesAction = this._hasChangesAction || function () {
+                        this._setHasChanges(null);
+                        this.entityChanged.publish(ecArgs);
+                    }.bind(this);
+                    return;
+                }
+                else {
+                    this._setHasChanges();
+                }
+            }
+        }
+        this.entityChanged.publish(ecArgs);
+    }
+    /** @hidden @internal */
+    _setHasChanges(hasChanges) {
+        if (hasChanges == null)
+            hasChanges = this._hasChangesCore();
+        let hadChanges = this._hasChanges;
+        this._hasChanges = hasChanges;
+        if (hasChanges !== hadChanges) {
+            this.hasChangesChanged.publish({ entityManager: this, hasChanges: hasChanges });
+        }
+        this._hasChangesAction = undefined;
+    }
+    /** @hidden @internal */
+    _linkRelatedEntities(entity) {
+        let em = this;
+        let entityAspect = entity.entityAspect;
+        // we do not want entityState to change as a result of linkage.
+        core.using(em, "isLoading", true, function () {
+            let unattachedMap = em._unattachedChildrenMap;
+            let entityKey = entityAspect.getKey();
+            let entityType = entityKey.entityType;
+            while (entityType) {
+                let keystring = entityKey.toString(entityType);
+                // attach any unattachedChildren
+                let tuples = unattachedMap.getTuplesByString(keystring);
+                if (tuples) {
+                    tuples.slice(0).forEach(function (tpl) {
+                        let unattachedChildren = tpl.children.filter(function (e) {
+                            return e.entityAspect.entityState !== EntityState.Detached;
+                        });
+                        let childToParentNp;
+                        let parentToChildNp;
+                        // np is usually childToParentNp
+                        // except with unidirectional 1-n where it is parentToChildNp;
+                        let np = tpl.navigationProperty;
+                        let inverseNp = np.inverse;
+                        if (inverseNp) {
+                            // bidirectional
+                            childToParentNp = np;
+                            parentToChildNp = inverseNp;
+                            if (parentToChildNp.isScalar) {
+                                let onlyChild = unattachedChildren[0];
+                                entity.setProperty(parentToChildNp.name, onlyChild);
+                                onlyChild.setProperty(childToParentNp.name, entity);
+                            }
+                            else {
+                                let currentChildren = entity.getProperty(parentToChildNp.name);
+                                unattachedChildren.forEach(function (child) {
+                                    currentChildren.push(child);
+                                    child.setProperty(childToParentNp.name, entity);
+                                });
+                            }
+                            unattachedMap.removeChildren(keystring, childToParentNp);
+                        }
+                        else {
+                            // unidirectional
+                            // if (np.isScalar || np.parentType !== entity.entityType) {
+                            if (np.isScalar) {
+                                // n -> 1  eg: child: OrderDetail parent: Product
+                                // 1 -> 1 eg child: Employee parent: Employee ( only Manager, no DirectReports property)
+                                childToParentNp = np;
+                                unattachedChildren.forEach(function (child) {
+                                    child.setProperty(childToParentNp.name, entity);
+                                });
+                                unattachedMap.removeChildren(keystring, childToParentNp);
+                            }
+                            else {
+                                // 1 -> n  eg: parent: Region child: Terr
+                                // TODO: need to remove unattached children from the map after this; only a perf issue.
+                                parentToChildNp = np;
+                                let currentChildren = entity.getProperty(parentToChildNp.name);
+                                unattachedChildren.forEach(function (child) {
+                                    // we know if can't already be there.
+                                    currentChildren._push(child);
+                                });
+                            }
+                        }
+                    });
+                }
+                entityType = entityType.baseEntityType; // look for relationships up the hierarchy
+            }
+            // now add to unattachedMap if needed.
+            entity.entityType.navigationProperties.forEach(function (np) {
+                if (np.isScalar) {
+                    let value = entity.getProperty(np.name);
+                    // property is already linked up
+                    if (value)
+                        return;
+                }
+                // first determine if np contains a parent or child
+                // having a parentKey means that this is a child
+                // if a parent then no need for more work because children will attach to it.
+                let parentKey = entityAspect.getParentKey(np);
+                if (parentKey) {
+                    // check for empty keys - meaning that parent id's are not yet set.
+                    if (parentKey._isEmpty())
+                        return;
+                    // if a child - look for parent in the em cache
+                    if (np.invForeignKeyNames.length) {
+                        // np relates to non-PK property of parent entity
+                        const query = new EntityQuery(parentKey.entityType.defaultResourceName).where(np.invForeignKeyNames[0], 'eq', parentKey.values[0]);
+                        const qresult = em.executeQueryLocally(query);
+                        if (qresult.length === 1) {
+                            let parent = qresult[0];
+                            entity.setProperty(np.name, parent);
+                        }
+                    }
+                    else {
+                        // np relates to PK of parent entity
+                        let parent = em.getEntityByKey(parentKey);
+                        if (parent) {
+                            // if found hook it up
+                            entity.setProperty(np.name, parent);
+                        }
+                        else {
+                            // else add parent to unresolvedParentMap;
+                            unattachedMap.addChild(parentKey, np, entity);
+                        }
+                    }
+                }
+                else if (np.inverse && np.inverse.invForeignKeyNames.length) {
+                    // np relates to non-PK property of parent entity; query entities by FK
+                    const akValue = entity.getProperty(np.inverse.invForeignKeyNames[0]);
+                    const query = new EntityQuery(np.entityType.defaultResourceName).where(np.invForeignKeyNames[0], 'eq', akValue);
+                    const qresult = em.executeQueryLocally(query);
+                    qresult.forEach((child) => {
+                        child.setProperty(np.inverse.name, entity);
+                    });
+                }
+            });
+            // handle unidirectional 1-x where we set x.fk
+            entity.entityType.foreignKeyProperties.forEach(function (fkProp) {
+                let invNp = fkProp.inverseNavigationProperty;
+                if (!invNp)
+                    return;
+                // unidirectional fk props only
+                let fkValue = entity.getProperty(fkProp.name);
+                let parentKey = new EntityKey(invNp.parentType, [fkValue]);
+                let parent = em.getEntityByKey(parentKey);
+                if (parent) {
+                    if (invNp.isScalar) {
+                        parent.setProperty(invNp.name, entity);
+                    }
+                    else {
+                        if (em.isLoading) {
+                            parent.getProperty(invNp.name)._push(entity);
+                        }
+                        else {
+                            parent.getProperty(invNp.name).push(entity);
+                        }
+                    }
+                }
+                else {
+                    // else add parent to unresolvedParentMap;
+                    unattachedMap.addChild(parentKey, invNp, entity);
+                }
+            });
+        });
+    }
+    /** @hidden @internal */
+    _attachEntityCore(entity, entityState, mergeStrategy) {
+        let group = findOrCreateEntityGroup(this, entity.entityType);
+        let attachedEntity = group.attachEntity(entity, entityState, mergeStrategy);
+        this._linkRelatedEntities(attachedEntity);
+        return attachedEntity;
+    }
+    /** @hidden @internal */
+    _updateFkVal(fkProp, oldValue, newValue) {
+        let group = this._entityGroupMap[fkProp.parentType.name];
+        if (!group)
+            return;
+        group._updateFkVal(fkProp, oldValue, newValue);
+    }
+}
+EntityManager.prototype._$typeName = "EntityManager";
+BreezeEvent.bubbleEvent(EntityManager.prototype);
+function clearServerErrors(entities) {
+    entities.forEach(function (entity) {
+        let serverKeys = [];
+        let aspect = entity.entityAspect;
+        core.objectForEach(aspect._validationErrors, function (key, ve) {
+            if (ve.isServerError)
+                serverKeys.push(key);
+        });
+        if (serverKeys.length === 0)
+            return;
+        aspect._processValidationOpAndPublish(function () {
+            serverKeys.forEach(function (key) {
+                aspect._removeValidationError(key);
+            });
+        });
+    });
+}
+function createEntityErrors(entities) {
+    let entityErrors = [];
+    entities.forEach((entity) => {
+        core.objectForEach(entity.entityAspect._validationErrors, function (key, ve) {
+            let cfg = core.extend({
+                entity: entity,
+                errorName: ve.validator.name
+            }, ve, ["errorMessage", "propertyName", "isServerError", "custom"]);
+            entityErrors.push(cfg);
+        });
+    });
+    return entityErrors;
+}
+function processServerErrors(saveContext, saveError) {
+    // converting ISaveErrorFromServer -> ISaveError
+    let serverErrors = saveError.entityErrors;
+    if (!serverErrors)
+        return saveError;
+    let entityManager = saveContext.entityManager;
+    let metadataStore = entityManager.metadataStore;
+    let entityErrors = serverErrors.map((serr) => {
+        let entity = null;
+        let entityType;
+        if (serr.keyValues) {
+            entityType = metadataStore._getStructuralType(serr.entityTypeName);
+            let ekey = new EntityKey(entityType, serr.keyValues);
+            entity = entityManager.getEntityByKey(ekey);
+        }
+        if (entityType && entity) {
+            let context = serr.propertyName ?
+                {
+                    propertyName: serr.propertyName,
+                    property: entityType.getProperty(serr.propertyName)
+                } : {};
+            let key = ValidationError.getKey(serr.errorName || serr.errorMessage, serr.propertyName);
+            let ve = new ValidationError(null, context, serr.errorMessage, key);
+            ve.isServerError = true;
+            entity.entityAspect.addValidationError(ve);
+        }
+        let entityError = core.extend({
+            entity: entity,
+            isServerError: true
+        }, serr, ["errorName", "errorMessage", "propertyName", "custom"]);
+        return entityError;
+    });
+    // converting ISaveErrorFromServer -> ISaveError 
+    saveError.entityErrors = entityErrors;
+    return saveError;
+}
+function fetchEntityByKeyCore(em, args) {
+    let tpl = createEntityKey(em, args);
+    let entityKey = tpl.entityKey;
+    let checkLocalCacheFirst = tpl.remainingArgs.length === 0 ? false : !!tpl.remainingArgs[0];
+    let entity = null;
+    let foundIt = false;
+    if (checkLocalCacheFirst) {
+        entity = em.getEntityByKey(entityKey);
+        foundIt = entity != null;
+        if (entity != null &&
+            // null the entity if it is deleted and we should exclude deleted entities
+            !em.queryOptions.includeDeleted && entity.entityAspect.entityState.isDeleted()) {
+            entity = null;
+            // but resume looking if we'd overwrite deleted entity with a remote entity
+            // note: em.queryOptions is always fully resolved by now
+            foundIt = em.queryOptions.mergeStrategy !== MergeStrategy.OverwriteChanges;
+        }
+    }
+    if (foundIt) {
+        return Promise.resolve({ entity: entity || undefined, entityKey: entityKey, fromCache: true });
+    }
+    else {
+        return EntityQuery.fromEntityKey(entityKey).using(em).execute().then(function (data) {
+            entity = (data.results.length === 0) ? null : data.results[0];
+            return Promise.resolve({ entity: entity || undefined, entityKey: entityKey, fromCache: false });
+        });
+    }
+}
+// private fns
+// takes in entityTypes as either strings or entityTypes or arrays of either
+// and returns either an entityType or an array of entityTypes or throws an error
+function checkEntityTypes(em, entityTypes) {
+    assertParam(entityTypes, "entityTypes").isString().isOptional().or().isNonEmptyArray().isString()
+        .or().isInstanceOf(EntityType).or().isNonEmptyArray().isInstanceOf(EntityType).check();
+    let resultTypes;
+    if (typeof entityTypes === "string") {
+        resultTypes = em.metadataStore._getStructuralType(entityTypes, false);
+    }
+    else if (Array.isArray(entityTypes) && typeof entityTypes[0] === "string") {
+        resultTypes = entityTypes.map(function (etName) {
+            return em.metadataStore._getStructuralType(etName, false);
+        });
+    }
+    else {
+        resultTypes = entityTypes;
+    }
+    return resultTypes;
+}
+function getChangesCore(em, entityTypes) {
+    let entityGroups = getEntityGroups(em, entityTypes);
+    // TODO: think about writing a core.mapMany method if we see more of these.
+    let selected = [];
+    entityGroups.forEach(function (eg) {
+        // eg may be undefined or null
+        if (!eg)
+            return;
+        let entities = eg.getChanges();
+        if (selected && selected.length) {
+            selected = selected.concat(entities);
+        }
+        else {
+            selected = entities;
+        }
+    });
+    return selected;
+}
+function getEntitiesCore(em, entityTypes, entityStates) {
+    let entityGroups = getEntityGroups(em, entityTypes);
+    // TODO: think about writing a core.mapMany method if we see more of these.
+    let selected = [];
+    entityGroups.forEach(function (eg) {
+        // eg may be undefined or null
+        if (!eg)
+            return;
+        let entities = eg.getEntities(entityStates);
+        if (selected && selected.length) {
+            selected = selected.concat(entities);
+        }
+        else {
+            selected = entities;
+        }
+    });
+    return selected;
+}
+function createEntityKey(em, args) {
+    try {
+        if (args[0] instanceof EntityKey) {
+            return { entityKey: args[0], remainingArgs: core.arraySlice(args, 1) };
+        }
+        else if (args.length >= 2) {
+            let entityType = (typeof args[0] === 'string') ? em.metadataStore._getStructuralType(args[0], false) : args[0];
+            return { entityKey: new EntityKey(entityType, args[1]), remainingArgs: core.arraySlice(args, 2) };
+        }
+    }
+    catch (e) { /* throw below */
+        // throw new Error("Must supply an EntityKey OR an EntityType name or EntityType followed by a key value or an array of key values.");
+    }
+    throw new Error("Must supply an EntityKey OR an EntityType name or EntityType followed by a key value or an array of key values.");
+}
+function markIsBeingSaved(entities, flag) {
+    entities.forEach(function (entity) {
+        entity.entityAspect.isBeingSaved = flag;
+    });
+}
+function exportEntityGroups(em, entitiesOrEntityTypes) {
+    let entityGroupMap;
+    let first = entitiesOrEntityTypes && entitiesOrEntityTypes[0];
+    // check if array
+    if (first) {
+        // group entities by entityType and
+        // create 'groups' that look like entityGroups.
+        entityGroupMap = {};
+        if (first.entityType) {
+            let entities = entitiesOrEntityTypes;
+            // assume "entities" is an array of entities;
+            entities.forEach(function (e) {
+                if (e.entityAspect.entityState === EntityState.Detached) {
+                    throw new Error("Unable to export an entity with an EntityState of 'Detached'");
+                }
+                let group = entityGroupMap[e.entityType.name];
+                if (!group) {
+                    group = {};
+                    group.entityType = e.entityType;
+                    group._entities = [];
+                    entityGroupMap[e.entityType.name] = group;
+                }
+                group._entities.push(e);
+            });
+        }
+        else {
+            // assume "entities" is an array of EntityTypes (or names)
+            let entityTypes = checkEntityTypes(em, entitiesOrEntityTypes);
+            if (entityTypes != null) {
+                entityTypes.forEach((et) => {
+                    let group = em._entityGroupMap[et.name];
+                    if (group && group._entities.length) {
+                        entityGroupMap[et.name] = group;
+                    }
+                });
+            }
+        }
+    }
+    else if (entitiesOrEntityTypes && entitiesOrEntityTypes.length === 0) {
+        // empty array = export nothing
+        entityGroupMap = {};
+    }
+    else {
+        entityGroupMap = em._entityGroupMap;
+    }
+    let tempKeys = [];
+    let newGroupMap = {};
+    core.objectForEach(entityGroupMap, (entityTypeName, entityGroup) => {
+        newGroupMap[entityTypeName] = exportEntityGroup(entityGroup, tempKeys);
+    });
+    return { entityGroupMap: newGroupMap, tempKeys: tempKeys };
+}
+function exportEntityGroup(entityGroup, tempKeys) {
+    let resultGroup = {};
+    let entityType = entityGroup.entityType;
+    let dps = entityType.dataProperties;
+    let serializerFn = getSerializerFn(entityType);
+    let rawEntities = [];
+    entityGroup._entities.forEach((entity) => {
+        if (entity) {
+            let rawEntity = structuralObjectToJson(entity, dps, serializerFn, tempKeys);
+            rawEntities.push(rawEntity);
+        }
+    });
+    resultGroup.entities = rawEntities;
+    return resultGroup;
+}
+function structuralObjectToJson(so, dps, serializerFn, tempKeys) {
+    let result = {};
+    dps.forEach(function (dp) {
+        let dpName = dp.name;
+        let value = so.getProperty(dpName);
+        if (value == null && dp.defaultValue == null)
+            return;
+        if (value && dp.isComplexProperty) {
+            let coDps = dp.dataType.dataProperties;
+            value = core.map(value, function (v) {
+                return structuralObjectToJson(v, coDps, serializerFn);
+            });
+        }
+        else {
+            value = serializerFn ? serializerFn(dp, value) : value;
+            if (dp.isUnmapped) {
+                value = core.toJSONSafe(value, core.toJSONSafeReplacer);
+            }
+        }
+        if (value === undefined)
+            return;
+        result[dpName] = value;
+    });
+    // if (so.entityAspect) {
+    if (EntityAspect.isEntity(so)) {
+        let aspect = so.entityAspect;
+        let entityState = aspect.entityState;
+        let newAspect = {
+            tempNavPropNames: exportTempKeyInfo(aspect, tempKeys || []),
+            entityState: entityState.name
+        };
+        if (aspect.extraMetadata) {
+            newAspect.extraMetadata = aspect.extraMetadata;
+        }
+        if (entityState.isModified() || entityState.isDeleted()) {
+            newAspect.originalValuesMap = aspect.originalValues;
+        }
+        result.entityAspect = newAspect;
+    }
+    else {
+        let aspect = so.complexAspect;
+        let newAspect = {};
+        if (aspect.originalValues && !core.isEmpty(aspect.originalValues)) {
+            newAspect.originalValuesMap = aspect.originalValues;
+        }
+        result.complexAspect = newAspect;
+    }
+    return result;
+}
+function exportTempKeyInfo(entityAspect, tempKeys) {
+    let entity = entityAspect.entity;
+    if (entityAspect.hasTempKey) {
+        tempKeys.push(entityAspect.getKey().toJSON());
+    }
+    // create map for this entity with foreignKeys that are 'temporary'
+    // map -> key: tempKey, value: fkPropName
+    let tempNavPropNames = [];
+    entity.entityType.navigationProperties.forEach(function (np) {
+        if (np.relatedDataProperties) {
+            let relatedValue = entity.getProperty(np.name);
+            if (relatedValue && relatedValue.entityAspect.hasTempKey) {
+                tempNavPropNames.push(np.name);
+            }
+        }
+    });
+    return tempNavPropNames;
+}
+function importEntityGroup(entityGroup, jsonGroup, importConfig) {
+    let tempKeyMap = importConfig.tempKeyMap;
+    let mergeAdds = !!importConfig.mergeAdds;
+    let entityType = entityGroup.entityType;
+    let mergeStrategy = importConfig.mergeStrategy;
+    let targetEntity;
+    let em = entityGroup.entityManager;
+    let entityChanged = em.entityChanged;
+    let entitiesToLink = [];
+    let rawValueFn = DataProperty.getRawValueFromClient;
+    jsonGroup.entities.forEach(function (rawEntity) {
+        let newAspect = rawEntity.entityAspect;
+        let entityKey = entityType.getEntityKeyFromRawEntity(rawEntity, rawValueFn);
+        let entityState = EntityState.fromName(newAspect.entityState);
+        if (!entityState || entityState === EntityState.Detached) {
+            throw new Error("Only entities with a non detached entity state may be imported.");
+        }
+        // Merge if raw entity is in cache UNLESS this is a new entity w/ a temp key
+        // Cannot safely merge such entities even if could match temp key to an entity in cache.
+        // Can enable merge of entities w/temp key using "mergeAdds" - use at your own risk!
+        let newTempKey = !mergeAdds && entityState.isAdded() && getMappedKey(tempKeyMap, entityKey);
+        targetEntity = newTempKey ? undefined : entityGroup.findEntityByKey(entityKey);
+        if (targetEntity) {
+            if (mergeStrategy === MergeStrategy.SkipMerge) {
+                // deliberate fall thru
+            }
+            else if (mergeStrategy === MergeStrategy.Disallowed) {
+                throw new Error("A MergeStrategy of 'Disallowed' prevents " + entityKey.toString() + " from being merged");
+            }
+            else {
+                let targetEntityState = targetEntity.entityAspect.entityState;
+                let wasUnchanged = targetEntityState.isUnchanged();
+                if (mergeStrategy === MergeStrategy.OverwriteChanges || wasUnchanged) {
+                    entityType._updateTargetFromRaw(targetEntity, rawEntity, rawValueFn);
+                    targetEntity.entityAspect.setEntityState(entityState);
+                    entityChanged.publish({ entityAction: EntityAction.MergeOnImport, entity: targetEntity });
+                }
+            }
+        }
+        else {
+            targetEntity = entityType._createInstanceCore();
+            entityType._updateTargetFromRaw(targetEntity, rawEntity, rawValueFn);
+            if (newTempKey) {
+                targetEntity.entityAspect.hasTempKey = true;
+                // fixup pk
+                targetEntity.setProperty(entityType.keyProperties[0].name, newTempKey.values[0]);
+                // fixup foreign keys
+                // This is safe because the entity is detached here and therefore originalValues will not be updated.
+                if (newAspect.tempNavPropNames) {
+                    newAspect.tempNavPropNames.forEach(function (npName) {
+                        let np = entityType.getNavigationProperty(npName);
+                        let fkPropName = np.relatedDataProperties[0].name;
+                        let oldFkValue = targetEntity.getProperty(fkPropName);
+                        let fk = new EntityKey(np.entityType, [oldFkValue]);
+                        let newFk = getMappedKey(tempKeyMap, fk);
+                        targetEntity.setProperty(fkPropName, newFk.values[0]);
+                    });
+                }
+            }
+            // Now performed in attachEntity
+            targetEntity = entityGroup.attachEntity(targetEntity, entityState);
+            entityChanged.publish({ entityAction: EntityAction.AttachOnImport, entity: targetEntity });
+            if (!entityState.isUnchanged()) {
+                em._notifyStateChange(targetEntity, true);
+            }
+        }
+        entitiesToLink.push(targetEntity);
+    });
+    return entitiesToLink;
+}
+function getMappedKey(tempKeyMap, entityKey) {
+    let newKey = tempKeyMap[entityKey.toString()];
+    if (newKey)
+        return newKey;
+    let subtypes = entityKey._subtypes;
+    if (!subtypes)
+        return null;
+    for (let i = 0, j = subtypes.length; i < j; i++) {
+        newKey = tempKeyMap[entityKey.toString(subtypes[i])];
+        if (newKey)
+            return newKey;
+    }
+    return null;
+}
+function promiseWithCallbacks(promise, callback, errorCallback) {
+    promise = promise.then(function (data) {
+        if (callback)
+            callback(data);
+        return Promise.resolve(data);
+    }, function (error) {
+        if (errorCallback)
+            errorCallback(error);
+        return Promise.reject(error);
+    });
+    return promise;
+}
+function getEntitiesToSave(em, entities) {
+    let entitiesToSave;
+    if (entities) {
+        entitiesToSave = entities.filter(function (e) {
+            if (e.entityAspect.entityManager !== em) {
+                throw new Error("Only entities in this entityManager may be saved");
+            }
+            return !e.entityAspect.entityState.isDetached();
+        });
+    }
+    else {
+        entitiesToSave = em.getChanges();
+    }
+    return entitiesToSave;
+}
+function fixupKeys(em, keyMappings) {
+    em._inKeyFixup = true;
+    keyMappings.forEach(function (km) {
+        let group = em._entityGroupMap[km.entityTypeName];
+        if (!group) {
+            throw new Error("Unable to locate the following fully qualified EntityType name: " + km.entityTypeName);
+        }
+        group._fixupKey(km.tempValue, km.realValue);
+    });
+    em._inKeyFixup = false;
+}
+function getEntityGroups(em, entityTypes) {
+    let groupMap = em._entityGroupMap;
+    if (entityTypes) {
+        return core.toArray(entityTypes).map(function (et) {
+            if (et instanceof EntityType) {
+                return groupMap[et.name];
+            }
+            else {
+                throw new Error("The EntityManager.getChanges() 'entityTypes' parameter must be either an entityType or an array of entityTypes or null");
+            }
+        });
+    }
+    else {
+        return core.getOwnPropertyValues(groupMap);
+    }
+}
+function checkEntityKey(em, entity) {
+    let ek = entity.entityAspect.getKey();
+    // return properties that are = to defaultValues
+    let keyPropsWithDefaultValues = core.arrayZip(entity.entityType.keyProperties, ek.values, function (kp, kv) {
+        return (kp.defaultValue === kv) ? kp : null;
+    }).filter(function (kp) {
+        return kp !== null;
+    });
+    if (keyPropsWithDefaultValues.length) {
+        if (entity.entityType.autoGeneratedKeyType !== AutoGeneratedKeyType.None) {
+            em.generateTempKeyValue(entity);
+        }
+        else {
+            // we will allow attaches of entities where only part of the key is set.
+            if (keyPropsWithDefaultValues.length === ek.values.length) {
+                throw new Error("Cannot attach an object of type  (" + entity.entityType.name + ") to an EntityManager without first setting its key or setting its entityType 'AutoGeneratedKeyType' property to something other than 'None'");
+            }
+        }
+    }
+}
+function validateEntityStates(em, entityStates) {
+    if (!entityStates)
+        return [];
+    let entStates = core.toArray(entityStates);
+    entStates.forEach((es) => {
+        if (!(es instanceof EntityState)) {
+            throw new Error("The EntityManager.getChanges() 'entityStates' parameter must either be null, an entityState or an array of entityStates");
+        }
+    });
+    return entStates;
+}
+function attachRelatedEntities(em, entity, entityState, mergeStrategy) {
+    let navProps = entity.entityType.navigationProperties;
+    navProps.forEach(function (np) {
+        let related = entity.getProperty(np.name);
+        if (np.isScalar) {
+            if (!related)
+                return;
+            em.attachEntity(related, entityState, mergeStrategy);
+        }
+        else {
+            related.forEach(function (e) {
+                em.attachEntity(e, entityState, mergeStrategy);
+            });
+        }
+    });
+}
+// returns a promise
+function executeQueryCore(em, query, queryOptions, dataService) {
+    try {
+        let results;
+        let metadataStore = em.metadataStore;
+        if (metadataStore.isEmpty() && dataService.hasServerMetadata) {
+            throw new Error("cannot execute _executeQueryCore until metadataStore is populated.");
+        }
+        if (queryOptions.fetchStrategy === FetchStrategy.FromLocalCache) {
+            try {
+                if (typeof query === 'string') {
+                    throw new Error("cannot execute 'string' EntityQuery locally.");
+                }
+                let qr = executeQueryLocallyCore(em, query);
+                return Promise.resolve({ results: qr.results, entityManager: em, inlineCount: qr.inlineCount, query: query });
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        }
+        let mappingContext = new MappingContext({
+            query: query,
+            entityManager: em,
+            dataService: dataService,
+            mergeOptions: {
+                mergeStrategy: queryOptions.mergeStrategy,
+                noTracking: !!query.noTrackingEnabled,
+                includeDeleted: queryOptions.includeDeleted
+            }
+        });
+        let validateOnQuery = em.validationOptions.validateOnQuery;
+        return dataService.adapterInstance.executeQuery(mappingContext).then(function (data) {
+            let result = core.wrapExecution(function () {
+                let state = { isLoading: em.isLoading };
+                em.isLoading = true;
+                em._pendingPubs = [];
+                return state;
+            }, function (state) {
+                // cleanup
+                em.isLoading = state.isLoading;
+                em._pendingPubs.forEach(function (fn) {
+                    fn();
+                });
+                em._pendingPubs = undefined;
+                em._hasChangesAction && em._hasChangesAction();
+                // TODO: removed - not sure why needed in first place...
+                // // HACK for GC
+                // query = undefined;
+                mappingContext = undefined;
+                // HACK: some errors thrown in next function do not propogate properly - this catches them.
+                if (state.error) {
+                    return Promise.reject(state.error);
+                }
+            }, function () {
+                let nodes = dataService.jsonResultsAdapter.extractResults(data);
+                nodes = core.toArray(nodes);
+                results = mappingContext.visitAndMerge(nodes, { nodeType: "root" });
+                if (validateOnQuery) {
+                    results.forEach(function (r) {
+                        // anon types and simple types will not have an entityAspect.
+                        r.entityAspect && r.entityAspect.validateEntity();
+                    });
+                }
+                mappingContext.processDeferred();
+                // if query has expand clauses walk each of the 'results' and mark the expanded props as loaded.
+                if (query instanceof EntityQuery) {
+                    markLoadedNavProps(results, query);
+                }
+                let retrievedEntities = core.objectMap(mappingContext.refMap);
+                return { results: results, query: query, entityManager: em, httpResponse: data.httpResponse, inlineCount: data.inlineCount, retrievedEntities: retrievedEntities };
+            });
+            return Promise.resolve(result);
+        }, function (e) {
+            if (e) {
+                e.query = query;
+                e.entityManager = em;
+            }
+            return Promise.reject(e);
+        });
+    }
+    catch (e) {
+        if (e) {
+            e.query = query;
+        }
+        return Promise.reject(e);
+    }
+}
+function markLoadedNavProps(entities, query) {
+    if (query.noTrackingEnabled)
+        return;
+    let expandClause = query.expandClause;
+    if (expandClause == null)
+        return;
+    expandClause.propertyPaths.forEach(function (propertyPath) {
+        let propNames = propertyPath.split('.');
+        markLoadedNavPath(entities, propNames);
+    });
+}
+function markLoadedNavPath(entities, propNames) {
+    let propName = propNames[0];
+    entities.forEach((entity) => {
+        let ea = entity.entityAspect;
+        if (!ea)
+            return; // entity may not be a 'real' entity in the case of a projection.
+        ea._markAsLoaded(propName);
+        if (propNames.length === 1)
+            return;
+        let next = entity.getProperty(propName);
+        if (!next)
+            return; // no children to process.
+        // strange logic because nonscalar nav values are NOT really arrays
+        // otherwise we could use Array.isArray
+        if (!next.arrayChanged)
+            next = [next];
+        markLoadedNavPath(next, propNames.slice(1));
+    });
+}
+function updateConcurrencyProperties(entities) {
+    let candidates = entities.filter((e) => {
+        e.entityAspect.isBeingSaved = true;
+        return e.entityAspect.entityState.isModified()
+            && e.entityType.concurrencyProperties.length > 0;
+    });
+    if (candidates.length === 0)
+        return;
+    candidates.forEach(function (c) {
+        c.entityType.concurrencyProperties.forEach(function (cp) {
+            updateConcurrencyProperty(c, cp);
+        });
+    });
+}
+function updateConcurrencyProperty(entity, property) {
+    // check if property has already been updated
+    if (entity.entityAspect.originalValues[property.name])
+        return;
+    let value = entity.getProperty(property.name);
+    let dataType = property.dataType;
+    if (!value)
+        value = dataType.defaultValue;
+    if (dataType.isNumeric) {
+        entity.setProperty(property.name, value + 1);
+    }
+    else if (dataType.getConcurrencyValue) {
+        // DataType has its own implementation
+        let nextValue = dataType.getConcurrencyValue(value);
+        entity.setProperty(property.name, nextValue);
+    }
+    else if (dataType === DataType.Binary) {
+        // best guess - that this is a timestamp column and is computed on the server during save
+        // - so no need to set it here.
+        return;
+    }
+    else {
+        // this just leaves DataTypes of Boolean, String and Byte - none of which should be the
+        // type for a concurrency column.
+        // NOTE: thought about just returning here but would rather be safe for now.
+        throw new Error("Unable to update the value of concurrency property before saving: " + property.name);
+    }
+}
+function findOrCreateEntityGroup(em, entityType) {
+    let group = em._entityGroupMap[entityType.name];
+    if (!group) {
+        group = new EntityGroup(em, entityType);
+        em._entityGroupMap[entityType.name] = group;
+    }
+    return group;
+}
+function findOrCreateEntityGroups(em, entityType) {
+    let entityTypes = entityType.getSelfAndSubtypes();
+    return entityTypes.map((et) => {
+        return findOrCreateEntityGroup(em, et);
+    });
+}
+function unwrapInstance(structObj, transformFn) {
+    let rawObject = {};
+    let stype = EntityAspect.isEntity(structObj) ? structObj.entityType : structObj.complexType;
+    let serializerFn = getSerializerFn(stype);
+    let unmapped = {};
+    stype.dataProperties.forEach(function (dp) {
+        if (dp.isComplexProperty) {
+            rawObject[dp.nameOnServer] = core.map(structObj.getProperty(dp.name), function (co) {
+                return unwrapInstance(co, transformFn);
+            });
+        }
+        else {
+            let val = structObj.getProperty(dp.name);
+            val = transformFn ? transformFn(dp, val) : val;
+            if (val === undefined)
+                return;
+            val = serializerFn ? serializerFn(dp, val) : val;
+            if (val !== undefined) {
+                if (dp.isUnmapped) {
+                    unmapped[dp.nameOnServer] = core.toJSONSafe(val, core.toJSONSafeReplacer);
+                }
+                else {
+                    rawObject[dp.nameOnServer] = val;
+                }
+            }
+        }
+    });
+    if (!core.isEmpty(unmapped)) {
+        // TODO: review this.
+        rawObject.__unmapped = unmapped;
+    }
+    return rawObject;
+}
+function unwrapOriginalValues(target, metadataStore, transformFn) {
+    let stype = EntityAspect.isEntity(target) ? target.entityType : target.complexType;
+    let aspect = EntityAspect.isEntity(target) ? target.entityAspect : target.complexAspect;
+    let fn = metadataStore.namingConvention.clientPropertyNameToServer;
+    let result = {};
+    core.objectForEach(aspect.originalValues, function (propName, val) {
+        let prop = stype.getProperty(propName);
+        val = transformFn ? transformFn(prop, val) : val;
+        if (val !== undefined) {
+            result[fn(propName, prop)] = val;
+        }
+    });
+    stype.complexProperties.forEach(function (cp) {
+        let nextTarget = target.getProperty(cp.name);
+        if (cp.isScalar) {
+            let unwrappedCo = unwrapOriginalValues(nextTarget, metadataStore, transformFn);
+            if (!core.isEmpty(unwrappedCo)) {
+                result[fn(cp.name, cp)] = unwrappedCo;
+            }
+        }
+        else {
+            let unwrappedCos = nextTarget.map((item) => {
+                return unwrapOriginalValues(item, metadataStore, transformFn);
+            });
+            result[fn(cp.name, cp)] = unwrappedCos;
+        }
+    });
+    return result;
+}
+function unwrapChangedValues(entity, metadataStore, transformFn) {
+    let stype = entity.entityType;
+    let serializerFn = getSerializerFn(stype);
+    let fn = metadataStore.namingConvention.clientPropertyNameToServer;
+    let result = {};
+    core.objectForEach(entity.entityAspect.originalValues, function (propName, value) {
+        let prop = stype.getProperty(propName);
+        let val = entity.getProperty(propName);
+        val = transformFn ? transformFn(prop, val) : val;
+        if (val === undefined)
+            return;
+        val = serializerFn ? serializerFn(prop, val) : val;
+        if (val !== undefined) {
+            result[fn(propName, prop)] = val;
+        }
+    });
+    // any change to any complex object or array of complex objects returns the ENTIRE
+    // current complex object or complex object array.  This is by design. Complex Objects
+    // are atomic.
+    stype.complexProperties.forEach((cp) => {
+        if (cpHasOriginalValues(entity, cp)) {
+            let coOrCos = entity.getProperty(cp.name);
+            result[fn(cp.name, cp)] = core.map(coOrCos, function (co) {
+                return unwrapInstance(co, transformFn);
+            });
+        }
+    });
+    return result;
+}
+function cpHasOriginalValues(structuralObject, cp) {
+    let coOrCos = structuralObject.getProperty(cp.name);
+    if (cp.isScalar) {
+        return coHasOriginalValues(coOrCos);
+    }
+    else {
+        // this occurs when a nonscalar co array has had cos added or removed.
+        if (coOrCos._origValues)
+            return true;
+        return coOrCos.some(function (co) {
+            return coHasOriginalValues(co);
+        });
+    }
+}
+function executeQueryLocallyCore(em, query) {
+    assertParam(query, "query").isInstanceOf(EntityQuery).check();
+    let metadataStore = em.metadataStore;
+    let entityType = query._getFromEntityType(metadataStore, true);
+    // there may be multiple groups is this is a base entity type.
+    let groups = findOrCreateEntityGroups(em, entityType);
+    // filter then order then skip then take
+    let filterFunc = query.wherePredicate && query.wherePredicate.toFunction({ entityType: entityType });
+    let queryOptions = QueryOptions.resolve([query.queryOptions, em.queryOptions, QueryOptions.defaultInstance]);
+    let includeDeleted = queryOptions.includeDeleted === true;
+    let newFilterFunc = function (entity) {
+        return entity && (includeDeleted || !entity.entityAspect.entityState.isDeleted()) && (filterFunc ? filterFunc(entity) : true);
+    };
+    let result = [];
+    // TODO: mapMany
+    groups.forEach((group) => {
+        let entities = group._entities.filter(newFilterFunc);
+        if (entities.length) {
+            result = result.length ? result.concat(entities) : entities;
+        }
+    });
+    let orderByComparer = query.orderByClause && query.orderByClause.getComparer(entityType);
+    if (orderByComparer) {
+        result.sort(orderByComparer);
+    }
+    let inlineCount = query.inlineCountEnabled ? result.length : undefined;
+    let skipCount = query.skipCount;
+    if (skipCount) {
+        result = result.slice(skipCount);
+    }
+    let takeCount = query.takeCount;
+    if (takeCount) {
+        result = result.slice(0, takeCount);
+    }
+    let selectClause = query.selectClause;
+    if (selectClause) {
+        let selectFn = selectClause.toFunction();
+        result = result.map(selectFn);
+    }
+    return { results: result, inlineCount: inlineCount };
+}
+function coHasOriginalValues(co) {
+    // next line checks all non complex properties of the co.
+    if (!core.isEmpty(co.complexAspect.originalValues))
+        return true;
+    // now need to recursively check each of the cps
+    return co.complexType.complexProperties.some(function (cp) {
+        return cpHasOriginalValues(co, cp);
+    });
+}
+function getSerializerFn(stype) {
+    return stype.serializerFn || (stype.metadataStore && stype.metadataStore.serializerFn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-manager.js","sourceRoot":"","sources":["../../../src/entity-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataServiceAdapter } from './interface-registry';\r\nimport { core, Callback, ErrorCallback } from './core';\r\nimport { assertParam, assertConfig } from './assert-param';\r\nimport { config } from './config';\r\nimport { BreezeEvent } from './event';\r\nimport { EntityAspect, Entity, ComplexObject, StructuralObject, PropertyChangedEventArgs } from './entity-aspect';\r\nimport { MetadataStore, EntityType, ComplexType, DataProperty, NavigationProperty, AutoGeneratedKeyType } from './entity-metadata';\r\nimport { EntityKey } from './entity-key';\r\nimport { EntityAction  } from './entity-action';\r\nimport { EntityState } from './entity-state';\r\nimport { DataService } from './data-service';\r\nimport { DataType } from './data-type';\r\nimport { ValidationError } from './validate';\r\nimport { ValidationOptions } from './validation-options';\r\nimport { QueryOptions, MergeStrategy, FetchStrategy } from './query-options';\r\nimport { SaveOptions } from './save-options';\r\nimport { KeyGenerator } from './key-generator';\r\nimport { EntityGroup } from './entity-group';\r\nimport { MappingContext } from './mapping-context';\r\nimport { EntityQuery } from './entity-query';\r\nimport { UnattachedChildrenMap } from './unattached-children-map';\r\n\r\nexport interface HttpResponse {\r\n  config: any;\r\n  data: any;\r\n  error?: any;\r\n  saveContext?: any;\r\n  status: number;\r\n  getHeaders(headerName: string): string;\r\n}\r\n\r\nexport interface ImportResult {\r\n  entities: Entity[];\r\n  tempKeyMapping: ITempKeyMap;\r\n}\r\n\r\n// subclasses of Error\r\n\r\n/** Base shape of any errors returned from the server. */\r\nexport interface ServerError extends Error {\r\n  httpResponse: HttpResponse;\r\n  status: number;\r\n  message: string;\r\n  statusText?: string;\r\n  body?: any;\r\n  url?: string;\r\n}\r\n\r\n/** Shape of a save error returned from the server. \r\nFor use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden @internal \r\n*/\r\nexport interface SaveErrorFromServer extends ServerError {\r\n  entityErrors: EntityErrorFromServer[];\r\n}\r\n\r\n/** Shape of a save error when returned to the client. */\r\nexport interface SaveError extends ServerError {\r\n  entityErrors: EntityError[];\r\n}\r\n\r\n// not subclasses of Error\r\n/** \r\nFor use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden @internal \r\n*/\r\nexport interface EntityErrorFromServer {\r\n  entityTypeName: string;\r\n  keyValues: any[];\r\n\r\n  errorName: string;\r\n  errorMessage: string;\r\n  propertyName: string;\r\n  custom?: any;\r\n}\r\n\r\n/** Shape of an error on a specific entity.  Part of a [[ISaveError]] */\r\nexport interface EntityError {\r\n  entity: Entity;\r\n  errorName: string;\r\n  errorMessage: string;\r\n  propertyName: string;\r\n  isServerError: boolean;\r\n  custom?: any;\r\n}\r\n\r\n/** The shape of the Promise returned by an [[EntityManager.executeQuery]] call. */\r\nexport interface QueryResult {\r\n  /** Top level entities returned */\r\n  results: any[];\r\n  /** Query that was executed */\r\n  query: EntityQuery | string;\r\n  /** EntityManager that executed the query */\r\n  entityManager?: EntityManager;\r\n  /** Total number of results available on the server */\r\n  inlineCount?: number;\r\n  /** All entities returned by the query.  Differs from results when an expand is used. */\r\n  retrievedEntities?: Entity[];\r\n    /** Raw response from the server */\r\n  httpResponse?: HttpResponse;\r\n}\r\n\r\nexport interface QuerySuccessCallback {\r\n  (data: QueryResult): void;\r\n}\r\n\r\nexport interface QueryErrorCallback {\r\n  (error: { query: EntityQuery; httpResponse: HttpResponse; entityManager: EntityManager; message?: string; stack?: string }): void;\r\n}\r\n\r\n/** Key mapping information returned as part of an [[ISaveResult]]. */\r\nexport interface KeyMapping {\r\n  entityTypeName: string;\r\n  tempValue: any;\r\n  realValue: any;\r\n}\r\n\r\ninterface ITempKeyMap {\r\n  [index: string]: EntityKey;\r\n}\r\n\r\n/** Configuration info to be passed to the [[EntityManager.importEntities]] method */\r\nexport interface ImportConfig {\r\n  /** If true, merge Added entities (with temp keys) as well.  This can be dangerous. */\r\n  mergeAdds?: boolean;\r\n  mergeStrategy?: MergeStrategy;  \r\n  metadataVersionFn?: (arg: { metadataVersion: any, metadataStoreName: any }) => void;\r\n}\r\n\r\ninterface ImportConfigExt extends ImportConfig {\r\n  tempKeyMap?: ITempKeyMap;\r\n}\r\n\r\n/** The shape of the Promise returned by an [[EntityManager.saveChanges]] call. */\r\nexport interface SaveResult {\r\n  entities: Entity[];\r\n  keyMappings: KeyMapping[];\r\n  deletedKeys?: { entityTypeName: string, keyValues: any[]}[];\r\n  httpResponse?: HttpResponse;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden \r\n*/\r\nexport interface SaveContext {\r\n  entityManager: EntityManager;\r\n  dataService: DataService;\r\n  processSavedEntities: (saveResult: SaveResult) => Entity[];\r\n  resourceName: string;\r\n  adapter?: DataServiceAdapter;\r\n  routePrefix?: string;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation. \r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden \r\n*/\r\nexport interface SaveBundle {\r\n  entities: Entity[];\r\n  saveOptions: SaveOptions;\r\n}\r\n\r\n/** Configuration info to be passed to the [[EntityManager]] constructor */\r\nexport interface EntityManagerConfig {\r\n  /** The service name associated with this EntityManager.  **/\r\n  serviceName?: string;\r\n  /** The DataService associated with this EntityManager. **/\r\n  dataService?: DataService;\r\n  /** The [[QueryOptions]] associated with this EntityManager.  **/\r\n  queryOptions?: QueryOptions;\r\n  /** The [[SaveOptions]] associated with this EntityManager. **/\r\n  saveOptions?: SaveOptions;\r\n  /** The [[ValidationOptions]] associated with this EntityManager.  **/\r\n  validationOptions?: ValidationOptions;\r\n  /** The [[KeyGenerator]] associated with this EntityManager. **/\r\n  keyGenerator?: KeyGenerator;\r\n  /** The [[KeyGenerator]] constructor associated with this EntityManager. **/\r\n  keyGeneratorCtor?: { new (): KeyGenerator }; // TODO: review this\r\n  /** The [[MetadataStore]] associated with this EntityManager. **/\r\n  metadataStore?: MetadataStore;\r\n}\r\n\r\n/** The shape returned by callbacks registered with [[EntityManager.entityChanged]] event */\r\nexport interface EntityChangedEventArgs {\r\n  entityAction: EntityAction;\r\n  entity?: Entity;\r\n  args?: PropertyChangedEventArgs;\r\n}\r\n\r\nexport interface ValidationErrorsChangedEventArgs {\r\n  entity: Entity; \r\n  added: ValidationError[]; \r\n  removed: ValidationError[];\r\n}\r\n\r\nexport interface HasChangesChangedEventArgs {\r\n  entityManager: EntityManager; \r\n  hasChanges: boolean;\r\n}\r\n\r\n/**\r\nInstances of the EntityManager contain and manage collections of entities, either retrieved from a backend datastore or created on the client.\r\n**/\r\nexport class EntityManager {\r\n  /** @hidden @internal */\r\n  _$typeName: string; // actually defined on prototype\r\n\r\n  /** The service name associated with this EntityManager. __Read Only__ **/\r\n  serviceName: string;\r\n  /** The DataService associated with this EntityManager. __Read Only__ **/\r\n  dataService: DataService;\r\n  /** The [[QueryOptions]] associated with this EntityManager. __Read Only__ **/\r\n  queryOptions: QueryOptions;\r\n  /** The [[SaveOptions]] associated with this EntityManager. __Read Only__ **/\r\n  saveOptions: SaveOptions;\r\n  /** The [[ValidationOptions]] associated with this EntityManager. __Read Only__ **/\r\n  validationOptions: ValidationOptions;\r\n  /** The [[KeyGenerator]] associated with this EntityManager. __Read Only__ **/\r\n  keyGenerator: KeyGenerator;\r\n  /** The [[KeyGenerator]] constructor associated with this EntityManager. __Read Only__ **/\r\n  keyGeneratorCtor: { new (): KeyGenerator }; // TODO: review this\r\n  /** The [[MetadataStore]] associated with this EntityManager. __Read Only__ **/\r\n  metadataStore: MetadataStore;\r\n  isLoading: boolean;\r\n  isRejectingChanges: boolean;\r\n\r\n  // events\r\n  /**\r\n  A [[BreezeEvent]] that fires whenever a change to any entity in this EntityManager occurs. __Read Only__\r\n\r\n  @eventArgs - \r\n  - entityAction - The [[EntityAction]] that occured.\r\n  - entity - The entity that changed.  If this is null, then all entities in the entityManager were affected.\r\n  - args - Additional information about this event. This will differ based on the entityAction.\r\n\r\n  >      let em = new EntityManager( {serviceName: \"breeze/NorthwindIBModel\" });\r\n  >      em.entityChanged.subscribe(function(changeArgs) {\r\n  >          // This code will be executed any time any entity within the entityManager \r\n  >          // is added, modified, deleted or detached for any reason.\r\n  >          let action = changeArgs.entityAction;\r\n  >          let entity = changeArgs.entity;\r\n  >          // .. do something to this entity when it is changed.\r\n  >      });\r\n  >  });\r\n  @event\r\n  **/\r\n  entityChanged: BreezeEvent<EntityChangedEventArgs>;\r\n\r\n  /**\r\n  An [[BreezeEvent]] that fires whenever validationErrors change for any entity in this EntityManager. __Read Only__\r\n  @eventArgs -\r\n    - entity - The entity on which the validation errors have been added or removed.\r\n    - added - An array containing any newly added [[ValidationError]]s\r\n    - removed - An array containing any newly removed [[ValidationError]]s. This is those errors that have been 'fixed'  \r\n\r\n  >      let em = new EntityManager( {serviceName: \"breeze/NorthwindIBModel\" });\r\n  >      em.validationErrorsChanged.subscribe(function(changeArgs) {\r\n  >              // This code will be executed any time any entity within the entityManager experiences a change to its validationErrors collection.\r\n  >              function (validationChangeArgs) {\r\n  >                  let entity == validationChangeArgs.entity;\r\n  >                  let errorsAdded = validationChangeArgs.added;\r\n  >                  let errorsCleared = validationChangeArgs.removed;\r\n  >                  // ... do something interesting with the order.\r\n  >              });\r\n  >          });\r\n  >      });\r\n  @event\r\n  **/\r\n  validationErrorsChanged: BreezeEvent<ValidationErrorsChangedEventArgs>;\r\n\r\n  /**\r\n  A [[BreezeEvent]] that fires whenever an EntityManager transitions to or from having changes. __Read Only__\r\n  @eventArgs -\r\n    - entityManager - The EntityManager whose 'hasChanges' status has changed.\r\n    - hasChanges - Whether or not this EntityManager has changes.\r\n\r\n  >      let em = new EntityManager( {serviceName: \"breeze/NorthwindIBModel\" });\r\n  >      em.hasChangesChanged.subscribe(function(args) {\r\n  >              let hasChangesChanged = args.hasChanges;\r\n  >              let entityManager = args.entityManager;\r\n  >          });\r\n  >      });\r\n  @event \r\n  **/\r\n  hasChangesChanged: BreezeEvent<HasChangesChangedEventArgs>;\r\n\r\n\r\n  /** @hidden @internal */\r\n  _pendingPubs?: any[]; // TODO: refine later\r\n  /** @hidden @internal */\r\n  _hasChangesAction?: (() => boolean); // TODO refine later\r\n  /** @hidden @internal */\r\n  _hasChanges: boolean;\r\n  /** @hidden @internal */\r\n  _entityGroupMap: { [index: string]: EntityGroup };\r\n  /** @hidden @internal */\r\n  _unattachedChildrenMap: UnattachedChildrenMap;\r\n  /** @hidden @internal */\r\n  _inKeyFixup: boolean;\r\n\r\n  helper = {\r\n    unwrapInstance: unwrapInstance,\r\n    unwrapOriginalValues: unwrapOriginalValues,\r\n    unwrapChangedValues: unwrapChangedValues\r\n  };\r\n\r\n  /**\r\n  EntityManager constructor.\r\n\r\n  At its most basic an EntityManager can be constructed with just a service name\r\n  >     let entityManager = new EntityManager( \"breeze/NorthwindIBModel\");\r\n\r\n  This is the same as calling it with the following configuration object\r\n  >     let entityManager = new EntityManager( {serviceName: \"breeze/NorthwindIBModel\" });\r\n\r\n  Usually however, configuration objects will contain more than just the 'serviceName';\r\n  >     let metadataStore = new MetadataStore();\r\n  >     let entityManager = new EntityManager( {\r\n  >       serviceName: \"breeze/NorthwindIBModel\",\r\n  >       metadataStore: metadataStore\r\n  >     });\r\n\r\n  or\r\n  >     return new QueryOptions({\r\n  >         mergeStrategy: obj,\r\n  >         fetchStrategy: this.fetchStrategy\r\n  >     });\r\n  >     let queryOptions = new QueryOptions({\r\n  >         mergeStrategy: MergeStrategy.OverwriteChanges,\r\n  >         fetchStrategy: FetchStrategy.FromServer\r\n  >     });\r\n  >     let validationOptions = new ValidationOptions({\r\n  >         validateOnAttach: true,\r\n  >         validateOnSave: true,\r\n  >         validateOnQuery: false\r\n  >     });\r\n  >     let entityManager = new EntityManager({\r\n  >         serviceName: \"breeze/NorthwindIBModel\",\r\n  >         queryOptions: queryOptions,\r\n  >         validationOptions: validationOptions\r\n  >     });\r\n  @param emConfig - Configuration settings or a service name.  \r\n  **/\r\n  constructor(emConfig?: EntityManagerConfig | string) {\r\n\r\n    if (arguments.length > 1) {\r\n      throw new Error(\"The EntityManager ctor has a single optional argument that is either a 'serviceName' or a configuration object.\");\r\n    }\r\n    let config: EntityManagerConfig;\r\n    if (arguments.length === 0) {\r\n      config = { serviceName: \"\" };\r\n    } else if (typeof emConfig === 'string') {\r\n      config = { serviceName: emConfig };\r\n    } else {\r\n      config = emConfig || {};\r\n    }\r\n\r\n    EntityManager._updateWithConfig(this, config, true);\r\n\r\n    this.entityChanged = new BreezeEvent(\"entityChanged\", this);\r\n    this.validationErrorsChanged = new BreezeEvent(\"validationErrorsChanged\", this);\r\n    this.hasChangesChanged = new BreezeEvent(\"hasChangesChanged\", this);\r\n\r\n    this.clear();\r\n\r\n  }\r\n\r\n  /**\r\n  General purpose property set method.  Any of the properties in the [[EntityManagerConfig]]\r\n  may be set.\r\n  >      // assume em1 is a previously created EntityManager\r\n  >      // where we want to change some of its settings.\r\n  >      em1.setProperties( {\r\n  >          serviceName: \"breeze/foo\"\r\n  >      });\r\n  @param config - An object containing the selected properties and values to set.\r\n  **/\r\n  setProperties(config: EntityManagerConfig) {\r\n    EntityManager._updateWithConfig(this, config, false);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  static _updateWithConfig(em: EntityManager, config: EntityManagerConfig, isCtor: boolean) {\r\n    let defaultQueryOptions = isCtor ? QueryOptions.defaultInstance : em.queryOptions;\r\n    let defaultSaveOptions = isCtor ? SaveOptions.defaultInstance : em.saveOptions;\r\n    let defaultValidationOptions = isCtor ? ValidationOptions.defaultInstance : em.validationOptions;\r\n\r\n    let configParam = assertConfig(config)\r\n      .whereParam(\"serviceName\").isOptional().isString()\r\n      .whereParam(\"dataService\").isOptional().isInstanceOf(DataService)\r\n      .whereParam(\"queryOptions\").isInstanceOf(QueryOptions).isOptional().withDefault(defaultQueryOptions)\r\n      .whereParam(\"saveOptions\").isInstanceOf(SaveOptions).isOptional().withDefault(defaultSaveOptions)\r\n      .whereParam(\"validationOptions\").isInstanceOf(ValidationOptions).isOptional().withDefault(defaultValidationOptions)\r\n      .whereParam(\"keyGeneratorCtor\").isFunction().isOptional();\r\n    if (isCtor) {\r\n      configParam = configParam\r\n        .whereParam(\"metadataStore\").isInstanceOf(MetadataStore).isOptional().withDefault(new MetadataStore());\r\n    }\r\n    configParam.applyAll(em);\r\n\r\n    // insure that entityManager's options versions are completely populated\r\n    core.updateWithDefaults(em.queryOptions, defaultQueryOptions);\r\n    core.updateWithDefaults(em.saveOptions, defaultSaveOptions);\r\n    core.updateWithDefaults(em.validationOptions, defaultValidationOptions);\r\n\r\n    if (config.serviceName) {\r\n      em.dataService = new DataService({\r\n        serviceName: em.serviceName\r\n      });\r\n    }\r\n    em.serviceName = em.dataService && em.dataService.serviceName;\r\n\r\n    em.keyGeneratorCtor = em.keyGeneratorCtor || KeyGenerator;\r\n    if (isCtor || config.keyGeneratorCtor) {\r\n      em.keyGenerator = new em.keyGeneratorCtor();\r\n    }\r\n  }\r\n\r\n  createEntity(typeName: string, initialValues?: Object, entityState?: EntityState, mergeStrategy?: MergeStrategy): Entity;\r\n  createEntity(entityType: EntityType, initialValues?: Object, entityState?: EntityState, mergeStrategy?: MergeStrategy): Entity;\r\n  /**\r\n  Creates a new entity of a specified type and optionally initializes it. By default the new entity is created with an EntityState of Added\r\n  but you can also optionally specify an EntityState.  An EntityState of 'Detached' will insure that the entity is created but not yet added\r\n  to the EntityManager. \r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      // create and add an entity;\r\n  >      let emp1 = em1.createEntity(\"Employee\");\r\n  >      // create and add an initialized entity;\r\n  >      let emp2 = em1.createEntity(\"Employee\", { lastName: \"Smith\", firstName: \"John\" });\r\n  >      // create and attach (not add) an initialized entity\r\n  >      let emp3 = em1.createEntity(\"Employee\", { id: 435, lastName: \"Smith\", firstName: \"John\" }, EntityState.Unchanged);\r\n  >      // create but don't attach an entity;\r\n  >      let emp4 = em1.createEntity(\"Employee\", { id: 435, lastName: \"Smith\", firstName: \"John\" }, EntityState.Detached);\r\n  @param typeName - The name of the EntityType for which an instance should be created.\r\n  @param entityType - The EntityType of the type for which an instance should be created.\r\n  @param initialValues - (default=null) Configuration object of the properties to set immediately after creation.\r\n  @param entityState - (default = [[EntityState.Added]]) The EntityState of the entity after being created and added to this EntityManager.\r\n  @param mergeStrategy - (default = [[MergeStrategy.Disallowed]]) - How to handle conflicts if an entity with the same key already exists within this EntityManager.\r\n  @return {Entity} A new Entity of the specified type. \r\n  */\r\n  createEntity(entityType: EntityType | string, initialValues: Object, entityState: EntityState, mergeStrategy: MergeStrategy) {\r\n    assertParam(entityType, \"entityType\").isString().or().isInstanceOf(EntityType).check();\r\n    assertParam(entityState, \"entityState\").isEnumOf(EntityState).isOptional().check();\r\n    assertParam(mergeStrategy, \"mergeStrategy\").isEnumOf(MergeStrategy).isOptional().check();\r\n\r\n    let et = (typeof entityType === \"string\") ? this.metadataStore._getStructuralType(entityType) as EntityType : entityType;\r\n    entityState = entityState || EntityState.Added;\r\n    let entity = {} as Entity;\r\n    core.using(this, \"isLoading\", true, function () {\r\n      entity = et.createEntity(initialValues);\r\n    });\r\n    if (entityState !== EntityState.Detached) {\r\n      entity = this.attachEntity(entity, entityState, mergeStrategy);\r\n    }\r\n    return entity;\r\n  }\r\n\r\n  static importEntities(exportedString: string, config?: ImportConfig): EntityManager;\r\n  static importEntities(exportedData: Object, config?: ImportConfig): EntityManager;\r\n  /**\r\n  Creates a new EntityManager and imports a previously exported result into it.\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let bundle = em1.exportEntities();\r\n  >      // can be stored via the web storage api\r\n  >      window.localStorage.setItem(\"myEntityManager\", bundle);\r\n  >      // assume the code below occurs in a different session.\r\n  >      let bundleFromStorage = window.localStorage.getItem(\"myEntityManager\");\r\n  >      // and imported\r\n  >      let em2 = EntityManager.importEntities(bundleFromStorage);\r\n  >      // em2 will now have a complete copy of what was in em1\r\n  @param exportedString - The result of a previous 'exportEntities' call as a string\r\n  @param exportedData - The result of a previous 'exportEntities' call as an Object.\r\n  @param config - A configuration object.\r\n  @param config.mergeStrategy - A  [[MergeStrategy]] to use when \r\n  merging into an existing EntityManager.\r\n  @param config.metadataVersionFn - A function that takes two arguments (the current metadataVersion and the imported store's 'name')\r\n  and may be used to perform version checking.\r\n  @return A new EntityManager.  Note that the return value of this method call is different from that\r\n  provided by the same named method on an EntityManager instance. Use that method if you need additional information\r\n  regarding the imported entities.\r\n  **/\r\n  static importEntities(exported: string | Object, config?: ImportConfig) {\r\n    let em = new EntityManager();\r\n    em.importEntities(exported, config);\r\n    return em;\r\n  }\r\n\r\n  // instance methods\r\n\r\n  /**\r\n  Calls [[EntityAspect.acceptChanges]] on every changed entity in this EntityManager.\r\n  **/\r\n  acceptChanges() {\r\n    this.getChanges().map(function (entity) {\r\n      return entity.entityAspect._checkOperation(\"acceptChanges\");\r\n    }).forEach(function (aspect) {\r\n      aspect.acceptChanges();\r\n    });\r\n  }\r\n\r\n  /**\r\n  Exports selected entities, all entities of selected types, or an entire EntityManager cache.\r\n\r\n  This method takes a snapshot of an EntityManager that can be stored offline or held in memory.\r\n  Use the [[EntityManager.importEntities]] method to restore or merge the snapshot\r\n  into another EntityManager at some later time.\r\n  >      // let em1 be an EntityManager containing a number of existing entities.\r\n  >     // export every entity in em1.\r\n  >     let bundle = em1.exportEntities();\r\n  >     // save to the browser's local storage\r\n  >     window.localStorage.setItem(\"myEntityManager\", bundle);\r\n  >     // later retrieve the export\r\n  >     let bundleFromStorage = window.localStorage.getItem(\"myEntityManager\");\r\n  >     // import the retrieved export bundle into another manager\r\n  >     let em2 = em1.createEmptyCopy();\r\n  >     em2.importEntities(bundleFromStorage);\r\n  >     // em2 now has a complete, faithful copy of the entities that were in em1\r\n\r\n  You can also control exactly which entities are exported.\r\n  >     // get em1's unsaved changes (an array) and export them.\r\n  >     let changes = em1.getChanges();\r\n  >     let bundle = em1.exportEntities(changes);\r\n  >     // merge these entities into em2 which may contains some of the same entities.\r\n  >     // do NOT overwrite the entities in em2 if they themselves have unsaved changes.\r\n  >     em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges} );\r\n\r\n  Metadata are included in an export by default. You may want to exclude the metadata\r\n  especially if you're exporting just a few entities for local storage.\r\n  >     let bundle = em1.exportEntities(arrayOfSelectedEntities, {includeMetadata: false});\r\n  >     window.localStorage.setItem(\"goodStuff\", bundle);\r\n\r\n  You may still express this option as a boolean value although this older syntax is deprecated.\r\n  >     // Exclude the metadata (deprecated syntax)\r\n  >     let bundle = em1.exportEntities(arrayOfSelectedEntities, false);\r\n\r\n  You can export all entities of one or more specified EntityTypes.\r\n  >     // Export all Customer and Employee entities (and also exclude metadata)\r\n  >     let bundle = em1.exportEntities(['Customer', 'Employee'], {includeMetadata: false});\r\n\r\n  All of the above examples return an export bundle as a string which is the default format.\r\n  You can export the bundle as JSON if you prefer by setting the `asString` option to false.\r\n  >     // Export all Customer and Employee entities as JSON and exclude the metadata\r\n  >     let bundle = em1.exportEntities(['Customer', 'Employee'],\r\n  >                                     {asString: false, includeMetadata: false});\r\n  >     // store JSON bundle somewhere ... perhaps indexDb ... and later import as we do here.\r\n  >     em2.importEntities(bundle);\r\n  @param entities - The entities to export or the EntityType(s) of the entities to export;\r\n    all entities are exported if this parameter is omitted or null.\r\n  @param exportConfig - Export configuration options or a boolean\r\n    - asString - (boolean) - If true (default), return export bundle as a string.\r\n    - includeMetadata - (boolean) - If true (default), include metadata in the export bundle.\r\n  @return The export bundle either serialized as a string (default) or as a JSON object.\r\n  The bundle contains the metadata (unless excluded) and the entity data grouped by type.\r\n  The entity data include property values, change-state, and temporary key mappings (if any).\r\n\r\n  The export bundle internals are deliberately undocumented.  This Breeze-internal representation of entity data is\r\n  suitable for export, storage, and import. The schema and contents of the bundle may change in future versions of Breeze.\r\n  Manipulate it at your own risk with appropriate caution.\r\n  **/\r\n  exportEntities(entities?: Entity[] | EntityType[] | string[], exportConfig?: { asString?: boolean, includeMetadata?: boolean } | boolean): string | Object {\r\n    assertParam(entities, \"entities\").isArray().isEntity()\r\n      .or().isNonEmptyArray().isInstanceOf(EntityType)\r\n      .or().isNonEmptyArray().isString()\r\n      .or().isOptional().check();\r\n\r\n    // assertParam(exportConfig, \"exportConfig\").isObject()\r\n    //   .or().isBoolean()\r\n    //   .or().isOptional().check();\r\n\r\n    if (exportConfig == null) {\r\n      exportConfig = { includeMetadata: true, asString: true };\r\n    } else if (typeof exportConfig === 'boolean') { // deprecated\r\n      exportConfig = { includeMetadata: exportConfig, asString: true };\r\n    }\r\n\r\n    assertConfig(exportConfig)\r\n      .whereParam(\"asString\").isBoolean().isOptional().withDefault(true)\r\n      .whereParam(\"includeMetadata\").isBoolean().isOptional().withDefault(true)\r\n      .applyAll(exportConfig);\r\n\r\n    let exportBundle = exportEntityGroups(this, entities);\r\n    let json = core.extend({}, exportBundle, [\"tempKeys\", \"entityGroupMap\"]);\r\n\r\n    if (exportConfig.includeMetadata) {\r\n      json = core.extend(json, this, [\"dataService\", \"saveOptions\", \"queryOptions\", \"validationOptions\"]);\r\n      (json as any).metadataStore = this.metadataStore.exportMetadata();\r\n    } else {\r\n      (json as any).metadataVersion = MetadataStore.metadataVersion;\r\n      (json as any).metadataStoreName = this.metadataStore.name;\r\n    }\r\n\r\n    let result = exportConfig.asString ? JSON.stringify(json, null, config.stringifyPad) : json;\r\n    return result;\r\n  }\r\n\r\n  // TODO: type the return value { entities: entitiesToLink, tempKeyMapping: tempKeyMap }\r\n  importEntities(exportedString: string, config?: ImportConfig): ImportResult;\r\n  importEntities(exportedData: Object, config?: ImportConfig): ImportResult;\r\n  /**\r\n  Imports a previously exported result into this EntityManager.\r\n\r\n  This method can be used to make a complete copy of any previously created entityManager, even if created\r\n  in a previous session and stored in localStorage. The static version of this method performs a\r\n  very similar process.\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     let bundle = em1.exportEntities();\r\n  >     // bundle can be stored in window.localStorage or just held in memory.\r\n  >     let em2 = new EntityManager({\r\n  >         serviceName: em1.serviceName,\r\n  >         metadataStore: em1.metadataStore\r\n  >     });\r\n  >     em2.importEntities(bundle);\r\n  >     // em2 will now have a complete copy of what was in em1\r\n\r\n  It can also be used to merge the contents of a previously created EntityManager with an\r\n  existing EntityManager with control over how the two are merged.\r\n  >     let bundle = em1.exportEntities();\r\n  >     // assume em2 is another entityManager containing some of the same entities possibly with modifications.\r\n  >     em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges} );\r\n  >     // em2 will now contain all of the entities from both em1 and em2.  Any em2 entities with previously\r\n  >     // made modifications will not have been touched, but all other entities from em1 will have been imported.\r\n  @param exportedString - The result of a previous 'export' call.\r\n  @param importConfig - A configuration object.\r\n  @param importConfig.mergeStrategy -  A [[MergeStrategy]] to use when\r\n  merging into an existing EntityManager.\r\n  @param importConfig.metadataVersionFn - A function that takes two arguments (the current metadataVersion and the imported store's 'name')\r\n  and may be used to perform version checking.\r\n  @return result \r\n    - result.entities {Array of Entities} The entities that were imported.\r\n    - result.tempKeyMap {Object} Mapping from original EntityKey in the import bundle to its corresponding EntityKey in this EntityManager.\r\n  **/\r\n  importEntities(exported: string | Object, importConfig?: ImportConfig) {\r\n    importConfig = importConfig || {};\r\n    assertConfig(importConfig)\r\n      .whereParam(\"mergeStrategy\").isEnumOf(MergeStrategy).isOptional().withDefault(this.queryOptions.mergeStrategy)\r\n      .whereParam(\"metadataVersionFn\").isFunction().isOptional()\r\n      .whereParam(\"mergeAdds\").isBoolean().isOptional()\r\n      .applyAll(importConfig);\r\n\r\n    let json = (typeof exported === \"string\") ? JSON.parse(exported) : exported;\r\n    if (json.metadataStore) {\r\n      this.metadataStore.importMetadata(json.metadataStore);\r\n      // the || clause is for backwards compat with an earlier serialization format.\r\n      this.dataService = (json.dataService && DataService.fromJSON(json.dataService)) || new DataService({ serviceName: json.serviceName });\r\n\r\n      this.saveOptions = new SaveOptions(json.saveOptions);\r\n      this.queryOptions = QueryOptions.fromJSON(json.queryOptions);\r\n      this.validationOptions = new ValidationOptions(json.validationOptions);\r\n    } else {\r\n      importConfig.metadataVersionFn && importConfig.metadataVersionFn({\r\n        metadataVersion: json.metadataVersion,\r\n        metadataStoreName: json.metadataStoreName\r\n      });\r\n    }\r\n\r\n    let tempKeyMap: ITempKeyMap = {};\r\n    json.tempKeys.forEach((k: any) => {\r\n      let oldKey = EntityKey.fromJSON(k, this.metadataStore);\r\n      // try to use oldKey if not already used in this keyGenerator.\r\n      tempKeyMap[oldKey.toString()] = new EntityKey(oldKey.entityType, this.keyGenerator.generateTempKeyValue(oldKey.entityType, oldKey.values[0]));\r\n    });\r\n\r\n    let entitiesToLink: Entity[] = [];\r\n    let impConfig = importConfig as ImportConfigExt;\r\n\r\n    impConfig.tempKeyMap = tempKeyMap;\r\n    core.wrapExecution(() => {\r\n      this._pendingPubs = [];\r\n    }, (state) => {\r\n      this._pendingPubs!.forEach((fn) => fn());\r\n      this._pendingPubs = undefined;\r\n      this._hasChangesAction && this._hasChangesAction();\r\n    }, () => {\r\n      core.objectForEach(json.entityGroupMap, (entityTypeName, jsonGroup) => {\r\n        let entityType = this.metadataStore._getStructuralType(entityTypeName, false) as EntityType;\r\n        let targetEntityGroup = findOrCreateEntityGroup(this, entityType);\r\n        let entities = importEntityGroup(targetEntityGroup, jsonGroup, impConfig);\r\n        if (entities && entities.length) {\r\n          entitiesToLink = entitiesToLink.concat(entities);\r\n        }\r\n      });\r\n      entitiesToLink.forEach((entity) => {\r\n        if (!entity.entityAspect.entityState.isDeleted()) {\r\n          this._linkRelatedEntities(entity);\r\n        }\r\n      });\r\n    });\r\n    return {\r\n      entities: entitiesToLink,\r\n      tempKeyMapping: tempKeyMap\r\n    };\r\n  }\r\n\r\n  /**\r\n  Clears this EntityManager's cache but keeps all other settings. Note that this\r\n  method is not as fast as creating a new EntityManager via 'new EntityManager'.\r\n  This is because clear actually detaches all of the entities from the EntityManager.\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     em1.clear();\r\n  >     // em1 is will now contain no entities, but all other setting will be maintained.\r\n  **/\r\n  clear() {\r\n    core.objectMap(this._entityGroupMap, function (key: string, entityGroup: EntityGroup) {\r\n      return entityGroup._checkOperation('clear');\r\n    }).forEach((entityGroup: EntityGroup) => {\r\n      entityGroup._clear();\r\n    });\r\n\r\n    this._entityGroupMap = {};\r\n    this._unattachedChildrenMap = new UnattachedChildrenMap();\r\n    this.keyGenerator = new this.keyGeneratorCtor();\r\n    this.entityChanged.publish({ entityAction: EntityAction.Clear });\r\n    this._setHasChanges(false);\r\n  }\r\n\r\n  /**\r\n  Creates an empty copy of this EntityManager but with the same DataService, MetadataStore, QueryOptions, SaveOptions, ValidationOptions, etc. \r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     let em2 = em1.createEmptyCopy();\r\n  >     // em2 is a new EntityManager with all of em1's settings\r\n  >     // but no entities.\r\n  @return A new EntityManager.\r\n  **/\r\n  createEmptyCopy() {\r\n    let copy = new EntityManager(core.extend({}, this,\r\n      [\"dataService\", \"metadataStore\", \"queryOptions\", \"saveOptions\", \"validationOptions\", \"keyGeneratorCtor\"]));\r\n    return copy;\r\n  }\r\n\r\n  /**\r\n  Attaches an entity to this EntityManager with an  [[EntityState]] of 'Added'.\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >     let cust1 = custType.createEntity();\r\n  >     em1.addEntity(cust1);\r\n\r\n  Note that this is the same as using 'attachEntity' with an [[EntityState]] of 'Added'.\r\n\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >     let cust1 = custType.createEntity();\r\n  >     em1.attachEntity(cust1, EntityState.Added);\r\n  @param entity - The entity to add.\r\n  @return The added entity.\r\n  **/\r\n  addEntity(entity: Entity) {\r\n    return this.attachEntity(entity, EntityState.Added);\r\n  }\r\n\r\n  /**\r\n  Attaches an entity to this EntityManager with a specified [[EntityState]].\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >     let cust1 = custType.createEntity();\r\n  >     em1.attachEntity(cust1, EntityState.Added);\r\n  @param entity - The entity to add.\r\n  @param entityState - (default=EntityState.Unchanged) The EntityState of the newly attached entity. If omitted this defaults to EntityState.Unchanged.\r\n  @param mergeStrategy - (default = MergeStrategy.Disallowed) How the specified entity should be merged into the EntityManager if this EntityManager already contains an entity with the same key.\r\n  @return The attached entity.\r\n  **/\r\n  attachEntity(entity: Entity, entityState?: EntityState, mergeStrategy?: MergeStrategy) {\r\n    assertParam(entity, \"entity\").isRequired().check();\r\n    this.metadataStore._checkEntityType(entity);\r\n    let esSymbol = assertParam(entityState, \"entityState\").isEnumOf(EntityState).isOptional().check(EntityState.Unchanged) as EntityState;\r\n    let msSymbol = assertParam(mergeStrategy, \"mergeStrategy\").isEnumOf(MergeStrategy).isOptional().check(MergeStrategy.Disallowed) as MergeStrategy;\r\n\r\n    if (entity.entityType.metadataStore !== this.metadataStore) {\r\n      throw new Error(\"Cannot attach this entity because the EntityType (\" + entity.entityType.name +\r\n        \") and MetadataStore associated with this entity does not match this EntityManager's MetadataStore.\");\r\n    }\r\n    let aspect = entity.entityAspect;\r\n    if (aspect) {\r\n      // to avoid reattaching an entity in progress\r\n      if (aspect._inProcessEntity) return aspect._inProcessEntity;\r\n    } else {\r\n      // this occur's when attaching an entity created via new instead of via createEntity.\r\n      aspect = new EntityAspect(entity);\r\n    }\r\n    let manager = aspect.entityManager;\r\n    if (manager) {\r\n      if (manager === this) {\r\n        return entity;\r\n      } else {\r\n        throw new Error(\"This entity already belongs to another EntityManager\");\r\n      }\r\n    }\r\n\r\n    let attachedEntity = {} as Entity;\r\n    core.using(this, \"isLoading\", true, () => {\r\n      if (esSymbol.isAdded()) {\r\n        checkEntityKey(this, entity);\r\n      }\r\n      // attachedEntity === entity EXCEPT in the case of a merge.\r\n      attachedEntity = this._attachEntityCore(entity, esSymbol, msSymbol);\r\n      aspect._inProcessEntity = attachedEntity;\r\n      try {\r\n        // entity ( not attachedEntity) is deliberate here.\r\n        attachRelatedEntities(this, entity, esSymbol, msSymbol);\r\n      } finally {\r\n        // insure that _inProcessEntity is cleared.\r\n        aspect._inProcessEntity = undefined;\r\n      }\r\n    });\r\n    if (this.validationOptions.validateOnAttach) {\r\n      attachedEntity.entityAspect.validateEntity();\r\n    }\r\n    if (!esSymbol.isUnchanged()) {\r\n      this._notifyStateChange(attachedEntity, true);\r\n    }\r\n    this.entityChanged.publish({ entityAction: EntityAction.Attach, entity: attachedEntity });\r\n\r\n    return attachedEntity;\r\n  }\r\n\r\n\r\n  /**\r\n  Detaches an entity from this EntityManager.\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     // assume cust1 is a customer Entity previously attached to em1\r\n  >     em1.detachEntity(cust1);\r\n  >     // em1 will now no longer contain cust1 and cust1 will have an\r\n  >     // entityAspect.entityState of EntityState.Detached\r\n  @param entity - The entity to detach.\r\n  @return Whether the entity could be detached. This will return false if the entity is already detached or was never attached.\r\n  **/\r\n  detachEntity(entity: Entity) {\r\n    assertParam(entity, \"entity\").isEntity().check();\r\n    let aspect = entity.entityAspect;\r\n    if (!aspect) {\r\n      // no aspect means in couldn't appear in any group\r\n      return false;\r\n    }\r\n\r\n    if (aspect.entityManager !== this) {\r\n      throw new Error(\"This entity does not belong to this EntityManager.\");\r\n    }\r\n    return aspect.setDetached();\r\n  }\r\n\r\n  /**\r\n  Fetches the metadata associated with the EntityManager's current 'serviceName'.  This call\r\n  occurs internally before the first query to any service if the metadata hasn't already been\r\n  loaded. __Async__\r\n\r\n  Usually you will not actually process the results of a fetchMetadata call directly, but will instead\r\n  ask for the metadata from the EntityManager after the fetchMetadata call returns.\r\n  >     let em1 = new EntityManager( \"breeze/NorthwindIBModel\");\r\n  >     em1.fetchMetadata()\r\n  >       .then(function() {\r\n  >           let metadataStore = em1.metadataStore;\r\n  >           // do something with the metadata\r\n  >       }).catch(function(exception) {\r\n  >           // handle exception here\r\n  >       });\r\n  \r\n  @param callback - Function called on success.\r\n  @param errorCallback - Function called on failure.\r\n  @return {Promise}\r\n    - schema {Object} The raw Schema object from metadata provider - Because this schema will differ depending on the metadata provider\r\n        it is usually better to access metadata via the 'metadataStore' property of the EntityManager instead of using this 'raw' data.\r\n  **/\r\n  fetchMetadata(dataService?: DataService, callback?: Callback, errorCallback?: ErrorCallback) {\r\n    if (typeof (dataService) === \"function\") {\r\n      // legacy support for when dataService was not an arg. i.e. first arg was callback\r\n      errorCallback = callback;\r\n      callback = dataService;\r\n      dataService = undefined;\r\n    } else {\r\n      assertParam(dataService, \"dataService\").isInstanceOf(DataService).isOptional().check();\r\n      assertParam(callback, \"callback\").isFunction().isOptional().check();\r\n      assertParam(errorCallback, \"errorCallback\").isFunction().isOptional().check();\r\n    }\r\n\r\n    let promise = this.metadataStore.fetchMetadata(dataService || this.dataService);\r\n    return promiseWithCallbacks(promise, callback, errorCallback);\r\n  }\r\n\r\n\r\n  executeQuery(query: string, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;\r\n  executeQuery(query: EntityQuery, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;\r\n  /**\r\n  Executes the specified query. __Async__ \r\n  \r\n  >     let em = new EntityManager(serviceName);\r\n  >     let query = new EntityQuery(\"Orders\");\r\n  >     em.executeQuery(query).then( function(data) {\r\n  >         let orders = data.results;\r\n  >         ... query results processed here\r\n  >     }).catch( function(err) {\r\n  >         ... query failure processed here\r\n  >     });\r\n\r\n  or with callbacks\r\n  >     let em = new EntityManager(serviceName);\r\n  >     let query = new EntityQuery(\"Orders\");\r\n  >     em.executeQuery(query,\r\n  >         function(data) {\r\n  >             let orders = data.results;\r\n  >             ... query results processed here\r\n  >         },\r\n  >         function(err) {\r\n  >             ... query failure processed here\r\n  >         });\r\n\r\n  Either way this method is the same as calling the The [[EntityQuery]] 'execute' method.\r\n  >     let em = new EntityManager(serviceName);\r\n  >     let query = new EntityQuery(\"Orders\").using(em);\r\n  >     query.execute().then( function(data) {\r\n  >         let orders = data.results;\r\n  >         ... query results processed here\r\n  >     }).catch( function(err) {\r\n  >         ... query failure processed here\r\n  >     });\r\n  @param query - The [[EntityQuery]] or OData query string to execute.\r\n  @param callback - Function called on success.\r\n  @param errorCallback - {Function} Function called on failure.\r\n  @return Promise of \r\n    - results - An array of entities\r\n    - retrievedEntities - A array of all of the entities returned by the query.  Differs from results (above) when .expand() is used.\r\n    - query - The original [[EntityQuery]] or query string\r\n    - entityManager -  The EntityManager.\r\n    - httpResponse - The [[IHttpResponse]] returned from the server.\r\n    - inlineCount -  Only available if 'inlineCount(true)' was applied to the query.  Returns the count of\r\n    items that would have been returned by the query before applying any skip or take operators, but after any filter/where predicates\r\n    would have been applied.\r\n  **/\r\n  executeQuery(query: EntityQuery | string, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback) {\r\n    assertParam(query, \"query\").isInstanceOf(EntityQuery).or().isString().check();\r\n    assertParam(callback, \"callback\").isFunction().isOptional().check();\r\n    assertParam(errorCallback, \"errorCallback\").isFunction().isOptional().check();\r\n    let promise: Promise<any>;\r\n    // 'resolve' methods create a new typed object with all of its properties fully resolved against a list of sources.\r\n    // Thought about creating a 'normalized' query with these 'resolved' objects\r\n    // but decided not to because the 'query' may not be an EntityQuery (it can be a string) and hence might not have a queryOptions or dataServices property on it.\r\n    let queryOptions = QueryOptions.resolve([(query as any).queryOptions, this.queryOptions, QueryOptions.defaultInstance]);\r\n    let dataService = DataService.resolve([(query as any).dataService!, this.dataService]);\r\n\r\n    if ((!dataService.hasServerMetadata) || this.metadataStore.hasMetadataFor(dataService.serviceName)) {\r\n      promise = executeQueryCore(this, query, queryOptions, dataService);\r\n    } else {\r\n      promise = this.fetchMetadata(dataService).then(() => {\r\n        return executeQueryCore(this, query, queryOptions, dataService);\r\n      });\r\n    }\r\n\r\n    return promiseWithCallbacks(promise, callback, errorCallback as ErrorCallback);\r\n  }\r\n\r\n  /**\r\n  Executes the specified query against this EntityManager's local cache.\r\n\r\n  Because this method is executed immediately there is no need for a promise or a callback\r\n  >     let em = new EntityManager(serviceName);\r\n  >     let query = new EntityQuery(\"Orders\");\r\n  >     let orders = em.executeQueryLocally(query);\r\n\r\n  Note that this can also be accomplished using the 'executeQuery' method with\r\n  a FetchStrategy of FromLocalCache and making use of the Promise or callback\r\n  >     let em = new EntityManager(serviceName);\r\n  >     let query = new EntityQuery(\"Orders\").using(FetchStrategy.FromLocalCache);\r\n  >     em.executeQuery(query).then( function(data) {\r\n  >         let orders = data.results;\r\n  >         ... query results processed here\r\n  >     }).catch( function(err) {\r\n  >         ... query failure processed here\r\n  >     });\r\n  @param query - The [[EntityQuery]] to execute.\r\n  @return  {Array of Entity}  Array of entities from cache that satisfy the query\r\n  **/\r\n  executeQueryLocally(query: EntityQuery) {\r\n    return executeQueryLocallyCore(this, query).results;\r\n  }\r\n\r\n  /**\r\n  Saves either a list of specified entities or all changed entities within this EntityManager. If there are no changes to any of the entities\r\n  specified then there will be no server side call made but a valid 'empty' saveResult will still be returned. __Async__\r\n\r\n  Often we will be saving all of the entities within an EntityManager that are either added, modified or deleted\r\n  and we will let the 'saveChanges' call determine which entities these are.\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      // This could include added, modified and deleted entities.\r\n  >      em.saveChanges().then(function(saveResult) {\r\n  >          let savedEntities = saveResult.entities;\r\n  >          let keyMappings = saveResult.keyMappings;\r\n  >      }).catch(function (e) {\r\n  >          // e is any exception that was thrown.\r\n  >      });\r\n\r\n  But we can also control exactly which entities to save and can specify specific SaveOptions\r\n\r\n  >      // assume entitiesToSave is an array of entities to save.\r\n  >      let saveOptions = new SaveOptions({ allowConcurrentSaves: true });\r\n  >      em.saveChanges(entitiesToSave, saveOptions).then(function(saveResult) {\r\n  >          let savedEntities = saveResult.entities;\r\n  >          let keyMappings = saveResult.keyMappings;\r\n  >      }).catch(function (e) {\r\n  >          // e is any exception that was thrown.\r\n  >      });\r\n\r\n  Callback methods can also be used\r\n  >      em.saveChanges(entitiesToSave, null,\r\n  >          function(saveResult) {\r\n  >              let savedEntities = saveResult.entities;\r\n  >              let keyMappings = saveResult.keyMappings;\r\n  >          }, function (e) {\r\n  >              // e is any exception that was thrown.\r\n  >          }\r\n  >      );\r\n\r\n  @param entities - The list of entities to save.\r\n  Every entity in that list will be sent to the server, whether changed or unchanged,\r\n  as long as it is attached to this EntityManager.\r\n  If this parameter is omitted, null or empty (the usual case),\r\n  every entity with pending changes in this EntityManager will be saved.\r\n  @param saveOptions - [[SaveOptions]] for the save - will default to\r\n  [[EntityManager.saveOptions]] if null.\r\n  @param callback -  Function called on success.\r\n  @param errorCallback - Function called on failure.\r\n  @return {Promise} Promise\r\n  **/\r\n  saveChanges(entities?: Entity[] | null, saveOptions?: SaveOptions, callback?: Function, errorCallback?: Function) {\r\n    assertParam(entities, \"entities\").isOptional().isArray().isEntity().check();\r\n    assertParam(saveOptions, \"saveOptions\").isInstanceOf(SaveOptions).isOptional().check();\r\n    assertParam(callback, \"callback\").isFunction().isOptional().check();\r\n    assertParam(errorCallback, \"errorCallback\").isFunction().isOptional().check();\r\n\r\n    saveOptions = saveOptions || this.saveOptions || SaveOptions.defaultInstance;\r\n\r\n    let entitiesToSave = getEntitiesToSave(this, entities ? entities : undefined);\r\n\r\n    if (entitiesToSave.length === 0) {\r\n      let result = { entities: [], keyMappings: [] } as SaveResult;\r\n      if (callback) callback(result);\r\n      return Promise.resolve(result);\r\n    }\r\n\r\n    if (!saveOptions.allowConcurrentSaves) {\r\n      let anyPendingSaves = entitiesToSave.some(function (entity) {\r\n        return entity.entityAspect.isBeingSaved;\r\n      });\r\n      if (anyPendingSaves) {\r\n        let err = new Error(\"Concurrent saves not allowed - SaveOptions.allowConcurrentSaves is false\");\r\n        if (errorCallback) errorCallback(err);\r\n        return Promise.reject(err);\r\n      }\r\n    }\r\n\r\n    clearServerErrors(entitiesToSave);\r\n\r\n    let valError = this.saveChangesValidateOnClient(entitiesToSave);\r\n    if (valError) {\r\n      if (errorCallback) errorCallback(valError);\r\n      return Promise.reject(valError);\r\n    }\r\n\r\n    let dataService = DataService.resolve([saveOptions.dataService, this.dataService]);\r\n    let saveContext: SaveContext = {\r\n      entityManager: this,\r\n      dataService: dataService,\r\n      processSavedEntities: processSavedEntities,\r\n      resourceName: saveOptions.resourceName || this.saveOptions.resourceName || \"SaveChanges\"\r\n    };\r\n\r\n    // TODO: need to check that if we are doing a partial save that all entities whose temp keys\r\n    // are referenced are also in the partial save group\r\n\r\n    let saveBundle = { entities: entitiesToSave, saveOptions: saveOptions };\r\n\r\n\r\n    try { // Guard against exception thrown in dataservice adapter before it goes async\r\n      updateConcurrencyProperties(entitiesToSave);\r\n      return dataService.adapterInstance!.saveChanges(saveContext, saveBundle)\r\n        .then(saveSuccess).then((r) => r, saveFail);\r\n    } catch (err) {\r\n      // undo the marking by updateConcurrencyProperties\r\n      markIsBeingSaved(entitiesToSave, false);\r\n      if (errorCallback) errorCallback(err);\r\n      return Promise.reject(err);\r\n    }\r\n\r\n    function saveSuccess(saveResult: SaveResult) {\r\n      let em = saveContext.entityManager;\r\n      markIsBeingSaved(entitiesToSave, false);\r\n      let savedEntities = saveContext.processSavedEntities(saveResult);\r\n      saveResult.entities = savedEntities;\r\n\r\n      // update _hasChanges after save.\r\n      em._setHasChanges();\r\n\r\n      // can't do this anymore because other changes might have been made while saved entities in flight.\r\n      //      let hasChanges = (isFullSave && haveSameContents(entitiesToSave, savedEntities)) ? false : null;\r\n      //      em._setHasChanges(hasChanges);\r\n\r\n      if (callback) callback(saveResult);\r\n      return Promise.resolve(saveResult);\r\n    }\r\n\r\n    function processSavedEntities(saveResult: SaveResult) {\r\n      let savedEntities = saveResult.entities;\r\n      let deletedKeys = saveResult.deletedKeys || [];\r\n      if (savedEntities.length === 0 && deletedKeys.length === 0) {\r\n        return [];\r\n      }\r\n      let keyMappings = saveResult.keyMappings;\r\n      let em = saveContext.entityManager;\r\n\r\n      // must occur outside of isLoading block\r\n      fixupKeys(em, keyMappings);\r\n\r\n      core.using(em, \"isLoading\", true, () => {\r\n\r\n        let mappingContext = new MappingContext({\r\n          query: undefined, // tells visitAndMerge this is a save instead of a query\r\n          entityManager: em,\r\n          mergeOptions: { mergeStrategy: MergeStrategy.OverwriteChanges },\r\n          dataService: dataService\r\n        });\r\n\r\n        // The visitAndMerge operation has been optimized so that we do not actually perform a merge if the\r\n        // the save operation did not actually return the entity - i.e. during OData and Mongo updates and deletes.\r\n        savedEntities = mappingContext.visitAndMerge(savedEntities, { nodeType: \"root\" });\r\n      });\r\n\r\n      // detach any entities found in the em that appear in the deletedKeys list. \r\n      deletedKeys.forEach(key => {\r\n        let entityType = em.metadataStore._getStructuralType(key.entityTypeName) as EntityType;\r\n        let ekey = new EntityKey(entityType, key.keyValues);\r\n        let entity = em.getEntityByKey(ekey);\r\n        if (entity) {\r\n          entity.entityAspect.setDetached();\r\n        }\r\n      });\r\n\r\n      return savedEntities;\r\n    }\r\n\r\n    function saveFail(serverError: SaveErrorFromServer) {\r\n      markIsBeingSaved(entitiesToSave, false);\r\n      let clientError = processServerErrors(saveContext, serverError);\r\n      if (errorCallback) errorCallback(clientError);\r\n      return Promise.reject(clientError);\r\n    }\r\n  }\r\n\r\n  /**\r\n  Run the \"saveChanges\" pre-save client validation logic.\r\n  \r\n  This is NOT a general purpose validation method.\r\n  It is intended for utilities that must know if saveChanges\r\n  would reject the save due to client validation errors.\r\n  \r\n  It only validates entities if the EntityManager's\r\n  [[ValidationOptions]].validateOnSave is true.\r\n  \r\n  @param entitiesToSave {Array of Entity} The list of entities to save (to validate).\r\n  @return {Error} Validation error or null if no error\r\n  **/\r\n  saveChangesValidateOnClient(entitiesToSave: Entity[]) {\r\n\r\n    if (this.validationOptions.validateOnSave) {\r\n      let failedEntities = entitiesToSave.filter(function (entity) {\r\n        let aspect = entity.entityAspect;\r\n        let isValid = aspect.entityState.isDeleted() || aspect.validateEntity();\r\n        return !isValid;\r\n      });\r\n      if (failedEntities.length > 0) {\r\n        let valError = new Error(\"Client side validation errors encountered - see the entityErrors collection on this object for more detail\");\r\n        (valError as any).entityErrors = createEntityErrors(failedEntities);\r\n        return valError; // TODO: type this.\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _findEntityGroup(entityType: EntityType) {\r\n    return this._entityGroupMap[entityType.name];\r\n  }\r\n\r\n  /**\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let employeeType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >      let employeeKey = new EntityKey(employeeType, 1);\r\n  >      let employee = em1.getEntityByKey(employeeKey);\r\n  >      // employee will either be an entity or null.\r\n  **/\r\n  getEntityByKey(entityKey: EntityKey): Entity | null;\r\n\r\n  /**  \r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let employee = em1.getEntityByKey(\"Employee\", 1);\r\n  >      // employee will either be an entity or null.\r\n  **/\r\n  getEntityByKey(typeName: string, keyValues: any | any[]): Entity | null;\r\n\r\n  /**  \r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let employeeType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >      let employee = em1.getEntityByKey(employeeType, 1);\r\n  >      // employee will either be an entity or null.\r\n  **/\r\n  getEntityByKey(type: EntityType, keyValues: any | any[]): Entity | null;\r\n\r\n  /**  \r\n  Attempts to locate an entity within this EntityManager by its [EntityKey].\r\n  @param entityKey - The [[EntityKey]] of the Entity to be located.\r\n  @param type - The [[EntityType]] for this key.\r\n  @param typeName - The EntityType name for this key.\r\n  @param keyValues - The values for this key - will usually just be a single value; an array is only needed for multipart keys.  \r\n  @return An Entity or null;\r\n  **/\r\n  getEntityByKey(...args: any[]) {\r\n    let entityKey = createEntityKey(this, args).entityKey;\r\n    let entityTypes = entityKey._subtypes || [entityKey.entityType];\r\n    let e: Entity | undefined;\r\n    // hack use of some to simulate mapFirst logic.\r\n    entityTypes.some((et) => {\r\n      let group = this._findEntityGroup(et);\r\n      // group version of findEntityByKey doesn't care about entityType\r\n      e = group && group.findEntityByKey(entityKey);\r\n      return e != null;\r\n    });\r\n    return e || null;\r\n  }\r\n\r\n  fetchEntityByKey(typeName: string, keyValues: any | any[], checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;\r\n  fetchEntityByKey(entityType: EntityType, keyValues: any | any[], checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;\r\n  fetchEntityByKey(entityKey: EntityKey, checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;\r\n  /**\r\n  Attempts to fetch an entity from the server by its [[EntityKey]] with\r\n  an option to check the local cache first. Note the this EntityManager's queryOptions.mergeStrategy\r\n  will be used to merge any server side entity returned by this method.\r\n  >     // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >     let employeeType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >     let employeeKey = new EntityKey(employeeType, 1);\r\n  >     em1.fetchEntityByKey(employeeKey).then(function(result) {\r\n  >       let employee = result.entity;\r\n  >       let entityKey = result.entityKey;\r\n  >       let fromCache = result.fromCache;\r\n  >     });\r\n  @param typeName  - The EntityType name for this key.\r\n  @param entityType  - The EntityType for this key.\r\n  @param keyValues - The values for this key - will usually just be a single value; an array is only needed for multipart keys.\r\n  @param entityKey - The [[EntityKey]] of the Entity to be located.\r\n  @param checkLocalCacheFirst - (default = false) - Whether to check this EntityManager first before going to the server. By default, the query will NOT do this.\r\n  @return {Promise}\r\n    - Properties on the promise success result\r\n      - entity {Object} The entity returned or null\r\n      - entityKey {EntityKey} The entityKey of the entity to fetch.\r\n      - fromCache {Boolean} Whether this entity was fetched from the server or was found in the local cache.\r\n  **/\r\n  fetchEntityByKey(...args: any[]) {\r\n    let dataService = DataService.resolve([this.dataService]);\r\n    if ((!dataService.hasServerMetadata) || this.metadataStore.hasMetadataFor(dataService.serviceName)) {\r\n      return fetchEntityByKeyCore(this, args);\r\n    } else {\r\n      return this.fetchMetadata(dataService).then(() => {\r\n        return fetchEntityByKeyCore(this, args);\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n  [Deprecated] - Attempts to locate an entity within this EntityManager by its  [[EntityKey]].\r\n  >     // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >     let employeeType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >     let employeeKey = new EntityKey(employeeType, 1);\r\n  >     let employee = em1.findEntityByKey(employeeKey);\r\n  >     // employee will either be an entity or null.\r\n  @deprecated    Use getEntityByKey instead\r\n  @param entityKey - The  [[EntityKey]] of the Entity to be located.\r\n  @return An Entity or null;\r\n  **/\r\n  findEntityByKey(entityKey: EntityKey) {\r\n    return this.getEntityByKey(entityKey);\r\n  }\r\n\r\n  /**\r\n  Generates a temporary key for the specified entity.  This is used to insure that newly\r\n  created entities have unique keys and to register that these keys are temporary and\r\n  need to be automatically replaced with 'real' key values once these entities are saved.\r\n  \r\n  The [[EntityManager.keyGeneratorCtor]] property is used internally by this method to actually generate\r\n  the keys - See the  KeyGenerator interface interface description to see\r\n  how a custom key generator can be plugged in.\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let customer = custType.createEntity();\r\n  >      let customerId = em.generateTempKeyValue(customer);\r\n  >      // The 'customer' entity 'CustomerID' property is now set to a newly generated unique id value\r\n  >      // This property will change again after a successful save of the 'customer' entity.\r\n  >  \r\n  >      em1.saveChanges().then( function( data) {\r\n  >          let sameCust1 = data.results[0];\r\n  >          // cust1 === sameCust1;\r\n  >          // but cust1.getProperty(\"CustomerId\") != customerId\r\n  >          // because the server will have generated a new id\r\n  >          // and the client will have been updated with this\r\n  >          // new id.\r\n  >      })\r\n  @param entity - The Entity to generate a key for.\r\n  @return The new key value\r\n  **/\r\n  generateTempKeyValue(entity: Entity) {\r\n    // TODO - check if this entity is attached to this EntityManager.\r\n    assertParam(entity, \"entity\").isEntity().check();\r\n    let entityType = entity.entityType;\r\n    let nextKeyValue = this.keyGenerator.generateTempKeyValue(entityType);\r\n    let keyProp = entityType.keyProperties[0];\r\n    entity.setProperty(keyProp.name, nextKeyValue);\r\n    entity.entityAspect.hasTempKey = true;\r\n    return nextKeyValue;\r\n  }\r\n\r\n  hasChanges(): boolean;\r\n  hasChanges(entityTypeNames: string | string[]): boolean;\r\n  hasChanges(entityTypes: EntityType | EntityType[]): boolean;\r\n  /**\r\n  Returns whether there are any changed entities of the specified [[EntityType]]s. A 'changed' Entity has\r\n  has an [[EntityState]] of either Added, Modified or Deleted.\r\n\r\n  This method can be used to determine if an EntityManager has any changes\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      if ( em1.hasChanges() {\r\n  >          // do something interesting\r\n  >      }\r\n\r\n  or if it has any changes on to a specific [[EntityType]].\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      if ( em1.hasChanges(custType) {\r\n  >          // do something interesting\r\n  >      }\r\n\r\n  or to a collection of [[EntityType]]s\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let orderType = em1.metadataStore.getEntityType(\"Order\");\r\n  >      if ( em1.hasChanges( [custType, orderType]) {\r\n  >          // do something interesting\r\n  >      }\r\n  @param entityTypes - The [[EntityType]] or EntityTypes for which 'changed' entities will be found.\r\n  @param entityTypeNames - The [[EntityType]] name or names for which 'changed' entities will be found.\r\n  @return Whether there are any changed entities that match the types specified..\r\n  **/\r\n  hasChanges(entityTypes?: EntityType | EntityType[] | string | string[]) {\r\n    if (!this._hasChanges) return false;\r\n    if (entityTypes === undefined) return this._hasChanges;\r\n    return this._hasChangesCore(entityTypes);\r\n  }\r\n\r\n\r\n  /** @hidden @internal */\r\n  // backdoor to \"really\" check for changes.\r\n  _hasChangesCore(entityTypes?: EntityType | EntityType[] | string | string[]) {\r\n    let ets = checkEntityTypes(this, entityTypes);\r\n    let entityGroups = getEntityGroups(this, ets);\r\n    return entityGroups.some(function (eg) {\r\n      return eg && eg.hasChanges();\r\n    });\r\n  }\r\n\r\n  getChanges(): Entity[];\r\n  getChanges(entityTypeNames: string | string[]): Entity[];\r\n  getChanges(entityTypes: EntityType | EntityType[]): Entity[];\r\n  /**\r\n  Returns a array of all changed entities of the specified [[EntityType]]s. A 'changed' Entity has\r\n  has an [[EntityState]] of either Added, Modified or Deleted.\r\n  \r\n  This method can be used to get all of the changed entities within an EntityManager\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let changedEntities = em1.getChanges();\r\n\r\n  or you can specify that you only want the changes on a specific [[EntityType]]\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let changedCustomers = em1.getChanges(custType);\r\n\r\n  or to a collection of [[EntityType]]s\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let orderType = em1.metadataStore.getEntityType(\"Order\");\r\n  >      let changedCustomersAndOrders = em1.getChanges([custType, orderType]);\r\n  @param entityTypes - The [[EntityType]] or EntityTypes for which 'changed' entities will be found.\r\n  @param entityTypeNames - The [[EntityType]] name or names for which 'changed' entities will be found.\r\n  @return An array of Entities\r\n  **/\r\n  getChanges(entityTypes?: EntityType | EntityType[] | string | string[]) {\r\n    let ets = checkEntityTypes(this, entityTypes);\r\n    return getChangesCore(this, ets);\r\n  }\r\n\r\n  /**\r\n  Rejects (reverses the effects) all of the additions, modifications and deletes from this EntityManager.\r\n  Calls [[EntityAspect.rejectChanges]] on every changed entity in this EntityManager.\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let entities = em1.rejectChanges();\r\n  @return The entities whose changes were rejected. These entities will all have EntityStates of\r\n  either 'Unchanged' or 'Detached'\r\n  **/\r\n  rejectChanges() {\r\n    if (!this._hasChanges) return [];\r\n    let changes = getChangesCore(this);\r\n    // next line stops individual reject changes from each calling _hasChangesCore\r\n    let aspects = changes.map(function (e) {\r\n      return e.entityAspect._checkOperation(\"rejectChanges\");\r\n    });\r\n    this._hasChanges = false;\r\n    aspects.forEach(function (aspect) {\r\n      aspect.rejectChanges();\r\n    });\r\n    this.hasChangesChanged.publish({ entityManager: this, hasChanges: false });\r\n    return changes;\r\n  }\r\n\r\n  getEntities(entityTypeNames?: string | string[], entityStates?: EntityState | EntityState[]): Entity[];\r\n  getEntities(entityTypes?: EntityType | EntityType[], entityStates?: EntityState | EntityState[]): Entity[];\r\n  /**\r\n  Returns a array of all entities of the specified [[EntityType]]s with the specified [[EntityState]]s.\r\n\r\n  This method can be used to get all of the entities within an EntityManager\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let entities = em1.getEntities();\r\n\r\n  or you can specify that you only want the changes on a specific [[EntityType]]\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let customers = em1.getEntities(custType);\r\n\r\n  or to a collection of [[EntityType]]s\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let orderType = em1.metadataStore.getEntityType(\"Order\");\r\n  >      let customersAndOrders = em1.getChanges([custType, orderType]);\r\n\r\n  You can also ask for entities with a particular [[EntityState]] or EntityStates.\r\n  >      // assume em1 is an EntityManager containing a number of preexisting entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let orderType = em1.metadataStore.getEntityType(\"Order\");\r\n  >      let addedCustomersAndOrders = em1.getEntities([custType, orderType], EntityState.Added);\r\n \r\n  @param entityTypeName - The [[EntityType]] name or names for which entities will be found.\r\n  If this parameter is omitted, all EntityTypes are searched.  \r\n  @param entityTypes - The [[EntityType]] or EntityTypes for which entities will be found.\r\n  If this parameter is omitted, all EntityTypes are searched. \r\n  @param entityStates - The [[EntityState]]s for which entities will be found.\r\n  If this parameter is omitted, entities of all EntityStates are returned.\r\n  @return An array of Entities\r\n  **/\r\n  getEntities(entityTypes?: EntityType | EntityType[] | string | string[], entityStates?: EntityState | EntityState[]) {\r\n    let entTypes = checkEntityTypes(this, entityTypes);\r\n    assertParam(entityStates, \"entityStates\").isOptional().isEnumOf(EntityState).or().isNonEmptyArray().isEnumOf(EntityState).check();\r\n\r\n    let states = validateEntityStates(this, entityStates);\r\n    return getEntitiesCore(this, entTypes, states);\r\n  }\r\n\r\n\r\n  // protected methods\r\n  /** @hidden @internal */\r\n  _notifyStateChange(entity: Entity, needsSave: boolean) {\r\n    let ecArgs = { entityAction: EntityAction.EntityStateChange, entity: entity };\r\n\r\n    if (needsSave) {\r\n      if (!this._hasChanges) this._setHasChanges(true);\r\n    } else {\r\n      // called when rejecting a change or merging an unchanged record.\r\n      // NOTE: this can be slow with lots of entities in the cache.\r\n      // so defer it during a query/import or save and call it once when complete ( if needed).\r\n      if (this._hasChanges) {\r\n        if (this.isLoading) {\r\n          this._hasChangesAction = this._hasChangesAction || function () {\r\n            this._setHasChanges(null);\r\n            this.entityChanged.publish(ecArgs);\r\n          }.bind(this);\r\n          return;\r\n        } else {\r\n          this._setHasChanges();\r\n        }\r\n      }\r\n    }\r\n    this.entityChanged.publish(ecArgs);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _setHasChanges(hasChanges?: boolean) {\r\n    if (hasChanges == null) hasChanges = this._hasChangesCore();\r\n    let hadChanges = this._hasChanges;\r\n    this._hasChanges = hasChanges;\r\n    if (hasChanges !== hadChanges) {\r\n      this.hasChangesChanged.publish({ entityManager: this, hasChanges: hasChanges });\r\n    }\r\n    this._hasChangesAction = undefined;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _linkRelatedEntities(entity: Entity) {\r\n    let em = this;\r\n    let entityAspect = entity.entityAspect;\r\n    // we do not want entityState to change as a result of linkage.\r\n    core.using(em, \"isLoading\", true, function () {\r\n\r\n      let unattachedMap = em._unattachedChildrenMap;\r\n      let entityKey = entityAspect.getKey();\r\n      let entityType = entityKey.entityType;\r\n\r\n      while (entityType) {\r\n        let keystring = entityKey.toString(entityType);\r\n\r\n        // attach any unattachedChildren\r\n        let tuples = unattachedMap.getTuplesByString(keystring);\r\n        if (tuples) {\r\n          tuples.slice(0).forEach(function (tpl) {\r\n\r\n            let unattachedChildren = tpl.children.filter(function (e) {\r\n              return e.entityAspect.entityState !== EntityState.Detached;\r\n            });\r\n\r\n            let childToParentNp: NavigationProperty;\r\n            let parentToChildNp: NavigationProperty;\r\n\r\n            // np is usually childToParentNp\r\n            // except with unidirectional 1-n where it is parentToChildNp;\r\n            let np = tpl.navigationProperty;\r\n\r\n            let inverseNp = np.inverse;\r\n            if (inverseNp) {\r\n              // bidirectional\r\n              childToParentNp = np;\r\n              parentToChildNp = inverseNp;\r\n\r\n              if (parentToChildNp.isScalar) {\r\n                let onlyChild = unattachedChildren[0];\r\n                entity.setProperty(parentToChildNp.name, onlyChild);\r\n                onlyChild.setProperty(childToParentNp.name, entity);\r\n              } else {\r\n                let currentChildren = entity.getProperty(parentToChildNp.name);\r\n                unattachedChildren.forEach(function (child) {\r\n                  currentChildren.push(child);\r\n                  child.setProperty(childToParentNp.name, entity);\r\n                });\r\n              }\r\n              unattachedMap.removeChildren(keystring, childToParentNp);\r\n            } else {\r\n              // unidirectional\r\n              // if (np.isScalar || np.parentType !== entity.entityType) {\r\n              if (np.isScalar) {\r\n                // n -> 1  eg: child: OrderDetail parent: Product\r\n                // 1 -> 1 eg child: Employee parent: Employee ( only Manager, no DirectReports property)\r\n                childToParentNp = np;\r\n                unattachedChildren.forEach(function (child) {\r\n                  child.setProperty(childToParentNp.name, entity);\r\n                });\r\n                unattachedMap.removeChildren(keystring, childToParentNp);\r\n              } else {\r\n                // 1 -> n  eg: parent: Region child: Terr\r\n                // TODO: need to remove unattached children from the map after this; only a perf issue.\r\n                parentToChildNp = np;\r\n                let currentChildren = entity.getProperty(parentToChildNp.name);\r\n                unattachedChildren.forEach(function (child) {\r\n                  // we know if can't already be there.\r\n                  currentChildren._push(child);\r\n                });\r\n              }\r\n            }\r\n          });\r\n        }\r\n        entityType = entityType.baseEntityType; // look for relationships up the hierarchy\r\n      }\r\n\r\n\r\n      // now add to unattachedMap if needed.\r\n      entity.entityType.navigationProperties.forEach(function (np) {\r\n        if (np.isScalar) {\r\n          let value = entity.getProperty(np.name);\r\n          // property is already linked up\r\n          if (value) return;\r\n        }\r\n\r\n        // first determine if np contains a parent or child\r\n        // having a parentKey means that this is a child\r\n        // if a parent then no need for more work because children will attach to it.\r\n        let parentKey = entityAspect.getParentKey(np);\r\n        if (parentKey) {\r\n          // check for empty keys - meaning that parent id's are not yet set.\r\n          if (parentKey._isEmpty()) return;\r\n          // if a child - look for parent in the em cache\r\n          if (np.invForeignKeyNames.length) {\r\n            // np relates to non-PK property of parent entity\r\n            const query = new EntityQuery(parentKey.entityType.defaultResourceName).where(np.invForeignKeyNames[0], 'eq', parentKey.values[0]);\r\n            const qresult = em.executeQueryLocally(query);\r\n            if (qresult.length === 1) {\r\n              let parent = qresult[0];\r\n              entity.setProperty(np.name, parent);\r\n            }\r\n          } else {\r\n            // np relates to PK of parent entity\r\n            let parent = em.getEntityByKey(parentKey);\r\n            if (parent) {\r\n              // if found hook it up\r\n              entity.setProperty(np.name, parent);\r\n            } else {\r\n              // else add parent to unresolvedParentMap;\r\n              unattachedMap.addChild(parentKey, np, entity);\r\n            }\r\n          }\r\n        } else if (np.inverse && np.inverse.invForeignKeyNames.length) {\r\n          // np relates to non-PK property of parent entity; query entities by FK\r\n          const akValue = entity.getProperty(np.inverse.invForeignKeyNames[0]);\r\n          const query = new EntityQuery(np.entityType.defaultResourceName).where(np.invForeignKeyNames[0], 'eq', akValue);\r\n          const qresult = em.executeQueryLocally(query);\r\n          qresult.forEach((child: Entity) => {\r\n            child.setProperty(np.inverse.name, entity);\r\n          });\r\n        }\r\n      });\r\n\r\n      // handle unidirectional 1-x where we set x.fk\r\n      entity.entityType.foreignKeyProperties.forEach(function (fkProp) {\r\n        let invNp = fkProp.inverseNavigationProperty;\r\n        if (!invNp) return;\r\n        // unidirectional fk props only\r\n        let fkValue = entity.getProperty(fkProp.name);\r\n        let parentKey = new EntityKey(invNp.parentType, [fkValue]);\r\n        let parent = em.getEntityByKey(parentKey);\r\n\r\n        if (parent) {\r\n          if (invNp.isScalar) {\r\n            parent.setProperty(invNp.name, entity);\r\n          } else {\r\n            if (em.isLoading) {\r\n              parent.getProperty(invNp.name)._push(entity);\r\n            } else {\r\n              parent.getProperty(invNp.name).push(entity);\r\n            }\r\n          }\r\n        } else {\r\n          // else add parent to unresolvedParentMap;\r\n          unattachedMap.addChild(parentKey, invNp, entity);\r\n        }\r\n      });\r\n    });\r\n\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _attachEntityCore(entity: Entity, entityState: EntityState, mergeStrategy: MergeStrategy) {\r\n    let group = findOrCreateEntityGroup(this, entity.entityType);\r\n    let attachedEntity = group.attachEntity(entity, entityState, mergeStrategy);\r\n    this._linkRelatedEntities(attachedEntity);\r\n    return attachedEntity;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateFkVal(fkProp: DataProperty, oldValue: any, newValue: any) {\r\n    let group = this._entityGroupMap[fkProp.parentType.name];\r\n    if (!group) return;\r\n    group._updateFkVal(fkProp, oldValue, newValue);\r\n  }\r\n}\r\n\r\nEntityManager.prototype._$typeName = \"EntityManager\";\r\n\r\nBreezeEvent.bubbleEvent(EntityManager.prototype);\r\n\r\nfunction clearServerErrors(entities: Entity[]) {\r\n  entities.forEach(function (entity) {\r\n    let serverKeys: string[] = [];\r\n    let aspect = entity.entityAspect;\r\n    core.objectForEach(aspect._validationErrors, function (key, ve) {\r\n      if (ve.isServerError) serverKeys.push(key);\r\n    });\r\n    if (serverKeys.length === 0) return;\r\n    aspect._processValidationOpAndPublish(function () {\r\n      serverKeys.forEach(function (key) {\r\n        aspect._removeValidationError(key);\r\n      });\r\n    });\r\n  });\r\n}\r\n\r\nfunction createEntityErrors(entities: Entity[]) {\r\n  let entityErrors: EntityError[] = [];\r\n  entities.forEach((entity) => {\r\n    core.objectForEach(entity.entityAspect._validationErrors, function (key, ve) {\r\n      let cfg = core.extend({\r\n        entity: entity,\r\n        errorName: ve.validator.name\r\n      }, ve, [\"errorMessage\", \"propertyName\", \"isServerError\", \"custom\"]) as EntityError;\r\n      entityErrors.push(cfg);\r\n    });\r\n  });\r\n  return entityErrors;\r\n}\r\n\r\n\r\nfunction processServerErrors(saveContext: SaveContext, saveError: SaveErrorFromServer) {\r\n  // converting ISaveErrorFromServer -> ISaveError\r\n  let serverErrors = saveError.entityErrors;\r\n  if (!serverErrors) return <SaveError> <any> saveError;\r\n  let entityManager = saveContext.entityManager;\r\n  let metadataStore = entityManager.metadataStore;\r\n  let entityErrors = serverErrors.map((serr) => {\r\n    let entity: Entity | null = null;\r\n    let entityType: EntityType | undefined;\r\n    if (serr.keyValues) {\r\n      entityType = metadataStore._getStructuralType(serr.entityTypeName) as EntityType;\r\n      let ekey = new EntityKey(entityType, serr.keyValues);\r\n      entity = entityManager.getEntityByKey(ekey);\r\n    }\r\n\r\n    if (entityType && entity) {\r\n      let context = serr.propertyName ?\r\n        {\r\n          propertyName: serr.propertyName,\r\n          property: entityType.getProperty(serr.propertyName)\r\n        } : {\r\n        };\r\n      let key = ValidationError.getKey(serr.errorName || serr.errorMessage, serr.propertyName);\r\n\r\n      let ve = new ValidationError(null, context, serr.errorMessage, key);\r\n      ve.isServerError = true;\r\n      entity.entityAspect.addValidationError(ve);\r\n    }\r\n\r\n    let entityError = core.extend({\r\n      entity: entity,\r\n      isServerError: true\r\n    }, serr, [\"errorName\", \"errorMessage\", \"propertyName\", \"custom\"]) as EntityError;\r\n    return entityError;\r\n  });\r\n  // converting ISaveErrorFromServer -> ISaveError \r\n  saveError.entityErrors = entityErrors as any;\r\n  return <SaveError> <any> saveError;\r\n}\r\n\r\nexport interface IEntityByKeyResult {\r\n  entity?: Entity;\r\n  entityKey: EntityKey;\r\n  fromCache: boolean;\r\n}\r\n\r\nfunction fetchEntityByKeyCore(em: EntityManager, args: any[]): Promise<IEntityByKeyResult> {\r\n  let tpl = createEntityKey(em, args);\r\n  let entityKey = tpl.entityKey;\r\n\r\n  let checkLocalCacheFirst = tpl.remainingArgs.length === 0 ? false : !!tpl.remainingArgs[0];\r\n  let entity: Entity | null = null;\r\n  let foundIt = false;\r\n  if (checkLocalCacheFirst) {\r\n    entity = em.getEntityByKey(entityKey);\r\n    foundIt = entity != null;\r\n    if (entity != null &&\r\n      // null the entity if it is deleted and we should exclude deleted entities\r\n      !em.queryOptions.includeDeleted && entity.entityAspect.entityState.isDeleted()) {\r\n      entity = null;\r\n      // but resume looking if we'd overwrite deleted entity with a remote entity\r\n      // note: em.queryOptions is always fully resolved by now\r\n      foundIt = em.queryOptions.mergeStrategy !== MergeStrategy.OverwriteChanges;\r\n    }\r\n  }\r\n  if (foundIt) {\r\n    return Promise.resolve({ entity: entity || undefined, entityKey: entityKey, fromCache: true });\r\n  } else {\r\n    return EntityQuery.fromEntityKey(entityKey).using(em).execute().then(function (data: any) {\r\n      entity = (data.results.length === 0) ? null : data.results[0];\r\n      return Promise.resolve({ entity: entity || undefined, entityKey: entityKey, fromCache: false });\r\n    });\r\n  }\r\n}\r\n\r\n\r\n// private fns\r\n\r\n// takes in entityTypes as either strings or entityTypes or arrays of either\r\n// and returns either an entityType or an array of entityTypes or throws an error\r\nfunction checkEntityTypes(em: EntityManager, entityTypes?: EntityType | EntityType[] | string | string[]) {\r\n  assertParam(entityTypes, \"entityTypes\").isString().isOptional().or().isNonEmptyArray().isString()\r\n    .or().isInstanceOf(EntityType).or().isNonEmptyArray().isInstanceOf(EntityType).check();\r\n  let resultTypes: EntityType | EntityType[] | undefined;\r\n  if (typeof entityTypes === \"string\") {\r\n    resultTypes = em.metadataStore._getStructuralType(entityTypes, false) as (EntityType | EntityType[]);\r\n  } else if (Array.isArray(entityTypes) && typeof entityTypes[0] === \"string\") {\r\n    resultTypes = (entityTypes as string[]).map(function (etName) {\r\n      return em.metadataStore._getStructuralType(etName, false) as EntityType;\r\n    });\r\n  } else {\r\n    resultTypes = entityTypes as (EntityType | EntityType[] | undefined);\r\n  }\r\n\r\n  return resultTypes;\r\n}\r\n\r\nfunction getChangesCore(em: EntityManager, entityTypes?: EntityType | EntityType[]) {\r\n  let entityGroups = getEntityGroups(em, entityTypes);\r\n\r\n  // TODO: think about writing a core.mapMany method if we see more of these.\r\n  let selected: Entity[] = [];\r\n  entityGroups.forEach(function (eg) {\r\n    // eg may be undefined or null\r\n    if (!eg) return;\r\n    let entities = eg.getChanges();\r\n    if (selected && selected.length) {\r\n      selected = selected.concat(entities);\r\n    } else {\r\n      selected = entities;\r\n    }\r\n  });\r\n  return selected;\r\n}\r\n\r\nfunction getEntitiesCore(em: EntityManager, entityTypes: EntityType | EntityType[] | undefined, entityStates: EntityState[]) {\r\n  let entityGroups = getEntityGroups(em, entityTypes);\r\n\r\n  // TODO: think about writing a core.mapMany method if we see more of these.\r\n  let selected: Entity[] = [];\r\n  entityGroups.forEach(function (eg) {\r\n    // eg may be undefined or null\r\n    if (!eg) return;\r\n    let entities = eg.getEntities(entityStates);\r\n    if (selected && selected.length) {\r\n      selected = selected.concat(entities);\r\n    } else {\r\n      selected = entities;\r\n    }\r\n  });\r\n  return selected;\r\n}\r\n\r\n\r\nfunction createEntityKey(em: EntityManager, args: any[]) {\r\n  try {\r\n    if (args[0] instanceof EntityKey) {\r\n      return { entityKey: args[0] as EntityKey, remainingArgs: core.arraySlice(args, 1) };\r\n    } else if (args.length >= 2) {\r\n      let entityType = (typeof args[0] === 'string') ? em.metadataStore._getStructuralType(args[0], false) : args[0];\r\n      return { entityKey: new EntityKey(entityType, args[1]), remainingArgs: core.arraySlice(args, 2) };\r\n    }\r\n  } catch (e) {/* throw below */\r\n    // throw new Error(\"Must supply an EntityKey OR an EntityType name or EntityType followed by a key value or an array of key values.\");\r\n  }\r\n  throw new Error(\"Must supply an EntityKey OR an EntityType name or EntityType followed by a key value or an array of key values.\");\r\n}\r\n\r\nfunction markIsBeingSaved(entities: Entity[], flag: boolean) {\r\n  entities.forEach(function (entity) {\r\n    entity.entityAspect.isBeingSaved = flag;\r\n  });\r\n}\r\n\r\nfunction exportEntityGroups(em: EntityManager, entitiesOrEntityTypes: Entity[] | EntityType[] | string[]) {\r\n  let entityGroupMap: { [index: string]: EntityGroup };\r\n  let first = entitiesOrEntityTypes && entitiesOrEntityTypes[0];\r\n  // check if array\r\n  if (first) {\r\n    // group entities by entityType and\r\n    // create 'groups' that look like entityGroups.\r\n    entityGroupMap = {};\r\n    if ((first as any).entityType) {\r\n      let entities = entitiesOrEntityTypes as Entity[];\r\n      // assume \"entities\" is an array of entities;\r\n      entities.forEach(function (e) {\r\n        if (e.entityAspect.entityState === EntityState.Detached) {\r\n          throw new Error(\"Unable to export an entity with an EntityState of 'Detached'\");\r\n        }\r\n        let group = entityGroupMap[e.entityType.name];\r\n        if (!group) {\r\n          group = {} as EntityGroup;\r\n          group.entityType = e.entityType;\r\n          group._entities = [];\r\n          entityGroupMap[e.entityType.name] = group;\r\n        }\r\n        group._entities.push(e);\r\n      });\r\n    } else {\r\n      // assume \"entities\" is an array of EntityTypes (or names)\r\n      let entityTypes = checkEntityTypes(em, entitiesOrEntityTypes as EntityType[] | string[]) as EntityType[];\r\n      if (entityTypes != null) {\r\n        entityTypes.forEach((et) => {\r\n          let group = em._entityGroupMap[et.name];\r\n          if (group && group._entities.length) {\r\n            entityGroupMap[et.name] = group;\r\n          }\r\n        });\r\n      }\r\n    }\r\n  } else if (entitiesOrEntityTypes && entitiesOrEntityTypes.length === 0) {\r\n    // empty array = export nothing\r\n    entityGroupMap = {};\r\n  } else {\r\n    entityGroupMap = em._entityGroupMap;\r\n  }\r\n\r\n  let tempKeys: ITempKey[] = [];\r\n  let newGroupMap = {};\r\n  core.objectForEach(entityGroupMap, (entityTypeName, entityGroup) => {\r\n    newGroupMap[entityTypeName] = exportEntityGroup(entityGroup, tempKeys);\r\n  });\r\n\r\n  return { entityGroupMap: newGroupMap, tempKeys: tempKeys };\r\n}\r\n\r\nfunction exportEntityGroup(entityGroup: EntityGroup, tempKeys: ITempKey[]) {\r\n  let resultGroup = {} as { entities: any[] };\r\n  let entityType = entityGroup.entityType;\r\n  let dps = entityType.dataProperties;\r\n  let serializerFn = getSerializerFn(entityType);\r\n  let rawEntities: any[] = [];\r\n  entityGroup._entities.forEach((entity) => {\r\n    if (entity) {\r\n      let rawEntity = structuralObjectToJson(entity, dps, serializerFn, tempKeys);\r\n      rawEntities.push(rawEntity);\r\n    }\r\n  });\r\n  resultGroup.entities = rawEntities;\r\n  return resultGroup;\r\n}\r\n\r\nfunction structuralObjectToJson(so: StructuralObject, dps: DataProperty[], serializerFn?: (dp: DataProperty, value: any) => any, tempKeys?: ITempKey[]) {\r\n\r\n  let result = {};\r\n  dps.forEach(function (dp) {\r\n    let dpName = dp.name;\r\n    let value = so.getProperty(dpName);\r\n    if (value == null && dp.defaultValue == null) return;\r\n\r\n    if (value && dp.isComplexProperty) {\r\n      let coDps = (dp.dataType as ComplexType).dataProperties;\r\n      value = core.map(value, function (v: ComplexObject) {\r\n        return structuralObjectToJson(v, coDps, serializerFn);\r\n      });\r\n    } else {\r\n      value = serializerFn ? serializerFn(dp, value) : value;\r\n      if (dp.isUnmapped) {\r\n        value = core.toJSONSafe(value, core.toJSONSafeReplacer);\r\n      }\r\n    }\r\n    if (value === undefined) return;\r\n    result[dpName] = value;\r\n  });\r\n\r\n  // if (so.entityAspect) {\r\n  if (EntityAspect.isEntity(so)) {\r\n    let aspect = so.entityAspect;\r\n    let entityState = aspect.entityState;\r\n    let newAspect = {\r\n      tempNavPropNames: exportTempKeyInfo(aspect, tempKeys || []),\r\n      entityState: entityState.name\r\n    } as any;\r\n    if (aspect.extraMetadata) {\r\n      newAspect.extraMetadata = aspect.extraMetadata;\r\n    }\r\n    if (entityState.isModified() || entityState.isDeleted()) {\r\n      newAspect.originalValuesMap = aspect.originalValues;\r\n    }\r\n    (result as any).entityAspect = newAspect;\r\n  } else {\r\n    let aspect = so.complexAspect;\r\n    let newAspect = {} as any;\r\n    if (aspect.originalValues && !core.isEmpty(aspect.originalValues)) {\r\n      newAspect.originalValuesMap = aspect.originalValues;\r\n    }\r\n\r\n    (result as any).complexAspect = newAspect;\r\n  }\r\n\r\n  return result;\r\n}\r\n\r\ninterface ITempKey {\r\n  entityType: string;\r\n  values: any[];\r\n}\r\n\r\nfunction exportTempKeyInfo(entityAspect: EntityAspect, tempKeys: ITempKey[]) {\r\n  let entity = entityAspect.entity as Entity;\r\n  if (entityAspect.hasTempKey) {\r\n    tempKeys.push(entityAspect.getKey().toJSON());\r\n  }\r\n  // create map for this entity with foreignKeys that are 'temporary'\r\n  // map -> key: tempKey, value: fkPropName\r\n  let tempNavPropNames: string[] = [];\r\n  entity.entityType.navigationProperties.forEach(function (np) {\r\n    if (np.relatedDataProperties) {\r\n      let relatedValue = entity.getProperty(np.name);\r\n      if (relatedValue && relatedValue.entityAspect.hasTempKey) {\r\n        tempNavPropNames.push(np.name);\r\n      }\r\n    }\r\n  });\r\n  return tempNavPropNames;\r\n}\r\n\r\nfunction importEntityGroup(entityGroup: EntityGroup, jsonGroup: { entities: any[] }, importConfig: ImportConfigExt) {\r\n\r\n  let tempKeyMap = importConfig.tempKeyMap;\r\n  let mergeAdds = !!importConfig.mergeAdds;\r\n\r\n  let entityType = entityGroup.entityType;\r\n  let mergeStrategy = importConfig.mergeStrategy;\r\n\r\n  let targetEntity: Entity | undefined;\r\n\r\n  let em = entityGroup.entityManager;\r\n  let entityChanged = em.entityChanged;\r\n  let entitiesToLink: Entity[] = [];\r\n  let rawValueFn = DataProperty.getRawValueFromClient;\r\n  jsonGroup.entities.forEach(function (rawEntity: any) {\r\n    let newAspect = rawEntity.entityAspect;\r\n\r\n    let entityKey = entityType.getEntityKeyFromRawEntity(rawEntity, rawValueFn);\r\n    let entityState = EntityState.fromName(newAspect.entityState) as EntityState;\r\n    if (!entityState || entityState === EntityState.Detached) {\r\n      throw new Error(\"Only entities with a non detached entity state may be imported.\");\r\n    }\r\n\r\n    // Merge if raw entity is in cache UNLESS this is a new entity w/ a temp key\r\n    // Cannot safely merge such entities even if could match temp key to an entity in cache.\r\n    // Can enable merge of entities w/temp key using \"mergeAdds\" - use at your own risk!\r\n    let newTempKey = !mergeAdds && entityState.isAdded() && getMappedKey(tempKeyMap!, entityKey);\r\n    targetEntity = newTempKey ? undefined : entityGroup.findEntityByKey(entityKey);\r\n\r\n    if (targetEntity) {\r\n      if (mergeStrategy === MergeStrategy.SkipMerge) {\r\n        // deliberate fall thru\r\n      } else if (mergeStrategy === MergeStrategy.Disallowed) {\r\n        throw new Error(\"A MergeStrategy of 'Disallowed' prevents \" + entityKey.toString() + \" from being merged\");\r\n      } else {\r\n        let targetEntityState = targetEntity.entityAspect.entityState;\r\n        let wasUnchanged = targetEntityState.isUnchanged();\r\n        if (mergeStrategy === MergeStrategy.OverwriteChanges || wasUnchanged) {\r\n          entityType._updateTargetFromRaw(targetEntity, rawEntity, rawValueFn);\r\n          targetEntity.entityAspect.setEntityState(entityState);\r\n          entityChanged.publish({ entityAction: EntityAction.MergeOnImport, entity: targetEntity });\r\n        }\r\n      }\r\n    } else {\r\n      targetEntity = entityType._createInstanceCore() as Entity;\r\n      entityType._updateTargetFromRaw(targetEntity, rawEntity, rawValueFn);\r\n      if (newTempKey) {\r\n        targetEntity.entityAspect.hasTempKey = true;\r\n        // fixup pk\r\n        targetEntity.setProperty(entityType.keyProperties[0].name, newTempKey.values[0]);\r\n\r\n        // fixup foreign keys\r\n        // This is safe because the entity is detached here and therefore originalValues will not be updated.\r\n        if (newAspect.tempNavPropNames) {\r\n          newAspect.tempNavPropNames.forEach(function (npName: string) {\r\n            let np = entityType.getNavigationProperty(npName);\r\n            let fkPropName = np!.relatedDataProperties[0].name;\r\n            let oldFkValue = targetEntity!.getProperty(fkPropName);\r\n            let fk = new EntityKey(np!.entityType, [oldFkValue]);\r\n            let newFk = getMappedKey(tempKeyMap!, fk);\r\n            targetEntity!.setProperty(fkPropName, newFk!.values[0]);\r\n          });\r\n        }\r\n      }\r\n      // Now performed in attachEntity\r\n      targetEntity = entityGroup.attachEntity(targetEntity, entityState);\r\n      entityChanged.publish({ entityAction: EntityAction.AttachOnImport, entity: targetEntity });\r\n      if (!entityState.isUnchanged()) {\r\n        em._notifyStateChange(targetEntity, true);\r\n      }\r\n    }\r\n\r\n    entitiesToLink.push(targetEntity);\r\n  });\r\n  return entitiesToLink;\r\n}\r\n\r\nfunction getMappedKey(tempKeyMap: ITempKeyMap, entityKey: EntityKey) {\r\n  let newKey = tempKeyMap[entityKey.toString()];\r\n  if (newKey) return newKey;\r\n  let subtypes = entityKey._subtypes;\r\n  if (!subtypes) return null;\r\n  for (let i = 0, j = subtypes.length; i < j; i++) {\r\n    newKey = tempKeyMap[entityKey.toString(subtypes[i])];\r\n    if (newKey) return newKey;\r\n  }\r\n  return null;\r\n}\r\n\r\nfunction promiseWithCallbacks<T>(promise: Promise<T>, callback?: Callback, errorCallback?: ErrorCallback) {\r\n  promise = promise.then(function (data) {\r\n    if (callback) callback(data);\r\n    return Promise.resolve(data);\r\n  }, function (error) {\r\n    if (errorCallback) errorCallback(error);\r\n    return Promise.reject(error);\r\n  });\r\n  return promise;\r\n}\r\n\r\nfunction getEntitiesToSave(em: EntityManager, entities?: Entity[]) {\r\n  let entitiesToSave: Entity[];\r\n  if (entities) {\r\n    entitiesToSave = entities.filter(function (e) {\r\n      if (e.entityAspect.entityManager !== em) {\r\n        throw new Error(\"Only entities in this entityManager may be saved\");\r\n      }\r\n      return !e.entityAspect.entityState.isDetached();\r\n    });\r\n  } else {\r\n    entitiesToSave = em.getChanges();\r\n  }\r\n  return entitiesToSave;\r\n}\r\n\r\nfunction fixupKeys(em: EntityManager, keyMappings: KeyMapping[]) {\r\n  em._inKeyFixup = true;\r\n  keyMappings.forEach(function (km) {\r\n    let group = em._entityGroupMap[km.entityTypeName];\r\n    if (!group) {\r\n      throw new Error(\"Unable to locate the following fully qualified EntityType name: \" + km.entityTypeName);\r\n    }\r\n    group._fixupKey(km.tempValue, km.realValue);\r\n  });\r\n  em._inKeyFixup = false;\r\n}\r\n\r\nfunction getEntityGroups(em: EntityManager, entityTypes?: EntityType | EntityType[]) {\r\n  let groupMap = em._entityGroupMap;\r\n  if (entityTypes) {\r\n    return core.toArray(entityTypes).map(function (et: EntityType) {\r\n      if (et instanceof EntityType) {\r\n        return groupMap[et.name];\r\n      } else {\r\n        throw new Error(\"The EntityManager.getChanges() 'entityTypes' parameter must be either an entityType or an array of entityTypes or null\");\r\n      }\r\n    });\r\n  } else {\r\n    return core.getOwnPropertyValues(groupMap) as EntityGroup[];\r\n  }\r\n}\r\n\r\nfunction checkEntityKey(em: EntityManager, entity: Entity) {\r\n  let ek = entity.entityAspect.getKey();\r\n  // return properties that are = to defaultValues\r\n  let keyPropsWithDefaultValues = core.arrayZip(entity.entityType.keyProperties, ek.values, function (kp, kv) {\r\n    return (kp.defaultValue === kv) ? kp : null;\r\n  }).filter(function (kp) {\r\n    return kp !== null;\r\n  });\r\n  if (keyPropsWithDefaultValues.length) {\r\n    if (entity.entityType.autoGeneratedKeyType !== AutoGeneratedKeyType.None) {\r\n      em.generateTempKeyValue(entity);\r\n    } else {\r\n      // we will allow attaches of entities where only part of the key is set.\r\n      if (keyPropsWithDefaultValues.length === ek.values.length) {\r\n        throw new Error(\"Cannot attach an object of type  (\" + entity.entityType.name + \") to an EntityManager without first setting its key or setting its entityType 'AutoGeneratedKeyType' property to something other than 'None'\");\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nfunction validateEntityStates(em: EntityManager, entityStates?: EntityState | EntityState[]) {\r\n  if (!entityStates) return [] as EntityState[];\r\n  let entStates = core.toArray(entityStates) as EntityState[];\r\n  entStates.forEach((es) => {\r\n    if (!(es instanceof EntityState)) {\r\n      throw new Error(\"The EntityManager.getChanges() 'entityStates' parameter must either be null, an entityState or an array of entityStates\");\r\n    }\r\n  });\r\n  return entStates;\r\n}\r\n\r\nfunction attachRelatedEntities(em: EntityManager, entity: Entity, entityState: EntityState, mergeStrategy: MergeStrategy) {\r\n  let navProps = entity.entityType.navigationProperties;\r\n  navProps.forEach(function (np) {\r\n    let related = entity.getProperty(np.name);\r\n    if (np.isScalar) {\r\n      if (!related) return;\r\n      em.attachEntity(related, entityState, mergeStrategy);\r\n    } else {\r\n      related.forEach(function (e: Entity) {\r\n        em.attachEntity(e, entityState, mergeStrategy);\r\n      });\r\n    }\r\n  });\r\n}\r\n\r\n// returns a promise\r\nfunction executeQueryCore(em: EntityManager, query: EntityQuery | string, queryOptions: QueryOptions, dataService: DataService): Promise<QueryResult> {\r\n  try {\r\n    let results: any[];\r\n    let metadataStore = em.metadataStore;\r\n\r\n    if (metadataStore.isEmpty() && dataService.hasServerMetadata) {\r\n      throw new Error(\"cannot execute _executeQueryCore until metadataStore is populated.\");\r\n    }\r\n\r\n    if (queryOptions.fetchStrategy === FetchStrategy.FromLocalCache) {\r\n      try {\r\n        if (typeof query === 'string') {\r\n          throw new Error(\"cannot execute 'string' EntityQuery locally.\");\r\n        }\r\n        let qr = executeQueryLocallyCore(em, query);\r\n        return Promise.resolve({ results: qr.results, entityManager: em, inlineCount: qr.inlineCount, query: query });\r\n      } catch (e) {\r\n        return Promise.reject(e);\r\n      }\r\n    }\r\n\r\n    let mappingContext: MappingContext | undefined = new MappingContext({\r\n      query: query,\r\n      entityManager: em,\r\n      dataService: dataService,\r\n      mergeOptions: {\r\n        mergeStrategy: queryOptions.mergeStrategy,\r\n        noTracking: !!(query as any).noTrackingEnabled,\r\n        includeDeleted: queryOptions.includeDeleted\r\n      }\r\n    });\r\n\r\n    let validateOnQuery = em.validationOptions.validateOnQuery;\r\n\r\n    return dataService.adapterInstance!.executeQuery(mappingContext).then(function (data: any) {\r\n      let result = core.wrapExecution(function () {\r\n        let state = { isLoading: em.isLoading };\r\n        em.isLoading = true;\r\n        em._pendingPubs = [];\r\n        return state;\r\n      }, function (state) {\r\n        // cleanup\r\n        em.isLoading = state.isLoading;\r\n        em._pendingPubs!.forEach(function (fn) {\r\n          fn();\r\n        });\r\n        em._pendingPubs = undefined;\r\n        em._hasChangesAction && em._hasChangesAction();\r\n        // TODO: removed - not sure why needed in first place...\r\n        // // HACK for GC\r\n        // query = undefined;\r\n        mappingContext = undefined;\r\n        // HACK: some errors thrown in next function do not propogate properly - this catches them.\r\n\r\n        if (state.error) {\r\n          return Promise.reject(state.error);\r\n        }\r\n\r\n      }, function () {\r\n        let nodes = dataService.jsonResultsAdapter.extractResults(data);\r\n        nodes = core.toArray(nodes);\r\n\r\n        results = mappingContext!.visitAndMerge(nodes, { nodeType: \"root\" });\r\n        if (validateOnQuery) {\r\n          results.forEach(function (r: any) {\r\n            // anon types and simple types will not have an entityAspect.\r\n            r.entityAspect && r.entityAspect.validateEntity();\r\n          });\r\n        }\r\n        mappingContext!.processDeferred();\r\n        // if query has expand clauses walk each of the 'results' and mark the expanded props as loaded.\r\n        if (query instanceof EntityQuery) {\r\n          markLoadedNavProps(results, query);\r\n        }\r\n        let retrievedEntities = core.objectMap(mappingContext!.refMap);\r\n        return { results: results, query: query, entityManager: em, httpResponse: data.httpResponse, inlineCount: data.inlineCount, retrievedEntities: retrievedEntities };\r\n      });\r\n      return Promise.resolve(result);\r\n    }, function (e: any) {\r\n      if (e) {\r\n        e.query = query;\r\n        e.entityManager = em;\r\n      }\r\n      return Promise.reject(e);\r\n    });\r\n\r\n  } catch (e) {\r\n    if (e) {\r\n      e.query = query;\r\n    }\r\n    return Promise.reject(e);\r\n  }\r\n}\r\n\r\nfunction markLoadedNavProps(entities: Entity[], query: EntityQuery) {\r\n  if (query.noTrackingEnabled) return;\r\n  let expandClause = query.expandClause;\r\n  if (expandClause == null) return;\r\n  expandClause.propertyPaths.forEach(function (propertyPath) {\r\n    let propNames = propertyPath.split('.');\r\n    markLoadedNavPath(entities, propNames);\r\n  });\r\n}\r\n\r\nfunction markLoadedNavPath(entities: Entity[], propNames: string[]) {\r\n  let propName = propNames[0];\r\n  entities.forEach((entity) => {\r\n    let ea = entity.entityAspect;\r\n    if (!ea) return; // entity may not be a 'real' entity in the case of a projection.\r\n    ea._markAsLoaded(propName);\r\n    if (propNames.length === 1) return;\r\n    let next = entity.getProperty(propName);\r\n    if (!next) return; // no children to process.\r\n    // strange logic because nonscalar nav values are NOT really arrays\r\n    // otherwise we could use Array.isArray\r\n    if (!next.arrayChanged) next = [next];\r\n    markLoadedNavPath(next, propNames.slice(1));\r\n  });\r\n}\r\n\r\nfunction updateConcurrencyProperties(entities: Entity[]) {\r\n  let candidates = entities.filter((e) => {\r\n    e.entityAspect.isBeingSaved = true;\r\n    return e.entityAspect.entityState.isModified()\r\n      && e.entityType.concurrencyProperties.length > 0;\r\n\r\n  });\r\n  if (candidates.length === 0) return;\r\n  candidates.forEach(function (c) {\r\n    c.entityType.concurrencyProperties.forEach(function (cp) {\r\n      updateConcurrencyProperty(c, cp);\r\n    });\r\n  });\r\n}\r\n\r\nfunction updateConcurrencyProperty(entity: Entity, property: DataProperty) {\r\n  // check if property has already been updated\r\n  if (entity.entityAspect.originalValues[property.name]) return;\r\n  let value = entity.getProperty(property.name);\r\n  let dataType = property.dataType as DataType;\r\n  if (!value) value = dataType.defaultValue;\r\n  if (dataType.isNumeric) {\r\n    entity.setProperty(property.name, value + 1);\r\n  } else if (dataType.getConcurrencyValue) {\r\n    // DataType has its own implementation\r\n    let nextValue = dataType.getConcurrencyValue(value);\r\n    entity.setProperty(property.name, nextValue);\r\n  } else if (dataType === DataType.Binary) {\r\n    // best guess - that this is a timestamp column and is computed on the server during save\r\n    // - so no need to set it here.\r\n    return;\r\n  } else {\r\n    // this just leaves DataTypes of Boolean, String and Byte - none of which should be the\r\n    // type for a concurrency column.\r\n    // NOTE: thought about just returning here but would rather be safe for now.\r\n    throw new Error(\"Unable to update the value of concurrency property before saving: \" + property.name);\r\n  }\r\n}\r\n\r\n\r\nfunction findOrCreateEntityGroup(em: EntityManager, entityType: EntityType) {\r\n  let group = em._entityGroupMap[entityType.name];\r\n  if (!group) {\r\n    group = new EntityGroup(em, entityType);\r\n    em._entityGroupMap[entityType.name] = group;\r\n  }\r\n  return group;\r\n}\r\n\r\nfunction findOrCreateEntityGroups(em: EntityManager, entityType: EntityType) {\r\n  let entityTypes = entityType.getSelfAndSubtypes();\r\n  return entityTypes.map((et) => {\r\n    return findOrCreateEntityGroup(em, et);\r\n  });\r\n}\r\n\r\nfunction unwrapInstance(structObj: StructuralObject, transformFn?: (dp: DataProperty, val: any) => any) {\r\n\r\n  let rawObject: any = {};\r\n  let stype = EntityAspect.isEntity(structObj) ? structObj.entityType : structObj.complexType;\r\n  let serializerFn = getSerializerFn(stype);\r\n  let unmapped = {};\r\n  stype.dataProperties.forEach(function (dp) {\r\n    if (dp.isComplexProperty) {\r\n      rawObject[dp.nameOnServer] = core.map(structObj.getProperty(dp.name), function (co) {\r\n        return unwrapInstance(co, transformFn);\r\n      });\r\n    } else {\r\n      let val = structObj.getProperty(dp.name);\r\n      val = transformFn ? transformFn(dp, val) : val;\r\n      if (val === undefined) return;\r\n      val = serializerFn ? serializerFn(dp, val) : val;\r\n      if (val !== undefined) {\r\n        if (dp.isUnmapped) {\r\n          unmapped[dp.nameOnServer] = core.toJSONSafe(val, core.toJSONSafeReplacer);\r\n        } else {\r\n          rawObject[dp.nameOnServer] = val;\r\n        }\r\n      }\r\n    }\r\n  });\r\n\r\n  if (!core.isEmpty(unmapped)) {\r\n    // TODO: review this.\r\n    (rawObject as any).__unmapped = unmapped;\r\n  }\r\n  return rawObject;\r\n}\r\n\r\nfunction unwrapOriginalValues(target: StructuralObject, metadataStore: MetadataStore, transformFn?: (dp: DataProperty, val: any) => any) {\r\n  let stype = EntityAspect.isEntity(target) ? target.entityType : target.complexType;\r\n  let aspect = EntityAspect.isEntity(target) ? target.entityAspect : target.complexAspect;\r\n  let fn = metadataStore.namingConvention.clientPropertyNameToServer;\r\n  let result = {};\r\n  core.objectForEach(aspect.originalValues, function (propName, val) {\r\n    let prop = stype.getProperty(propName) as DataProperty;\r\n    val = transformFn ? transformFn(prop, val) : val;\r\n    if (val !== undefined) {\r\n      result[fn(propName, prop)] = val;\r\n    }\r\n  });\r\n  stype.complexProperties.forEach(function (cp) {\r\n    let nextTarget = target.getProperty(cp.name);\r\n    if (cp.isScalar) {\r\n      let unwrappedCo = unwrapOriginalValues(nextTarget, metadataStore, transformFn);\r\n      if (!core.isEmpty(unwrappedCo)) {\r\n        result[fn(cp.name, cp)] = unwrappedCo;\r\n      }\r\n    } else {\r\n      let unwrappedCos = nextTarget.map((item: any) => {\r\n        return unwrapOriginalValues(item, metadataStore, transformFn);\r\n      });\r\n      result[fn(cp.name, cp)] = unwrappedCos;\r\n    }\r\n  });\r\n  return result;\r\n}\r\n\r\nfunction unwrapChangedValues(entity: Entity, metadataStore: MetadataStore, transformFn: (dp: DataProperty, val: any) => any) {\r\n  let stype = entity.entityType;\r\n  let serializerFn = getSerializerFn(stype);\r\n  let fn = metadataStore.namingConvention.clientPropertyNameToServer;\r\n  let result = {};\r\n  core.objectForEach(entity.entityAspect.originalValues, function (propName, value) {\r\n    let prop = stype.getProperty(propName) as DataProperty;\r\n    let val = entity.getProperty(propName);\r\n    val = transformFn ? transformFn(prop, val) : val;\r\n    if (val === undefined) return;\r\n    val = serializerFn ? serializerFn(prop, val) : val;\r\n    if (val !== undefined) {\r\n      result[fn(propName, prop)] = val;\r\n    }\r\n  });\r\n  // any change to any complex object or array of complex objects returns the ENTIRE\r\n  // current complex object or complex object array.  This is by design. Complex Objects\r\n  // are atomic.\r\n  stype.complexProperties.forEach((cp) => {\r\n    if (cpHasOriginalValues(entity, cp)) {\r\n      let coOrCos = entity.getProperty(cp.name);\r\n      result[fn(cp.name, cp)] = core.map(coOrCos, function (co) {\r\n        return unwrapInstance(co, transformFn);\r\n      });\r\n    }\r\n  });\r\n  return result;\r\n}\r\n\r\nfunction cpHasOriginalValues(structuralObject: StructuralObject, cp: DataProperty): boolean {\r\n  let coOrCos = structuralObject.getProperty(cp.name);\r\n  if (cp.isScalar) {\r\n    return coHasOriginalValues(coOrCos);\r\n  } else {\r\n    // this occurs when a nonscalar co array has had cos added or removed.\r\n    if (coOrCos._origValues) return true;\r\n    return coOrCos.some(function (co: ComplexObject) {\r\n      return coHasOriginalValues(co);\r\n    });\r\n  }\r\n}\r\n\r\nfunction executeQueryLocallyCore(em: EntityManager, query: EntityQuery) {\r\n  assertParam(query, \"query\").isInstanceOf(EntityQuery).check();\r\n\r\n  let metadataStore = em.metadataStore;\r\n  let entityType = query._getFromEntityType(metadataStore, true);\r\n  // there may be multiple groups is this is a base entity type.\r\n  let groups = findOrCreateEntityGroups(em, entityType!);\r\n  // filter then order then skip then take\r\n  let filterFunc = query.wherePredicate && query.wherePredicate.toFunction({ entityType: entityType });\r\n\r\n  let queryOptions = QueryOptions.resolve([query.queryOptions, em.queryOptions, QueryOptions.defaultInstance]);\r\n  let includeDeleted = queryOptions.includeDeleted === true;\r\n\r\n  let newFilterFunc = function (entity: Entity) {\r\n    return entity && (includeDeleted || !entity.entityAspect.entityState.isDeleted()) && (filterFunc ? filterFunc(entity) : true);\r\n  };\r\n\r\n  let result: any[] = [];\r\n  // TODO: mapMany\r\n  groups.forEach((group) => {\r\n    let entities = group._entities.filter(newFilterFunc) as Entity[];\r\n    if (entities.length) {\r\n      result = result.length ? result.concat(entities) : entities;\r\n    }\r\n  });\r\n\r\n  let orderByComparer = query.orderByClause && query.orderByClause.getComparer(entityType!);\r\n  if (orderByComparer) {\r\n    result.sort(orderByComparer);\r\n  }\r\n\r\n  let inlineCount = query.inlineCountEnabled ? result.length : undefined;\r\n\r\n  let skipCount = query.skipCount;\r\n  if (skipCount) {\r\n    result = result.slice(skipCount);\r\n  }\r\n  let takeCount = query.takeCount;\r\n  if (takeCount) {\r\n    result = result.slice(0, takeCount);\r\n  }\r\n\r\n  let selectClause = query.selectClause;\r\n  if (selectClause) {\r\n    let selectFn = selectClause.toFunction();\r\n    result = result.map(selectFn);\r\n  }\r\n  return { results: result, inlineCount: inlineCount };\r\n}\r\n\r\nfunction coHasOriginalValues(co: ComplexObject) {\r\n  // next line checks all non complex properties of the co.\r\n  if (!core.isEmpty(co.complexAspect.originalValues)) return true;\r\n  // now need to recursively check each of the cps\r\n  return co.complexType.complexProperties.some(function (cp) {\r\n    return cpHasOriginalValues(co, cp);\r\n  });\r\n}\r\n\r\nfunction getSerializerFn(stype: EntityType | ComplexType) {\r\n  return stype.serializerFn || (stype.metadataStore && stype.metadataStore.serializerFn);\r\n}\r\n\r\n"]}