breeze-client 2.2.2 → 3.0.0

package/manager/entity-manager.js

@@ -0,0 +1,2395 @@
+import { core, arraySlice } from '../core/core.js';
+import { assertParam, assertConfig } from '../core/assert-param.js';
+import { config, setDefaultAdapters } from '../config/config.js';
+import { BreezeEvent } from '../core/event.js';
+import { EntityAspect, peekProperty } from '../entity/entity-aspect.js';
+import { MetadataStore, EntityType, DataProperty, AutoGeneratedKeyType, entityTypeForCtor } from '../metadata/entity-metadata.js';
+import { EntityKey } from '../entity/entity-key.js';
+import { observableArray } from '../entity/observable-array.js';
+import { EntityAction } from '../entity/entity-action.js';
+import { EntityState } from '../entity/entity-state.js';
+import { DataService } from '../metadata/data-service.js';
+import { DataType } from '../metadata/data-type.js';
+import { ValidationError } from '../validation/validate.js';
+import { ValidationOptions } from '../validation/validation-options.js';
+import { QueryOptions, MergeStrategy, FetchStrategy } from '../query/query-options.js';
+import { SaveOptions } from './save-options.js';
+import { KeyGenerator } from '../entity/key-generator.js';
+import { EntityGroup } from '../entity/entity-group.js';
+import { MappingContext } from '../query/mapping-context.js';
+import { EntityQuery } from '../query/entity-query.js';
+import { UnattachedChildrenMap } from '../entity/unattached-children-map.js';
+import { serverDefaultAdapters } from '../config/default-adapters.js';
+/** The RFC 9457 `type` URIs a Breeze server sends on {@link ServerError.problemType}.
+
+A problem type is a stable identifier for a *kind* of failure, which is what a status code often
+is not: `409` covers both a concurrency conflict and a duplicate key, and the two call for
+different recovery. */
+export const ProblemTypes = {
+    /** A row was changed or deleted by someone else after this client read it. */
+    concurrencyConflict: "https://breeze.github.io/problems/concurrency-conflict",
+    /** The save was rejected by validation; see `entityErrors`. */
+    entityErrors: "https://breeze.github.io/problems/entity-errors",
+    /** An unhandled exception on the server. */
+    serverError: "https://breeze.github.io/problems/server-error",
+};
+/** Whether an error is an optimistic concurrency conflict - a row changed or deleted by someone
+else after this client read it.
+
+```ts
+try {
+  await em.saveChanges();
+} catch (e) {
+  if (isConcurrencyError(e)) {
+    // re-read and let the user decide; retrying the same save would fail the same way
+  }
+}
+```
+
+This is exact rather than approximate: it is true only when the server said so with
+{@link ProblemTypes.concurrencyConflict}, never inferred from the status code or the message. A
+`409` from a duplicate key is not a concurrency conflict, and matching on message text breaks
+when the ORM, database or server version changes.
+
+A Breeze .NET server sends this for EF Core's `DbUpdateConcurrencyException` and NHibernate's
+`StaleObjectStateException`. A server that does not send a `type` - any pre-3.0 Breeze server, and
+most non-Breeze ones - returns false here, and there is nothing reliable to use instead.
+
+When the conflict names the rows involved, they are on `entityErrors` with the entities attached:
+
+```ts
+const stale = (e.entityErrors ?? [])
+  .filter(ee => ee.errorName === "ConcurrencyError")
+  .map(ee => ee.entity);
+```
+@param error The rejection value from a Breeze call - typically a {@link SaveError}.
+@returns true if the server identified this as a concurrency conflict. */
+export function isConcurrencyError(error) {
+    return !!error && error.problemType === ProblemTypes.concurrencyConflict;
+}
+/**
+Instances of the EntityManager contain and manage collections of entities, either retrieved from a backend datastore or created on the client.
+*/
+export class EntityManager {
+    // events
+    /**
+    A {@link BreezeEvent} that fires whenever a change to any entity in this EntityManager occurs. __Read Only__
+  
+    @eventArgs -
+    - entityAction - The {@link EntityAction} that occured.
+    - entity - The entity that changed. Undefined for {@link EntityAction.Clear}, which affects every entity in the manager.
+    - args - Additional information about this event. This will differ based on the entityAction.
+  
+    ```ts
+    const em = new EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+    em.entityChanged.subscribe(changeArgs => {
+        // This code will be executed any time any entity within the entityManager
+        // is added, modified, deleted or detached for any reason.
+        const action = changeArgs.entityAction;
+        const entity = changeArgs.entity;
+        // .. do something to this entity when it is changed.
+    });
+    ```
+    @event
+    */
+    entityChanged;
+    /**
+    An {@link BreezeEvent} that fires whenever validationErrors change for any entity in this EntityManager. __Read Only__
+    @eventArgs -
+      - entity - The entity on which the validation errors have been added or removed.
+      - added - An array containing any newly added {@link ValidationError}s
+      - removed - An array containing any newly removed {@link ValidationError}s. This is those errors that have been 'fixed'
+  
+    ```ts
+    const em = new EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+    em.validationErrorsChanged.subscribe(changeArgs => {
+        // This code will be executed any time any entity within the entityManager
+        // experiences a change to its validationErrors collection.
+        const entity = changeArgs.entity;
+        const errorsAdded = changeArgs.added;
+        const errorsCleared = changeArgs.removed;
+        // ... do something interesting with the entity.
+    });
+    ```
+    @event
+    */
+    validationErrorsChanged;
+    /**
+    A {@link BreezeEvent} that fires whenever an EntityManager transitions to or from having changes. __Read Only__
+    @eventArgs -
+      - entityManager - The EntityManager whose 'hasChanges' status has changed.
+      - hasChanges - Whether or not this EntityManager has changes.
+  
+    ```ts
+    const em = new EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+    em.hasChangesChanged.subscribe(args => {
+        const hasChanges = args.hasChanges;
+        const entityManager = args.entityManager;
+    });
+    ```
+    @event
+    */
+    hasChangesChanged;
+    /** @hidden @internal */
+    _pendingPubs; // TODO: refine later
+    /** @hidden @internal */
+    // Deferred to the end of a load: recomputing hasChanges scans the cache, so it is done once
+    // when the load finishes rather than per entity. See _notifyStateChange.
+    _hasChangesAction;
+    /** @hidden @internal */
+    _hasChanges;
+    /** @hidden @internal Keyed by qualified entityType name. */
+    _entityGroupMap;
+    /** @hidden @internal */
+    _unattachedChildrenMap;
+    /** @hidden @internal */
+    _inKeyFixup;
+    /** Functions a {@link DataServiceAdapter} uses to build the save request: `unwrapInstance` turns an
+    entity or complex object into a plain object with server property names, `unwrapOriginalValues`
+    does the same for its original values, and `unwrapChangedValues` for the current values of its
+    changed properties. For adapter authors; applications do not normally need it. */
+    helper = {
+        /** Turns an entity or complex object into a plain object keyed by server property names. */
+        unwrapInstance: unwrapInstance,
+        /** The same, for the original values of an entity's changed properties. */
+        unwrapOriginalValues: unwrapOriginalValues,
+        /** The same, for the current values of an entity's changed properties. */
+        unwrapChangedValues: unwrapChangedValues
+    };
+    /**
+    EntityManager constructor.
+  
+    At its most basic an EntityManager can be constructed with just a service name
+    ```ts
+    const entityManager = new EntityManager("breeze/NorthwindIBModel");
+    ```
+  
+    This is the same as calling it with the following configuration object
+    ```ts
+    const entityManager = new EntityManager({ serviceName: "breeze/NorthwindIBModel" });
+    ```
+  
+    Usually however, configuration objects will contain more than just the 'serviceName';
+    ```ts
+    const metadataStore = new MetadataStore();
+    const entityManager = new EntityManager({
+      serviceName: "breeze/NorthwindIBModel",
+      metadataStore: metadataStore
+    });
+    ```
+  
+    or
+    ```ts
+    const queryOptions = new QueryOptions({
+        mergeStrategy: MergeStrategy.OverwriteChanges,
+        fetchStrategy: FetchStrategy.FromServer
+    });
+    const validationOptions = new ValidationOptions({
+        validateOnAttach: true,
+        validateOnSave: true,
+        validateOnQuery: false
+    });
+    const entityManager = new EntityManager({
+        serviceName: "breeze/NorthwindIBModel",
+        queryOptions: queryOptions,
+        validationOptions: validationOptions
+    });
+    ```
+    @param emConfig - Configuration settings or a service name.
+    */
+    constructor(emConfig) {
+        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);
+        // Given a real value here rather than left undefined, because `core.using` restores a
+        // property it found undefined by *deleting* it. These two are scoped with `core.using` on
+        // every createEntity, query merge and rejectChanges, so the manager was having a property
+        // added and removed several times per entity - which is what puts an object into V8's
+        // dictionary-properties mode, permanently, for every property it has. Reads of
+        // `metadataStore`, `queryOptions` and the rest then cost about 20x what they should.
+        this.isLoading = false;
+        this.isRejectingChanges = false;
+        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 {@link EntityManagerConfig}
+    may be set.
+    ```ts
+    // 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) {
+            // Use the store's DataService for this service when it has one (added with addDataService, by fetchMetadata or
+            // from imported metadata), so that its settings - hasServerMetadata among them - apply to this manager.
+            em.dataService = em.metadataStore.getDataService(em.serviceName) || 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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    // create and add an entity. Passing the registered class types the result:
+    const emp1 = em1.createEntity(Employee);            // Employee
+    // create and add an initialized entity;
+    const emp2 = em1.createEntity(Employee, { lastName: "Smith", firstName: "John" });
+    // create and attach (not add) an initialized entity
+    const emp3 = em1.createEntity(Employee, { employeeID: 435, lastName: "Smith", firstName: "John" }, EntityState.Unchanged);
+    // create but don't attach an entity;
+    const emp4 = em1.createEntity(Employee, { employeeID: 435, lastName: "Smith", firstName: "John" }, EntityState.Detached);
+    // with the constructor, initialValues is checked: a property Employee does not declare,
+    // such as a misspelling, is a compile error rather than a value silently ignored
+    em1.createEntity(Employee, { lastNmae: "Smith" });   // error
+  
+    // the type name and the EntityType both still work, and return Entity:
+    const emp5 = em1.createEntity("Employee", { lastName: "Smith" });
+    ```
+  
+    The constructor overload needs the class to have been registered with
+    {@link MetadataStore.registerEntityTypeCtor}; that is what tells Breeze which type it stands
+    for. An unregistered class throws. See the Typed entities guide.
+    @param entityCtor - A constructor registered for the EntityType to create.
+    @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.
+    With the constructor overload it is typed as {@link InitialValues}, so a property the class does
+    not declare is a compile error.
+    @param entityState - (default = {@link EntityState.Added}) The EntityState of the entity after being created and added to this EntityManager.
+    @param mergeStrategy - (default = {@link MergeStrategy.Disallowed}) - How to handle conflicts if an entity with the same key already exists within this EntityManager.
+    @returns {Entity} A new Entity of the specified type.
+    */
+    createEntity(entityType, initialValues, entityState, mergeStrategy) {
+        // A constructor stands for its type *name*, which is then looked up in this manager's own
+        // MetadataStore. Using the EntityType hanging off the constructor's prototype would tie the
+        // call to whichever store the class was registered with, and a manager with an equivalent
+        // store - a copy, or one built from the same metadata - would fail deep inside attachEntity
+        // with a store-mismatch error.
+        if (typeof entityType === "function") {
+            entityType = entityTypeForCtor(entityType).name;
+        }
+        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) {
+            // The two enums were checked above; no need for attachEntity to check them again.
+            entity = this._attachEntity(entity, entityState, mergeStrategy || MergeStrategy.Disallowed);
+        }
+        return entity;
+    }
+    /**
+    Creates a new EntityManager and imports a previously exported result into it.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const bundle = em1.exportEntities() as string;
+    // can be stored via the web storage api
+    window.localStorage.setItem("myEntityManager", bundle);
+    // assume the code below occurs in a different session.
+    const bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    // and imported
+    const 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  {@link MergeStrategy} to use when
+    merging into an existing EntityManager.
+    @param config.metadataVersionFn - A function called with `{ metadataVersion, metadataStoreName }` from the
+    import bundle, for version checking; throw from it to reject the import. Only called when the bundle was
+    exported without its metadata.
+    @returns 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 {@link 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 {@link EntityManager.importEntities} method to restore or merge the snapshot
+    into another EntityManager at some later time.
+    ```ts
+    // let em1 be an EntityManager containing a number of existing entities.
+    // export every entity in em1.
+    const bundle = em1.exportEntities() as string;
+    // save to the browser's local storage
+    window.localStorage.setItem("myEntityManager", bundle);
+    // later retrieve the export
+    const bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    // import the retrieved export bundle into another manager
+    const 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.
+    ```ts
+    // get em1's unsaved changes (an array) and export them.
+    const changes = em1.getChanges();
+    const 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.
+    ```ts
+    const bundle = em1.exportEntities(arrayOfSelectedEntities, { includeMetadata: false }) as string;
+    window.localStorage.setItem("goodStuff", bundle);
+    ```
+  
+    You may still express this option as a boolean value although this older syntax is deprecated.
+    ```ts
+    // Exclude the metadata (deprecated syntax)
+    const bundle = em1.exportEntities(arrayOfSelectedEntities, false);
+    ```
+  
+    You can export all entities of one or more specified EntityTypes, by name.
+    ```ts
+    // Export all Customer and Employee entities (and also exclude metadata)
+    const 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.
+    ```ts
+    // Export all Customer and Employee entities as JSON and exclude the metadata
+    const 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 types of the entities to export - as registered
+      classes, {@link EntityType}s or type names. 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.
+    @returns 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) {
+        // A registered class stands for its type name, as it does for getEntities.
+        if (Array.isArray(entities) && typeof entities[0] === "function") {
+            entities = entities.map(ctor => entityTypeForCtor(ctor).name);
+        }
+        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); // classes were resolved to names above
+        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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const bundle = em1.exportEntities();
+    // bundle can be stored in window.localStorage or just held in memory.
+    const 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.
+    ```ts
+    const 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 {@link MergeStrategy} to use when
+    merging into an existing EntityManager.
+    @param importConfig.metadataVersionFn - A function called with `{ metadataVersion, metadataStoreName }` from the
+    import bundle, for version checking; throw from it to reject the import. Only called when the bundle was
+    exported without its metadata.
+    @returns result
+      - result.entities {Array of Entities} The entities that were imported.
+      - result.tempKeyMapping {Object} For each temporary key in the bundle, the temporary {@link EntityKey} the entity has in this manager - see {@link ITempKeyMap}.
+    */
+    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.
+    ```ts
+    // 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() {
+        // The constructor calls clear() before _entityGroupMap is assigned, so this runs
+        // once with it undefined. core.objectMap used to absorb that; Map.values() does not.
+        Array.from(this._entityGroupMap?.values() ?? [])
+            .map(entityGroup => entityGroup._checkOperation('clear'))
+            .forEach(entityGroup => entityGroup._clear());
+        this._entityGroupMap = new Map();
+        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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const em2 = em1.createEmptyCopy();
+    // em2 is a new EntityManager with all of em1's settings
+    // but no entities.
+    ```
+    @returns 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  {@link EntityState} of 'Added'.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const cust1 = em1.createEntity(Customer, { companyName: "Acme" }, EntityState.Detached);
+    em1.addEntity(cust1);     // returns cust1, a Customer
+    ```
+  
+    Note that this is the same as using 'attachEntity' with an {@link EntityState} of 'Added'.
+  
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const cust1 = em1.createEntity(Customer, { companyName: "Acme" }, EntityState.Detached);
+    em1.attachEntity(cust1, EntityState.Added);
+    ```
+    @param entity - The entity to add.
+    @returns The added entity.
+    */
+    addEntity(entity) {
+        return this.attachEntity(entity, EntityState.Added);
+    }
+    /**
+    Attaches an entity to this EntityManager with a specified {@link EntityState}.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const cust1 = em1.createEntity(Customer, { companyName: "Acme" }, EntityState.Detached);
+    em1.attachEntity(cust1, EntityState.Added);     // returns cust1, a Customer
+    ```
+    @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.
+    @returns The attached entity.
+    */
+    attachEntity(entity, entityState, mergeStrategy) {
+        assertParam(entity, "entity").isRequired().check();
+        // Before the enum checks, so that an unregistered entity is still reported ahead of a bad
+        // entityState, as it was when this was one method. _attachEntity repeats it for its internal
+        // callers and it early-exits on anything that has an entityType, which is everything here.
+        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);
+        return this._attachEntity(entity, esSymbol, msSymbol);
+    }
+    /**
+     * What `attachEntity` does once its arguments have been checked.
+     *
+     * `createEntity` checks the same `entityState` and `mergeStrategy` a moment earlier and then
+     * called the public method, so every created entity paid for the three `assertParam` chains
+     * twice. Callers inside Breeze already hold a real entity and resolved enum values, so they
+     * come in here instead. Everything the *entity* is checked for - a known type, a matching
+     * metadata store, not already attached elsewhere - still happens below, because those depend
+     * on this manager rather than on the caller getting its arguments right.
+     *
+     * @hidden @internal
+     */
+    _attachEntity(entity, esSymbol, msSymbol) {
+        this.metadataStore._checkEntityType(entity);
+        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.
+    ```ts
+    // 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.
+    @returns 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.
+    ```ts
+    const em1 = new EntityManager("breeze/NorthwindIBModel");
+    await em1.fetchMetadata();
+    const metadataStore = em1.metadataStore;
+    // do something with the metadata
+    ```
+    
+    @param callback - Deprecated. Function called on success.
+    @param errorCallback - Deprecated. Function called on failure.
+    @returns {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__
+    
+    ```ts
+    const em = new EntityManager(serviceName);
+    const query = EntityQuery.from(Order);
+    const data = await em.executeQuery(query);
+    const orders = data.results;   // Order[], because the query was built from the class
+    ```
+  
+    The `callback` and `errorCallback` arguments are deprecated. They still work, but the
+    promise is the supported form and the callbacks will be removed in a future major version.
+  
+    This method is the same as calling the {@link EntityQuery} 'execute' method.
+    ```ts
+    const em = new EntityManager(serviceName);
+    const data = await EntityQuery.from(Order).using(em).execute();
+    const orders = data.results;   // Order[]
+    ```
+    @param query - The {@link EntityQuery} or query string to execute.
+    @param callback - Deprecated. Function called on success.
+    @param errorCallback - Deprecated. Function called on failure.
+    @returns 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 {@link EntityQuery} or query string
+      - entityManager -  The EntityManager.
+      - httpResponse - The {@link HttpResponse} 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
+    ```ts
+    const em = new EntityManager(serviceName);
+    const query = EntityQuery.from(Order);
+    const orders = em.executeQueryLocally(query);   // Order[]
+    ```
+  
+    Note that this can also be accomplished using the 'executeQuery' method with
+    a FetchStrategy of FromLocalCache and making use of the Promise or callback
+    ```ts
+    const em = new EntityManager(serviceName);
+    const query = EntityQuery.from(Order).using(FetchStrategy.FromLocalCache);
+    const data = await em.executeQuery(query);
+    const orders = data.results;   // Order[]
+    ```
+    @param query - The {@link EntityQuery} to execute.
+    @returns  {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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    // This could include added, modified and deleted entities.
+    // A failed save rejects, so the await throws.
+    const saveResult = await em1.saveChanges();
+    const savedEntities = saveResult.entities;
+    const keyMappings = saveResult.keyMappings;
+    ```
+  
+    But we can also control exactly which entities to save and can specify specific SaveOptions
+  
+    ```ts
+    // save only the changed customers
+    const saveOptions = new SaveOptions({ allowConcurrentSaves: true });
+    const saveResult = await em1.saveChanges(em1.getChanges(Customer), saveOptions);
+    ```
+  
+    The `callback` and `errorCallback` arguments are deprecated. They still work, but the
+    promise is the supported form and the callbacks will be removed in a future major version.
+  
+    @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 - {@link SaveOptions} for the save - will default to
+    {@link EntityManager.saveOptions} if null.
+    @param callback - Deprecated. Function called on success.
+    @param errorCallback - Deprecated. Function called on failure.
+    @returns {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);
+        const rejectInvalid = (valError) => {
+            if (errorCallback)
+                errorCallback(valError);
+            return Promise.reject(valError);
+        };
+        // With an async validator, the save waits for it. The entities count as being saved from here,
+        // so a second saveChanges while this one waits is refused, as it would be once this is sent.
+        // Without one, nothing here waits, exactly as before.
+        if (this.validationOptions.validateOnSave && hasAsyncValidators(entitiesToSave)) {
+            markIsBeingSaved(entitiesToSave, true);
+            return this.saveChangesValidateOnClientAsync(entitiesToSave).then(valError => {
+                markIsBeingSaved(entitiesToSave, false);
+                return valError ? rejectInvalid(valError) : this._sendSave(entitiesToSave, saveOptions, callback, errorCallback);
+            }, err => {
+                markIsBeingSaved(entitiesToSave, false);
+                return rejectInvalid(err);
+            });
+        }
+        let valError = this.saveChangesValidateOnClient(entitiesToSave);
+        if (valError)
+            return rejectInvalid(valError);
+        return this._sendSave(entitiesToSave, saveOptions, callback, errorCallback);
+    }
+    /** The part of saveChanges after validation: send the entities, and merge what comes back.
+    @hidden @internal */
+    _sendSave(entitiesToSave, saveOptions, callback, errorCallback) {
+        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, // tells visitAndMerge this is a save instead of a query
+                    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 some 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
+    {@link ValidationOptions}.validateOnSave is true.
+    
+    @param entitiesToSave {Array of Entity} The list of entities to save (to validate).
+    @returns {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;
+    }
+    /**
+    The check {@link EntityManager.saveChangesValidateOnClient} makes, with async validators run too:
+    each entity is validated with {@link EntityAspect.validateEntityAsync}. `saveChanges` uses this
+    in its place when any of the entities it saves has an async validator.
+    @param entitiesToSave - The entities to validate.
+    @returns A promise of the error `saveChanges` would reject with, or null.
+    */
+    async saveChangesValidateOnClientAsync(entitiesToSave) {
+        if (!this.validationOptions.validateOnSave)
+            return null;
+        const valid = await Promise.all(entitiesToSave.map(entity => entity.entityAspect.entityState.isDeleted() || entity.entityAspect.validateEntityAsync()));
+        const failedEntities = entitiesToSave.filter((entity, ix) => !valid[ix]);
+        if (failedEntities.length === 0)
+            return null;
+        const valError = new Error("Client side validation errors encountered - see the entityErrors collection on this object for more detail");
+        valError.entityErrors = createEntityErrors(failedEntities);
+        return valError;
+    }
+    /** @hidden @internal */
+    _findEntityGroup(entityType) {
+        return this._entityGroupMap.get(entityType.name);
+    }
+    /**
+    Attempts to locate an entity within this EntityManager by its [EntityKey].
+    @param entityKey - The {@link EntityKey} of the Entity to be located.
+    @param type - The {@link 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.
+    @returns 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 {@link 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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities,
+    // and that Employee is registered with its MetadataStore.
+    const result = await em1.fetchEntityByKey(Employee, 1);
+    const employee = result.entity;       // Employee | null
+    const entityKey = result.entityKey;
+    const fromCache = result.fromCache;
+    // look in the cache first, and query the server only if it is not there
+    const { entity } = await em1.fetchEntityByKey(Employee, 1, true);
+    ```
+  
+    A type name, an EntityType or an {@link EntityKey} also works; the result's `entity` is then a plain Entity.
+    ```ts
+    const result = await em1.fetchEntityByKey("Employee", 1);
+    ```
+    @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 {@link 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.
+    @returns {Promise}
+      - Properties on the promise success result
+        - entity {Object} The entity found, or null if there is none. (Before 3.0 this was undefined; see UPGRADE.md.)
+        - 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  {@link EntityKey}.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const employeeType = em1.metadataStore.getAsEntityType("Employee");
+    const employeeKey = new EntityKey(employeeType, 1);
+    const employee = em1.findEntityByKey(employeeKey);
+    // employee will either be an entity or null.
+    ```
+    @deprecated    Use getEntityByKey instead
+    @param entityKey - The  {@link EntityKey} of the Entity to be located.
+    @returns 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 {@link 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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const customer = em1.createEntity(Customer, { companyName: "Acme" }, EntityState.Detached);
+    const customerId = em1.generateTempKeyValue(customer);
+    // customer.customerID is now set to a newly generated unique id value.
+    // This property will change again after a successful save of the customer.
+    em1.addEntity(customer);
+    await em1.saveChanges();
+    // customer.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.
+    @returns 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 {@link EntityType}s. A 'changed' Entity has
+    has an {@link EntityState} of either Added, Modified or Deleted.
+  
+    This method can be used to determine if an EntityManager has any changes
+    ```ts
+    // 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 {@link EntityType}.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    if (em1.hasChanges(Customer)) {
+        // do something interesting
+    }
+    ```
+  
+    or to a collection of {@link EntityType}s, named or given as EntityTypes
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    if (em1.hasChanges(["Customer", "Order"])) {
+        // do something interesting
+    }
+    ```
+    @param entityTypes - The {@link EntityType} or EntityTypes for which 'changed' entities will be found.
+    @param entityTypeNames - The {@link EntityType} name or names for which 'changed' entities will be found.
+    @returns 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 {@link EntityType}s. A 'changed' Entity has
+    has an {@link EntityState} of either Added, Modified or Deleted.
+    
+    This method can be used to get all of the changed entities within an EntityManager
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const changedEntities = em1.getChanges();
+    ```
+  
+    or you can specify that you only want the changes on a specific {@link EntityType}
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const changedCustomers = em1.getChanges(Customer);   // Customer[], from the registered class
+    ```
+  
+    or to a collection of {@link EntityType}s, named or given as EntityTypes
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const changedCustomersAndOrders = em1.getChanges(["Customer", "Order"]);   // Entity[]
+    ```
+    @param entityTypes - The {@link EntityType} or EntityTypes for which 'changed' entities will be found.
+    @param entityTypeNames - The {@link EntityType} name or names for which 'changed' entities will be found.
+    @returns 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 {@link EntityAspect.rejectChanges} on every changed entity in this EntityManager.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const entities = em1.rejectChanges();
+    ```
+    @returns 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 {@link EntityType}s with the specified {@link EntityState}s.
+  
+    This method can be used to get all of the entities within an EntityManager
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const entities = em1.getEntities();
+    ```
+  
+    or you can specify that you only want the entities of a specific {@link EntityType}
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const customers = em1.getEntities(Customer);          // Customer[]
+    ```
+  
+    or of a collection of {@link EntityType}s, named or given as EntityTypes
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const customersAndOrders = em1.getEntities(["Customer", "Order"]);   // Entity[]
+    ```
+  
+    You can also ask for entities with a particular {@link EntityState} or EntityStates.
+    ```ts
+    // assume em1 is an EntityManager containing a number of preexisting entities.
+    const addedCustomers = em1.getEntities(Customer, EntityState.Added);   // Customer[]
+    const addedOrModifiedOrders = em1.getEntities(Order, [EntityState.Added, EntityState.Modified]);
+    ```
+   
+    @param entityTypeName - The {@link EntityType} name or names for which entities will be found.
+    If this parameter is omitted, all EntityTypes are searched.
+    @param entityTypes - The {@link EntityType} or EntityTypes for which entities will be found.
+    If this parameter is omitted, all EntityTypes are searched.
+    @param entityStates - The {@link EntityState}s for which entities will be found.
+    If this parameter is omitted, entities of all EntityStates are returned.
+    @returns 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: the manager may have just
+            // become clean, and finding out means _hasChangesCore scanning the whole cache. During a
+            // query or import that would run once per entity, so it is deferred to the end of the load
+            // and done once.
+            //
+            // Only that is deferred. The event below belongs to THIS entity and is published now:
+            // deferring it dropped it, because the deferred closure is built once (note the `||`) and
+            // so captured the first entity's arguments and published for that one alone. Every entity
+            // after the first reported nothing - and only when the manager happened to already have
+            // changes, since otherwise this branch is skipped entirely.
+            if (this._hasChanges) {
+                if (this.isLoading) {
+                    this._hasChangesAction = this._hasChangesAction || (() => this._setHasChanges(null));
+                }
+                else {
+                    this._setHasChanges();
+                }
+            }
+        }
+        this.entityChanged.publish(ecArgs);
+    }
+    /**
+     * `null` means recompute it from the cache, which is the expensive case.
+     * @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
+                                parentToChildNp = np;
+                                let currentChildren = entity.getProperty(parentToChildNp.name);
+                                unattachedChildren.forEach(function (child) {
+                                    // we know if can't already be there.
+                                    observableArray.pushUnchecked(currentChildren, child);
+                                });
+                                // Deliberately NOT removeChildren, unlike the three branches above. The tuple
+                                // stays in the map for the life of the manager, which does hold its children
+                                // against collection - but it is what re-links them if this parent is detached
+                                // and a new one with the same key attached, because a unidirectional child has
+                                // no navigation property of its own to rebuild the collection from. Removing it
+                                // leaves the re-attached parent with an empty collection. Measured: it produces
+                                // no duplicates, since a given parent key is linked once.
+                            }
+                        }
+                    });
+                }
+                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) {
+                            observableArray.pushUnchecked(parent.getProperty(invNp.name), 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.get(fkProp.parentType.name);
+        if (!group)
+            return;
+        group._updateFkVal(fkProp, oldValue, newValue);
+    }
+}
+EntityManager.prototype._$typeName = "EntityManager";
+BreezeEvent.bubbleEvent(EntityManager.prototype);
+// The adapters an EntityManager falls back to when none is registered (see default-adapters.ts).
+// Installed by this module, which every bundle that talks to a server contains, rather than by
+// an import for effect, which a bundler may drop. See "sideEffects" in CHANGES-DEV.md.
+setDefaultAdapters(serverDefaultAdapters);
+/** Whether any of these entities has an async validator, on its type, a property, or a complex type
+it holds. Looked up once per type: validators can be added at any time, so it is not cached. */
+function hasAsyncValidators(entities) {
+    const seen = new Set();
+    const typeHasAsync = (stype) => {
+        if (seen.has(stype))
+            return false;
+        seen.add(stype);
+        if (stype.getAllValidators().some(v => v.isAsync))
+            return true;
+        return stype.getProperties().some((p) => p.getAllValidators().some((v) => v.isAsync) ||
+            (p.isComplexProperty && typeHasAsync(p.dataType)));
+    };
+    return entities.some(e => !e.entityAspect.entityState.isDeleted() && typeHasAsync(e.entityType));
+}
+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,
+                // An error added with addValidationError has no validator. Reading one threw a TypeError,
+                // which replaced the whole validation error - and its entityErrors - with "Cannot read
+                // properties of undefined". Such an error is named by its key.
+                errorName: ve.validator ? ve.validator.name : ve.key
+            }, 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) || undefined
+                } : {};
+            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, 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, 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) {
+    // A registered constructor stands for its type name, which is resolved against this manager's
+    // own store - see the note in createEntity. Normalized before the assertions, so the rest of
+    // this, and every caller, is the 2.x path unchanged.
+    if (typeof entityTypes === "function") {
+        entityTypes = entityTypeForCtor(entityTypes).name;
+    }
+    else if (Array.isArray(entityTypes) && entityTypes.some(t => typeof t === "function")) {
+        entityTypes = entityTypes.map(t => typeof t === "function" ? entityTypeForCtor(t).name : t);
+    }
+    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) {
+    if (args[0] instanceof EntityKey) {
+        return { entityKey: args[0], remainingArgs: arraySlice(args, 1) };
+    }
+    if (args.length >= 2) {
+        let entityType;
+        try {
+            entityType = (typeof args[0] === 'string') ? em.metadataStore._getStructuralType(args[0], false)
+                : (typeof args[0] === 'function') ? em.metadataStore._getStructuralType(entityTypeForCtor(args[0]).name, false) : args[0];
+        }
+        catch (e) { /* not a type: the error below says what is expected */ }
+        if (entityType instanceof EntityType) {
+            // Outside the try: an error about the key values - a name that is not part of the key, a key
+            // property with no value - says more than the one below.
+            return { entityKey: new EntityKey(entityType, args[1]), remainingArgs: arraySlice(args, 2) };
+        }
+    }
+    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 = new Map();
+        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.get(e.entityType.name);
+                if (!group) {
+                    group = {};
+                    group.entityType = e.entityType;
+                    group._entities = [];
+                    entityGroupMap.set(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.get(et.name);
+                    if (group && group._entities.length) {
+                        entityGroupMap.set(et.name, group);
+                    }
+                });
+            }
+        }
+    }
+    else if (entitiesOrEntityTypes && entitiesOrEntityTypes.length === 0) {
+        // empty array = export nothing
+        entityGroupMap = new Map();
+    }
+    else {
+        entityGroupMap = em._entityGroupMap;
+    }
+    let tempKeys = [];
+    // the exported shape is a plain object: this is the serialized wire format,
+    // and JSON.stringify(new Map()) would produce '{}'.
+    let newGroupMap = {};
+    entityGroupMap.forEach((entityGroup, entityTypeName) => {
+        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.get(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.get(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 Array.from(groupMap.values());
+    }
+}
+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) {
+        // A collection that has never been read has nothing to cascade to. Reading it would create
+        // the array for every collection of every entity attached.
+        let related = np.isScalar ? entity.getProperty(np.name) : peekProperty(entity, np.name);
+        if (np.isScalar) {
+            if (!related)
+                return;
+            em.attachEntity(related, entityState, mergeStrategy);
+        }
+        else {
+            if (!related)
+                return;
+            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();
+                mappingContext = undefined;
+                // A materialization error thrown below needs no help here: wrapExecution rethrows it,
+                // which rejects this promise. This cleanup used to return Promise.reject(state.error)
+                // as well; nothing received that second promise, so it was an unhandled rejection.
+            }, 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.get(entityType.name);
+    if (!group) {
+        group = new EntityGroup(em, entityType);
+        em._entityGroupMap.set(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 (observableArray.hasOriginalValues(coOrCos))
+            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) {
+        // named as a remote query's results are named
+        let selectFn = selectClause.toFunction({ entityType: entityType });
+        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=entity-manager.js.map