breeze-client 2.2.0 → 2.2.1-cjs

package/esm2015/src/entity-metadata.js

@@ -0,0 +1,2109 @@
+import { core } from './core';
+import { config } from './config';
+import { BreezeEvent } from './event';
+import { assertParam, assertConfig, Param } from './assert-param';
+import { DataType } from './data-type';
+import { EntityAspect, ComplexAspect } from './entity-aspect';
+import { EntityKey } from './entity-key';
+import { Validator } from './validate';
+import { BreezeEnum } from './enum';
+import { DataService } from './data-service';
+import { NamingConvention } from './naming-convention';
+import { CsdlMetadataParser } from './csdl-metadata-parser'; // TODO isolate this later;
+import { LocalQueryComparisonOptions } from './local-query-comparison-options';
+import { defaultPropertyInterceptor } from './default-property-interceptor';
+/**
+An instance of the MetadataStore contains all of the metadata about a collection of [[EntityType]]'s.
+MetadataStores may be shared across [[EntityManager]]'s.  If an EntityManager is created without an
+explicit MetadataStore, the MetadataStore from the MetadataStore.defaultInstance property will be used.
+@dynamic
+**/
+export class MetadataStore {
+    /**
+    Constructs a new MetadataStore.
+    
+    >     let ms = new MetadataStore();
+  
+    The store can then be associated with an EntityManager
+    >     let entityManager = new EntityManager( {
+    >         serviceName: "breeze/NorthwindIBModel",
+    >         metadataStore: ms
+    >     });
+  
+    or for an existing EntityManager
+    >    // Assume em1 is an existing EntityManager
+    >    em1.setProperties( { metadataStore: ms });
+    
+    @param config - Configuration settings .
+      - namingConvention - (default=NamingConvention.defaultInstance) NamingConvention to be used in mapping property names
+    between client and server. Uses the NamingConvention.defaultInstance if not specified.
+      - localQueryComparisonOptions - (default=LocalQueryComparisonOptions.defaultInstance) The LocalQueryComparisonOptions to be
+    used when performing "local queries" in order to match the semantics of queries against a remote service.
+      - serializerFn - A function that is used to mediate the serialization of instances of this type.
+    **/
+    constructor(config) {
+        config = config || {};
+        assertConfig(config)
+            .whereParam("namingConvention").isOptional().isInstanceOf(NamingConvention).withDefault(NamingConvention.defaultInstance)
+            .whereParam("localQueryComparisonOptions").isOptional().isInstanceOf(LocalQueryComparisonOptions).withDefault(LocalQueryComparisonOptions.defaultInstance)
+            .whereParam("serializerFn").isOptional().isFunction()
+            .applyAll(this);
+        this.dataServices = []; // array of dataServices;
+        this._resourceEntityTypeMap = {}; // key is resource name - value is qualified entityType name
+        this._structuralTypeMap = {}; // key is qualified structuraltype name - value is structuralType. ( structural = entityType or complexType).
+        this._shortNameMap = {}; // key is shortName, value is qualified name - does not need to be serialized.
+        this._ctorRegistry = {}; // key is either short or qual type name - value is ctor;
+        this._incompleteTypeMap = {}; // key is entityTypeName; value is array of nav props
+        this._incompleteComplexTypeMap = {}; // key is complexTypeName; value is array of complexType props
+        this._id = MetadataStore.__id++;
+        this.metadataFetched = new BreezeEvent("metadataFetched", this);
+    }
+    // for debugging use the line below instead.
+    //ctor.normalizeTypeName = function (rawTypeName) { return parseTypeName(rawTypeName).typeName; };
+    /**
+    General purpose property set method
+    
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     em1.metadataStore.setProperties( {
+    >         version: "6.1.3",
+    >         serializerFn: function(prop, value) {
+    >         return (prop.isUnmapped) ? undefined : value;
+    >         }
+    >     )};
+    @param config -  An object containing the selected properties and values to set.
+    **/
+    setProperties(config) {
+        assertConfig(config)
+            .whereParam("name").isString().isOptional()
+            .whereParam("serializerFn").isFunction().isOptional()
+            .applyAll(this);
+    }
+    /**
+    Adds a DataService to this MetadataStore. If a DataService with the same serviceName is already
+    in the MetadataStore an exception will be thrown.
+    @param dataService - The [[DataService]] to add
+    @param shouldOverwrite - (default=false) Permit overwrite of existing DataService rather than throw exception
+    **/
+    addDataService(dataService, shouldOverwrite) {
+        assertParam(dataService, "dataService").isInstanceOf(DataService).check();
+        assertParam(shouldOverwrite, "shouldOverwrite").isBoolean().isOptional().check();
+        let ix = this._getDataServiceIndex(dataService.serviceName);
+        if (ix >= 0) {
+            if (!!shouldOverwrite) {
+                this.dataServices[ix] = dataService;
+            }
+            else {
+                throw new Error("A dataService with this name '" + dataService.serviceName + "' already exists in this MetadataStore");
+            }
+        }
+        else {
+            this.dataServices.push(dataService);
+        }
+    }
+    /** @hidden @internal */
+    _getDataServiceIndex(serviceName) {
+        return core.arrayIndexOf(this.dataServices, function (ds) {
+            return ds.serviceName === serviceName;
+        });
+    }
+    /**
+    Adds an EntityType to this MetadataStore.  No additional properties may be added to the EntityType after its has
+    been added to the MetadataStore.
+    @param structuralType - The EntityType or ComplexType to add
+    **/
+    addEntityType(stype) {
+        let structuralType;
+        if (stype instanceof EntityType || stype instanceof ComplexType) {
+            structuralType = stype;
+        }
+        else {
+            structuralType = stype.isComplexType ? new ComplexType(stype) : new EntityType(stype);
+        }
+        // if (!structuralType.isComplexType) { // same as below but isn't a 'type guard'
+        if (structuralType instanceof EntityType) {
+            if (structuralType.baseTypeName && !structuralType.baseEntityType) {
+                let baseEntityType = this._getStructuralType(structuralType.baseTypeName, true);
+                // safe cast because we know that baseEntityType must be an EntityType if the structuralType is an EntityType
+                structuralType._updateFromBase(baseEntityType);
+            }
+            if (structuralType.keyProperties.length === 0 && !structuralType.isAbstract) {
+                throw new Error("Unable to add " + structuralType.name +
+                    " to this MetadataStore.  An EntityType must have at least one property designated as a key property - See the 'DataProperty.isPartOfKey' property.");
+            }
+        }
+        structuralType.metadataStore = this;
+        // don't register anon types
+        if (!structuralType.isAnonymous) {
+            if (this._structuralTypeMap[structuralType.name]) {
+                throw new Error("Type " + structuralType.name + " already exists in this MetadataStore.");
+            }
+            this._structuralTypeMap[structuralType.name] = structuralType;
+            this._shortNameMap[structuralType.shortName] = structuralType.name;
+        }
+        structuralType.getProperties().forEach(p => {
+            structuralType._updateNames(p);
+            if (!p.isUnmapped) {
+                structuralType._mappedPropertiesCount++;
+            }
+        });
+        structuralType._updateCps();
+        // 'isEntityType' is a type guard
+        if (structuralType instanceof EntityType) {
+            structuralType._updateNps();
+            // give the type it's base's resource name if it doesn't have its own.
+            let defResourceName = structuralType.defaultResourceName || (structuralType.baseEntityType && structuralType.baseEntityType.defaultResourceName);
+            if (defResourceName && !this.getEntityTypeNameForResourceName(defResourceName)) {
+                this.setEntityTypeForResourceName(defResourceName, structuralType.name);
+            }
+            structuralType.defaultResourceName = defResourceName;
+            // check if this structural type's name, short version or qualified version has a registered ctor.
+            structuralType.getEntityCtor();
+        }
+    }
+    /**
+    Exports this MetadataStore to a serialized string appropriate for local storage.   This operation is also called
+    internally when exporting an EntityManager.
+    >      // assume ms is a previously created MetadataStore
+    >      let metadataAsString = ms.exportMetadata();
+    >      window.localStorage.setItem("metadata", metadataAsString);
+    >      // and later, usually in a different session imported
+    >      let metadataFromStorage = window.localStorage.getItem("metadata");
+    >      let newMetadataStore = new MetadataStore();
+    >      newMetadataStore.importMetadata(metadataFromStorage);
+    @return A serialized version of this MetadataStore that may be stored locally and later restored.
+    **/
+    exportMetadata() {
+        let result = JSON.stringify({
+            "metadataVersion": MetadataStore.metadataVersion,
+            "name": this.name,
+            "namingConvention": this.namingConvention.name,
+            "localQueryComparisonOptions": this.localQueryComparisonOptions.name,
+            "dataServices": this.dataServices,
+            "structuralTypes": core.objectMap(this._structuralTypeMap),
+            "resourceEntityTypeMap": this._resourceEntityTypeMap
+        }, null, config.stringifyPad);
+        return result;
+    }
+    /**
+    Imports a previously exported serialized MetadataStore into this MetadataStore.
+      
+    >      // assume ms is a previously created MetadataStore
+    >      let metadataAsString = ms.exportMetadata();
+    >      window.localStorage.setItem("metadata", metadataAsString);
+    >      // and later, usually in a different session
+    >      let metadataFromStorage = window.localStorage.getItem("metadata");
+    >      let newMetadataStore = new MetadataStore();
+    >      newMetadataStore.importMetadata(metadataFromStorage);
+    @param exportedMetadata - A previously exported MetadataStore.
+    @param allowMerge -  Allows custom metadata to be merged into existing metadata types.
+    @return This MetadataStore.
+    @chainable
+    **/
+    importMetadata(exportedMetadata, allowMerge = false) {
+        assertParam(allowMerge, "allowMerge").isOptional().isBoolean().check();
+        this._deferredTypes = {};
+        // insure that we don't mutate incoming exportedMetadata ( if its an object)
+        let metadataAsString = (typeof (exportedMetadata) === "string") ? exportedMetadata : JSON.stringify(exportedMetadata);
+        const metadataJson = JSON.parse(metadataAsString);
+        if (metadataJson.schema) {
+            return CsdlMetadataParser.parse(this, metadataJson.schema, metadataJson.altMetadata);
+        }
+        let json = metadataJson;
+        if (json.metadataVersion && json.metadataVersion !== MetadataStore.metadataVersion) {
+            let msg = core.formatString("Cannot import metadata with a different 'metadataVersion' (%1) than the current 'MetadataStore.metadataVersion' (%2) ", json.metadataVersion, MetadataStore.metadataVersion);
+            throw new Error(msg);
+        }
+        let ncName = json.namingConvention;
+        let lqcoName = json.localQueryComparisonOptions;
+        if (this.isEmpty()) {
+            this.namingConvention = config._fetchObject(NamingConvention, ncName) || this.namingConvention;
+            this.localQueryComparisonOptions = config._fetchObject(LocalQueryComparisonOptions, lqcoName) || this.localQueryComparisonOptions;
+        }
+        else {
+            if (ncName && this.namingConvention.name !== ncName) {
+                throw new Error("Cannot import metadata with a different 'namingConvention' from the current MetadataStore");
+            }
+            if (lqcoName && this.localQueryComparisonOptions.name !== lqcoName) {
+                throw new Error("Cannot import metadata with different 'localQueryComparisonOptions' from the current MetadataStore");
+            }
+        }
+        //noinspection JSHint
+        json.dataServices && json.dataServices.forEach((ds) => {
+            let realDs = DataService.fromJSON(ds);
+            this.addDataService(realDs, true);
+        });
+        json.structuralTypes && json.structuralTypes.forEach((stype) => {
+            structuralTypeFromJson(this, stype, allowMerge);
+        });
+        core.extend(this._resourceEntityTypeMap, json.resourceEntityTypeMap);
+        core.extend(this._incompleteTypeMap, json.incompleteTypeMap);
+        return this;
+    }
+    /**
+    Creates a new MetadataStore from a previously exported serialized MetadataStore
+    >      // assume ms is a previously created MetadataStore
+    >      let metadataAsString = ms.exportMetadata();
+    >      window.localStorage.setItem("metadata", metadataAsString);
+    >      // and later, usually in a different session
+    >      let metadataFromStorage = window.localStorage.getItem("metadata");
+    >      let newMetadataStore = MetadataStore.importMetadata(metadataFromStorage);
+    @param exportedString - A previously exported MetadataStore.
+    @return A new MetadataStore.
+    **/
+    static importMetadata(exportedString) {
+        let ms = new MetadataStore();
+        ms.importMetadata(exportedString);
+        return ms;
+    }
+    /**
+    Returns whether Metadata has been retrieved for a specified service name.
+    >      // Assume em1 is an existing EntityManager.
+    >      if (!em1.metadataStore.hasMetadataFor("breeze/NorthwindIBModel"))) {
+    >          // do something interesting
+    >      }
+    @param serviceName - The service name.
+    @return Whether metadata has already been retrieved for the specified service name.
+    **/
+    hasMetadataFor(serviceName) {
+        return !!this.getDataService(serviceName);
+    }
+    /**
+    Returns the DataService for a specified service name
+    >      // Assume em1 is an existing EntityManager.
+    >      let ds = em1.metadataStore.getDataService("breeze/NorthwindIBModel");
+    >      let adapterName = ds.adapterName; // may be null
+    @param serviceName - The service name.
+    @return The DataService with the specified name.
+    **/
+    getDataService(serviceName) {
+        assertParam(serviceName, "serviceName").isString().check();
+        serviceName = DataService._normalizeServiceName(serviceName);
+        return core.arrayFirst(this.dataServices, function (ds) {
+            return ds.serviceName === serviceName;
+        });
+    }
+    /**
+    Fetches the metadata for a specified 'service'. This method is automatically called
+    internally by an EntityManager before its first query against a new service. __Async__
+  
+    Usually you will not actually process the results of a fetchMetadata call directly, but will instead
+    ask for the metadata from the EntityManager after the fetchMetadata call returns.
+    >      let ms = new MetadataStore();
+    >      // or more commonly
+    >      // let ms = anEntityManager.metadataStore;
+    >      ms.fetchMetadata("breeze/NorthwindIBModel").then(function(rawMetadata) {
+    >            // do something with the metadata
+    >      }).catch(function(exception) {
+    >          // handle exception here
+    >      });
+    @param dataService -  Either a DataService or just the name of the DataService to fetch metadata for.
+    @param callback - Function called on success.
+    @param errorCallback - Function called on failure.
+    @return Promise
+    **/
+    fetchMetadata(dataService, callback, errorCallback) {
+        try {
+            assertParam(dataService, "dataService").isString().or().isInstanceOf(DataService).check();
+            assertParam(callback, "callback").isFunction().isOptional().check();
+            assertParam(errorCallback, "errorCallback").isFunction().isOptional().check();
+            if (typeof dataService === "string") {
+                // use the dataService with a matching name or create a new one.
+                dataService = this.getDataService(dataService) || new DataService({ serviceName: dataService });
+            }
+            dataService = DataService.resolve([dataService]);
+            if (this.hasMetadataFor(dataService.serviceName)) {
+                throw new Error("Metadata for a specific serviceName may only be fetched once per MetadataStore. ServiceName: " + dataService.serviceName);
+            }
+            return dataService.adapterInstance.fetchMetadata(this, dataService).then((rawMetadata) => {
+                this.metadataFetched.publish({ metadataStore: this, dataService: dataService, rawMetadata: rawMetadata });
+                if (callback)
+                    callback(rawMetadata);
+                return Promise.resolve(rawMetadata);
+            }, function (error) {
+                if (errorCallback)
+                    errorCallback(error);
+                return Promise.reject(error);
+            });
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    // TODO: strongly type interceptor below.
+    /**
+    Used to register a constructor for an EntityType that is not known via standard Metadata discovery;
+    i.e. an unmapped type.
+    @param entityCtor - The constructor function for the 'unmapped' type.
+    @param interceptor - An interceptor function
+    **/
+    trackUnmappedType(entityCtor, interceptor) {
+        assertParam(entityCtor, "entityCtor").isFunction().check();
+        assertParam(interceptor, "interceptor").isFunction().isOptional().check();
+        // TODO: think about adding this to the MetadataStore.
+        let entityType = new EntityType(this);
+        entityType._setCtor(entityCtor, interceptor);
+    }
+    /**
+    Provides a mechanism to register a 'custom' constructor to be used when creating new instances
+    of the specified entity type.  If this call is not made, a default constructor is created for
+    the entity as needed.
+    This call may be made before or after the corresponding EntityType has been discovered via
+    Metadata discovery.
+    >      let Customer = function () {
+    >              this.miscData = "asdf";
+    >          };
+    >      Customer.prototype.doFoo() {
+    >              ...
+    >          }
+    >      // assume em1 is a preexisting EntityManager;
+    >      em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
+    >      // any queries or EntityType.create calls from this point on will call the Customer constructor
+    >      // registered above.
+    @param structuralTypeName - The name of the EntityType or ComplexType.
+    @param aCtor - The constructor for this EntityType or ComplexType; may be null if all you want to do is set the next parameter.
+    @param initFn - A function or the name of a function on the entity that is to be executed immediately after the entity has been created
+    and populated with any initial values. Called with 'initFn(entity)'
+    @param noTrackingFn - A function that is executed immediately after a noTracking entity has been created and whose return
+    value will be used in place of the noTracking entity.
+    **/
+    registerEntityTypeCtor(structuralTypeName, aCtor, initFn, noTrackingFn) {
+        assertParam(structuralTypeName, "structuralTypeName").isString().check();
+        assertParam(aCtor, "aCtor").isFunction().isOptional().check();
+        assertParam(initFn, "initFn").isOptional().isFunction().or().isString().check();
+        assertParam(noTrackingFn, "noTrackingFn").isOptional().isFunction().check();
+        let qualifiedTypeName = getQualifiedTypeName(this, structuralTypeName, false);
+        let typeName = qualifiedTypeName || structuralTypeName;
+        if (aCtor) {
+            if (aCtor._$typeName && aCtor._$typeName !== typeName) {
+                // TODO: wrap this - console and especially console.warn does not exist in all browsers.
+                console.warn("Registering a constructor for " + typeName + " that is already used for " + aCtor._$typeName + ".");
+            }
+            aCtor._$typeName = typeName;
+        }
+        this._ctorRegistry[typeName] = { ctor: aCtor, initFn: initFn, noTrackingFn: noTrackingFn };
+        if (qualifiedTypeName) {
+            let stype = this._structuralTypeMap[qualifiedTypeName];
+            stype && stype.getCtor(true); // this will complete the registration if avail now.
+        }
+    }
+    /**
+    Returns whether this MetadataStore contains any metadata yet.
+    >      // assume em1 is a preexisting EntityManager;
+    >      if (em1.metadataStore.isEmpty()) {
+    >          // do something interesting
+    >      }
+    **/
+    isEmpty() {
+        return core.isEmpty(this._structuralTypeMap);
+    }
+    /**
+    Returns an [[EntityType]] or null given its name.
+    >      // assume em1 is a preexisting EntityManager
+    >      let odType = em1.metadataStore.getAsEntityType("OrderDetail");
+  
+    or to throw an error if the type is not found
+    >      let badType = em1.metadataStore.getAsEntityType("Foo", false);
+    >      // badType will not get set and an exception will be thrown.
+    @param structuralTypeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share
+    that same short name an exception will be thrown.
+    @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.
+    @return The EntityType. ComplexType or 'null' if not not found.
+    **/
+    getAsEntityType(typeName, okIfNotFound = false) {
+        const st = this.getStructuralType(typeName, okIfNotFound);
+        if (st instanceof EntityType) {
+            return st;
+        }
+        else if (okIfNotFound) {
+            return null;
+        }
+        else {
+            let msg = core.formatString("Unable to locate an 'EntityType' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.", typeName);
+            throw new Error(msg);
+        }
+    }
+    /**
+    Returns an [[EntityType]] or null given its name.
+    >      // assume em1 is a preexisting EntityManager
+    >      let locType = em1.metadataStore.getAsComplexType("Location");
+  
+    or to throw an error if the type is not found
+    >      let badType = em1.metadataStore.getAsComplexType("Foo", false);
+    >      // badType will not get set and an exception will be thrown.
+    @param structuralTypeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share
+    that same short name an exception will be thrown.
+    @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.
+    @return The EntityType. ComplexType or 'null' if not not found.
+    **/
+    getAsComplexType(typeName, okIfNotFound = false) {
+        const st = this.getStructuralType(typeName, okIfNotFound);
+        if (st instanceof ComplexType) {
+            return st;
+        }
+        else if (okIfNotFound) {
+            return null;
+        }
+        else {
+            let msg = core.formatString("Unable to locate an 'ComplexType' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.", typeName);
+            throw new Error(msg);
+        }
+    }
+    /**
+    Returns an [[EntityType]] or a [[ComplexType]] given its name.
+    @deprecated Replaced by getStructuralType but ... it is probably more usefull to call either getAsEntityType or getAsComplexType instead
+    @param typeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share
+    that same short name an exception will be thrown.
+    @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.
+    @return The EntityType. ComplexType or 'null' if not not found.
+    **/
+    getEntityType(typeName, okIfNotFound = false) {
+        return this.getStructuralType(typeName, okIfNotFound);
+    }
+    /**
+    Returns an [[EntityType]] or a [[ComplexType]] given its name.
+    >      // assume em1 is a preexisting EntityManager
+    >      let odType = em1.metadataStore.getStructuralType("OrderDetail");
+  
+    or to throw an error if the type is not found
+    >      let badType = em1.metadataStore.getStructuralType("Foo", false);
+    >      // badType will not get set and an exception will be thrown.
+    @deprecated Preferably use either getAsEntityType or getAsComplexType.  Get
+    @param typeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share
+    that same short name an exception will be thrown.
+    @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.
+    @return The EntityType. ComplexType or 'null' if not not found.
+    **/
+    getStructuralType(typeName, okIfNotFound = false) {
+        assertParam(typeName, "typeName").isString().check();
+        assertParam(okIfNotFound, "okIfNotFound").isBoolean().isOptional().check(false);
+        return this._getStructuralType(typeName, okIfNotFound);
+    }
+    /** @hidden @internal */
+    _getStructuralType(typeName, okIfNotFound = false) {
+        let qualTypeName = getQualifiedTypeName(this, typeName, false);
+        let type = this._structuralTypeMap[qualTypeName];
+        if (!type) {
+            if (okIfNotFound)
+                return null;
+            let msg = core.formatString("Unable to locate a 'Type' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.", typeName);
+            throw new Error(msg);
+        }
+        return type;
+    }
+    /**
+    Returns an array containing all of the [[EntityType]]s or [[ComplexType]]s in this MetadataStore.
+    >      // assume em1 is a preexisting EntityManager
+    >      let allTypes = em1.metadataStore.getEntityTypes();
+    **/
+    getEntityTypes() {
+        return getTypesFromMap(this._structuralTypeMap);
+    }
+    getIncompleteNavigationProperties() {
+        return core.objectMap(this._incompleteTypeMap, function (key, value) {
+            return value;
+        });
+    }
+    /**
+    Returns a fully qualified entityTypeName for a specified resource name.  The reverse of this operation
+    can be obtained via the  [[EntityType.defaultResourceName]] property
+    **/
+    getEntityTypeNameForResourceName(resourceName) {
+        assertParam(resourceName, "resourceName").isString().check();
+        return this._resourceEntityTypeMap[resourceName];
+    }
+    /**
+    Associates a resourceName with an entityType.
+  
+    This method is only needed in those cases where multiple resources return the same
+    entityType.  In this case Metadata discovery will only determine a single resource name for
+    each entityType.
+    @param resourceName - The resource name
+    @param entityTypeOrName - If passing a string either the fully qualified name or a short name may be used. If a short name is specified and multiple types share
+    that same short name an exception will be thrown. If the entityType has not yet been discovered then a fully qualified name must be used.
+    **/
+    setEntityTypeForResourceName(resourceName, entityTypeOrName) {
+        assertParam(resourceName, "resourceName").isString().check();
+        assertParam(entityTypeOrName, "entityTypeOrName").isInstanceOf(EntityType).or().isString().check();
+        let entityTypeName;
+        if (entityTypeOrName instanceof EntityType) {
+            entityTypeName = entityTypeOrName.name;
+        }
+        else {
+            entityTypeName = getQualifiedTypeName(this, entityTypeOrName, true);
+        }
+        this._resourceEntityTypeMap[resourceName] = entityTypeName;
+        let entityType = this._getStructuralType(entityTypeName, true);
+        if (entityType && entityType instanceof EntityType && !entityType.defaultResourceName) {
+            entityType.defaultResourceName = resourceName;
+        }
+    }
+    /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */
+    static parseTypeName(entityTypeName) {
+        // TODO: removed 
+        // if (!entityTypeName) {
+        //   return null;
+        // }
+        let typeParts = entityTypeName.split(":#");
+        if (typeParts.length > 1) {
+            return MetadataStore.makeTypeHash(typeParts[0], typeParts[1]);
+        }
+        if (core.stringStartsWith(entityTypeName, MetadataStore.ANONTYPE_PREFIX)) {
+            let typeHash = MetadataStore.makeTypeHash(entityTypeName);
+            typeHash.isAnonymous = true;
+            return typeHash;
+        }
+        let entityTypeNameNoAssembly = entityTypeName.split(",")[0];
+        typeParts = entityTypeNameNoAssembly.split(".");
+        if (typeParts.length > 1) {
+            let shortName = typeParts[typeParts.length - 1];
+            let namespaceParts = typeParts.slice(0, typeParts.length - 1);
+            let ns = namespaceParts.join(".");
+            return MetadataStore.makeTypeHash(shortName, ns);
+        }
+        else {
+            return MetadataStore.makeTypeHash(entityTypeName);
+        }
+    }
+    /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */
+    static makeTypeHash(shortName, ns) {
+        return {
+            shortTypeName: shortName,
+            namespace: ns,
+            typeName: qualifyTypeName(shortName, ns)
+        };
+    }
+    // protected methods
+    /** @hidden @internal */
+    _checkEntityType(entity) {
+        if (entity.entityType)
+            return;
+        let typeName = entity.prototype._$typeName;
+        if (!typeName) {
+            throw new Error("This entity has not been registered. See the MetadataStore.registerEntityTypeCtor method");
+        }
+        // we know that it is an EntityType ( as opposed to a ComplexType)
+        let entityType = this._getStructuralType(typeName);
+        if (entityType) {
+            entity.entityType = entityType;
+        }
+    }
+}
+/** @hidden @internal */
+MetadataStore.__id = 0;
+/** @hidden @internal */
+MetadataStore.ANONTYPE_PREFIX = "_IB_";
+/** The version of any MetadataStores created by this class */
+MetadataStore.metadataVersion = '1.0.5';
+// needs to be made avail to dataService.xxx files
+MetadataStore.normalizeTypeName = core.memoize(function (rawTypeName) {
+    return rawTypeName && MetadataStore.parseTypeName(rawTypeName).typeName;
+});
+MetadataStore.prototype._$typeName = "MetadataStore";
+BreezeEvent.bubbleEvent(MetadataStore.prototype);
+function getTypesFromMap(typeMap) {
+    let types = [];
+    for (let key in typeMap) {
+        let value = typeMap[key];
+        // skip 'shortName' entries
+        if (key === value.name) {
+            types.push(typeMap[key]);
+        }
+    }
+    return types;
+}
+function structuralTypeFromJson(metadataStore, json, allowMerge) {
+    let typeName = qualifyTypeName(json.shortName, json.namespace);
+    let stype = metadataStore._getStructuralType(typeName, true);
+    if (stype) {
+        if (allowMerge) {
+            return mergeStructuralType(stype, json);
+        }
+        else {
+            // allow it but don't replace anything.
+            return stype;
+        }
+    }
+    let config = {
+        shortName: json.shortName,
+        namespace: json.namespace,
+        isAbstract: json.isAbstract,
+        autoGeneratedKeyType: AutoGeneratedKeyType.fromName(json.autoGeneratedKeyType),
+        defaultResourceName: json.defaultResourceName,
+        custom: json.custom
+    };
+    stype = json.isComplexType ? new ComplexType(config) : new EntityType(config);
+    // baseType may not have been imported yet so we need to defer handling this type until later.
+    if (json.baseTypeName && stype instanceof EntityType) {
+        stype.baseTypeName = json.baseTypeName;
+        let baseEntityType = metadataStore._getStructuralType(json.baseTypeName, true);
+        if (baseEntityType) {
+            completeStructuralTypeFromJson(metadataStore, json, stype);
+        }
+        else {
+            core.getArray(metadataStore._deferredTypes, json.baseTypeName).push({ json: json, stype: stype });
+        }
+    }
+    else {
+        completeStructuralTypeFromJson(metadataStore, json, stype);
+    }
+    // stype may or may not have been added to the metadataStore at this point.
+    return stype;
+}
+function mergeStructuralType(stype, json) {
+    if (json.custom) {
+        stype.custom = json.custom;
+    }
+    mergeProps(stype, json.dataProperties);
+    mergeProps(stype, json.navigationProperties);
+    return stype;
+}
+function mergeProps(stype, jsonProps) {
+    if (!jsonProps)
+        return;
+    jsonProps.forEach((jsonProp) => {
+        let propName = jsonProp.name;
+        if (!propName) {
+            if (jsonProp.nameOnServer) {
+                propName = stype.metadataStore.namingConvention.serverPropertyNameToClient(jsonProp.nameOnServer, {});
+            }
+            else {
+                // backslash-quote works around compiler bug
+                const msg = "Unable to complete \'importMetadata\' - cannot locate a \'name\' or \'nameOnServer\' for one of the imported property nodes";
+                throw new Error(msg);
+            }
+        }
+        if (jsonProp.custom) {
+            let prop = stype.getProperty(propName, true);
+            prop.custom = jsonProp.custom;
+        }
+    });
+}
+function completeStructuralTypeFromJson(metadataStore, json, stype) {
+    // validators from baseType work because validation walks thru base types
+    // so no need to copy down.
+    if (json.validators) {
+        stype.validators = json.validators.map(Validator.fromJSON);
+    }
+    json.dataProperties.forEach(function (dp) {
+        stype._addPropertyCore(DataProperty.fromJSON(dp));
+    });
+    let isEntityType = !json.isComplexType;
+    if (isEntityType) {
+        //noinspection JSHint
+        json.navigationProperties && json.navigationProperties.forEach(function (np) {
+            stype._addPropertyCore(NavigationProperty.fromJSON(np));
+        });
+    }
+    metadataStore.addEntityType(stype);
+    let deferredTypes = metadataStore._deferredTypes;
+    let deferrals = deferredTypes[stype.name];
+    if (deferrals) {
+        deferrals.forEach(function (d) {
+            completeStructuralTypeFromJson(metadataStore, d.json, d.stype);
+        });
+        delete deferredTypes[stype.name];
+    }
+}
+function getQualifiedTypeName(metadataStore, structTypeName, throwIfNotFound) {
+    if (isQualifiedTypeName(structTypeName))
+        return structTypeName;
+    let result = metadataStore._shortNameMap[structTypeName];
+    if (!result && throwIfNotFound) {
+        throw new Error("Unable to locate 'entityTypeName' of: " + structTypeName);
+    }
+    return result;
+}
+/** Container for all of the metadata about a specific type of Entity.
+**/
+export class EntityType {
+    /** EntityType constructor
+    >      let entityType = new EntityType( {
+    >          shortName: "person",
+    >          namespace: "myAppNamespace"
+    >      });
+    @param config - Configuration settings or a MetadataStore.  If this parameter is just a MetadataStore
+    then what will be created is an 'anonymous' type that will never be communicated to or from the server. It is purely for
+    client side use and will be given an automatically generated name. Normally, however, you will use a configuration object.
+    **/
+    constructor(config) {
+        /** Always false for an EntityType. **/
+        this.isComplexType = false;
+        /**
+        @deprecated Use [[getCtor]] instead.
+        */
+        this.getEntityCtor = this.getCtor;
+        if (arguments.length > 1) {
+            throw new Error("The EntityType ctor has a single argument that is either a 'MetadataStore' or a configuration object.");
+        }
+        // let etConfig =  <EntityTypeConfig> <any> undefined;
+        let etConfig = undefined;
+        if (config._$typeName === "MetadataStore") {
+            this.metadataStore = config;
+            this.shortName = "Anon_" + (++EntityType.__nextAnonIx);
+            this.namespace = "";
+            this.isAnonymous = true;
+            // etConfig = undefined;
+        }
+        else {
+            etConfig = config;
+            assertConfig(config)
+                .whereParam("shortName").isNonEmptyString()
+                .whereParam("namespace").isString().isOptional().withDefault("")
+                .whereParam("baseTypeName").isString().isOptional()
+                .whereParam("isAbstract").isBoolean().isOptional().withDefault(false)
+                .whereParam("autoGeneratedKeyType").isEnumOf(AutoGeneratedKeyType).isOptional().withDefault(AutoGeneratedKeyType.None)
+                .whereParam("defaultResourceName").isNonEmptyString().isOptional().withDefault(null)
+                .whereParam("dataProperties").isOptional()
+                .whereParam("navigationProperties").isOptional()
+                .whereParam("serializerFn").isOptional().isFunction()
+                .whereParam("custom").isOptional()
+                .applyAll(this);
+        }
+        this.name = qualifyTypeName(this.shortName, this.namespace);
+        // the defaultResourceName may also be set up either via metadata lookup or first query or via the 'setProperties' method
+        this.dataProperties = [];
+        this.navigationProperties = [];
+        this.complexProperties = [];
+        this.keyProperties = [];
+        this.foreignKeyProperties = [];
+        this.inverseForeignKeyProperties = [];
+        this.concurrencyProperties = [];
+        this.unmappedProperties = []; // will be updated later.
+        this.validators = [];
+        this.warnings = [];
+        this._mappedPropertiesCount = 0;
+        this.subtypes = [];
+        // now process any data/nav props
+        if (etConfig && etConfig.dataProperties) {
+            addProperties(this, etConfig.dataProperties, DataProperty);
+        }
+        if (etConfig && etConfig.navigationProperties) {
+            addProperties(this, etConfig.navigationProperties, NavigationProperty);
+        }
+    }
+    /**
+    General purpose property set method
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      custType.setProperties( {
+    >          autoGeneratedKeyType: AutoGeneratedKeyType.Identity;
+    >          defaultResourceName: "CustomersAndIncludedOrders"
+    >      )};
+    @param config - a configuration object
+    **/
+    setProperties(config) {
+        assertConfig(config)
+            .whereParam("autoGeneratedKeyType").isEnumOf(AutoGeneratedKeyType).isOptional()
+            .whereParam("defaultResourceName").isString().isOptional()
+            .whereParam("serializerFn").isFunction().isOptional()
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+        if (config.defaultResourceName) {
+            this.defaultResourceName = config.defaultResourceName;
+        }
+    }
+    /**
+    Returns whether this type is a subtype of a specified type.
+    **/
+    isSubtypeOf(entityType) {
+        assertParam(entityType, "entityType").isInstanceOf(EntityType).check();
+        let baseType = this;
+        do {
+            if (baseType === entityType)
+                return true;
+            baseType = baseType.baseEntityType;
+        } while (baseType);
+        return false;
+    }
+    /**
+    Returns an array containing this type and any/all subtypes of this type down thru the hierarchy.
+    **/
+    getSelfAndSubtypes() {
+        let result = [this];
+        this.subtypes.forEach(function (st) {
+            let subtypes = st.getSelfAndSubtypes();
+            result.push.apply(result, subtypes);
+        });
+        return result;
+    }
+    getAllValidators() {
+        let result = this.validators.slice(0);
+        let bt = this.baseEntityType;
+        while (bt) {
+            result.push.apply(result, bt.validators);
+            bt = bt.baseEntityType;
+        }
+        return result;
+    }
+    /**
+    Adds a  [[DataProperty]] or a [[NavigationProperty]] to this EntityType.
+    >      // assume myEntityType is a newly constructed EntityType.
+    >      myEntityType.addProperty(dataProperty1);
+    >      myEntityType.addProperty(dataProperty2);
+    >      myEntityType.addProperty(navigationProperty1);
+    **/
+    addProperty(property) {
+        assertParam(property, "property").isInstanceOf(DataProperty).or().isInstanceOf(NavigationProperty).check();
+        // true is 2nd arg to force resolve of any navigation properties.
+        let newprop = this._addPropertyCore(property, true);
+        if (this.subtypes && this.subtypes.length) {
+            let stype = this;
+            stype.getSelfAndSubtypes().forEach(function (st) {
+                if (st !== stype) {
+                    if (property.isNavigationProperty) {
+                        st._addPropertyCore(new NavigationProperty(property), true);
+                    }
+                    else {
+                        st._addPropertyCore(new DataProperty(property), true);
+                    }
+                }
+            });
+        }
+        return newprop;
+    }
+    /** @hidden @internal */
+    _updateFromBase(baseEntityType) {
+        this.baseEntityType = baseEntityType;
+        if (this.autoGeneratedKeyType === AutoGeneratedKeyType.None) {
+            this.autoGeneratedKeyType = baseEntityType.autoGeneratedKeyType;
+        }
+        baseEntityType.dataProperties.forEach((dp) => {
+            let newDp = new DataProperty(dp);
+            // don't need to copy validators becaue we will walk the hierarchy to find them
+            newDp.validators = [];
+            newDp.baseProperty = dp;
+            this._addPropertyCore(newDp);
+        }, this);
+        baseEntityType.navigationProperties.forEach((np) => {
+            let newNp = new NavigationProperty(np);
+            // don't need to copy validators becaue we will walk the hierarchy to find them
+            newNp.validators = [];
+            newNp.baseProperty = np;
+            this._addPropertyCore(newNp);
+        }, this);
+        baseEntityType.subtypes.push(this);
+    }
+    /** @hidden @internal */
+    _addPropertyCore(property, shouldResolve = false) {
+        if (this.isFrozen) {
+            throw new Error("The '" + this.name + "' EntityType/ComplexType has been frozen. You can only add properties to an EntityType/ComplexType before any instances of that type have been created and attached to an entityManager.");
+        }
+        let parentType = property.parentType;
+        if (parentType) {
+            if (parentType !== this) {
+                throw new Error("This property: " + property.name + " has already been added to " + property.parentType.name);
+            }
+            else {
+                // adding the same property more than once to the same entityType is just ignored.
+                return;
+            }
+        }
+        property.parentType = this;
+        let ms = this.metadataStore;
+        // if (property.isDataProperty) { // modified because doesn't act as a type guard 
+        if (property instanceof DataProperty) {
+            this._addDataProperty(property);
+        }
+        else {
+            this._addNavigationProperty(property);
+            // metadataStore can be undefined if this entityType has not yet been added to a MetadataStore.
+            if (shouldResolve && ms) {
+                tryResolveNp(property, ms);
+            }
+        }
+        // unmapped properties can be added AFTER entityType has already resolved all property names.
+        if (ms && !(property.name && property.nameOnServer)) {
+            updateClientServerNames(ms.namingConvention, property, "name");
+        }
+        // props can be added after entity prototype has already been wrapped.
+        if (ms && this._extra) {
+            if (this._extra.alreadyWrappedProps) {
+                let proto = this._ctor.prototype;
+                config.interfaceRegistry.modelLibrary.getDefaultInstance().initializeEntityPrototype(proto);
+            }
+        }
+    }
+    /**
+    Create a new entity of this type.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getAsEntityType("Customer");
+    >      let cust1 = custType.createEntity();
+    >      em1.addEntity(cust1);
+    @param initialValues- Configuration object of the properties to set immediately after creation.
+    @return The new entity.
+    **/
+    createEntity(initialValues) {
+        // ignore the _$eref once the entity is attached to an entityManager.
+        if (initialValues && initialValues._$eref && !initialValues._$eref.entityAspect.entityManager)
+            return initialValues._$eref;
+        let instance = this._createInstanceCore();
+        if (initialValues) {
+            // only assign an _eref if the object is fully "keyed"
+            if (this.keyProperties.every(function (kp) {
+                return initialValues[kp.name] != null;
+            })) {
+                initialValues._$eref = instance;
+            }
+            this._updateTargetFromRaw(instance, initialValues, getRawValueFromConfig);
+            this.navigationProperties.forEach(function (np) {
+                let relatedEntity;
+                let val = initialValues[np.name];
+                if (val != undefined) {
+                    let navEntityType = np.entityType;
+                    if (np.isScalar) {
+                        relatedEntity = val.entityAspect ? val : navEntityType.createEntity(val);
+                        instance.setProperty(np.name, relatedEntity);
+                    }
+                    else {
+                        let relatedEntities = instance.getProperty(np.name);
+                        val.forEach((v) => {
+                            relatedEntity = v.entityAspect ? v : navEntityType.createEntity(v);
+                            relatedEntities.push(relatedEntity);
+                        });
+                    }
+                }
+            });
+        }
+        this._initializeInstance(instance);
+        return instance;
+    }
+    /** @hidden @internal */
+    _createInstanceCore() {
+        let aCtor = this.getCtor();
+        let instance = new aCtor();
+        new EntityAspect(instance);
+        return instance;
+    }
+    /** @hidden @internal */
+    _initializeInstance(instance) {
+        if (this.baseEntityType) {
+            this.baseEntityType._initializeInstance(instance);
+        }
+        let initFn = this.initFn;
+        if (initFn) {
+            let fn = (typeof initFn === "string") ? instance[initFn] : initFn;
+            fn(instance);
+        }
+        this.complexProperties && this.complexProperties.forEach(function (cp) {
+            let complexType = cp.dataType;
+            let ctInstance = instance.getProperty(cp.name);
+            if (Array.isArray(ctInstance)) {
+                ctInstance.forEach((ctInst) => {
+                    complexType._initializeInstance(ctInst);
+                });
+            }
+            else {
+                complexType._initializeInstance(ctInstance);
+            }
+        });
+        // not needed for complexObjects
+        if (instance.entityAspect) {
+            instance.entityAspect._initialized = true;
+        }
+    }
+    /**
+    Returns the constructor for this EntityType.
+    @param forceRefresh - Whether to ignore any cached version of this constructor. (default == false)
+    @return The constructor for this EntityType.
+    **/
+    getCtor(forceRefresh = false) {
+        if (this._ctor && !forceRefresh)
+            return this._ctor;
+        let ctorRegistry = this.metadataStore._ctorRegistry;
+        let r = ctorRegistry[this.name] || ctorRegistry[this.shortName] || {};
+        let aCtor = r.ctor || this._ctor;
+        let ctorType = aCtor && aCtor.prototype && (aCtor.prototype.entityType || aCtor.prototype.complexType);
+        if (ctorType && ctorType.metadataStore !== this.metadataStore) {
+            // We can't risk a mismatch between the ctor and the type info in a specific metadatastore
+            // because modelLibraries rely on type info to intercept ctor properties
+            throw new Error("Cannot register the same constructor for " + this.name + " in different metadata stores.  Please define a separate constructor for each metadata store.");
+        }
+        if (r.ctor && forceRefresh) {
+            this._extra = undefined;
+        }
+        if (!aCtor) {
+            let createCtor = config.interfaceRegistry.modelLibrary.getDefaultInstance().createCtor;
+            aCtor = createCtor ? createCtor(this) : createEmptyCtor(this);
+        }
+        this.initFn = r.initFn;
+        this.noTrackingFn = r.noTrackingFn;
+        aCtor.prototype._$typeName = this.name;
+        this._setCtor(aCtor);
+        return aCtor;
+    }
+    /** @hidden @internal */
+    // May make public later.
+    _setCtor(aCtor, interceptor) {
+        let instanceProto = aCtor.prototype;
+        // place for extra breeze related data
+        this._extra = this._extra || {};
+        let instance = new aCtor();
+        calcUnmappedProperties(this, instance);
+        if (this._$typeName === "EntityType") {
+            // insure that all of the properties are on the 'template' instance before watching the class.
+            instanceProto.entityType = this;
+        }
+        else {
+            instanceProto.complexType = this;
+        }
+        // defaultPropertyInterceptor is a 'global' (but internal to breeze) function;
+        instanceProto._$interceptor = interceptor || defaultPropertyInterceptor;
+        config.interfaceRegistry.modelLibrary.getDefaultInstance().initializeEntityPrototype(instanceProto);
+        this._ctor = aCtor;
+    }
+    /**
+    Adds either an entity or property level validator to this EntityType.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let countryProp = custType.getProperty("Country");
+    >      let valFn = function (v) {
+    >              if (v == null) return true;
+    >              return (core.stringStartsWith(v, "US"));
+    >          };
+    >      let countryValidator = new Validator("countryIsUS", valFn,
+    >      { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
+    >      custType.addValidator(countryValidator, countryProp);
+  
+    This is the same as adding an entity level validator via the 'validators' property of DataProperty or NavigationProperty
+    >      countryProp.validators.push(countryValidator);
+  
+    Entity level validators can also be added by omitting the 'property' parameter.
+    >      custType.addValidator(someEntityLevelValidator);
+  
+    or
+    >      custType.validators.push(someEntityLevelValidator);
+    @param validator - Validator to add.
+    @param property - Property to add this validator to.  If omitted, the validator is assumed to be an
+    entity level validator and is added to the EntityType's 'validators'.
+    **/
+    addValidator(validator, property) {
+        assertParam(validator, "validator").isInstanceOf(Validator).check();
+        assertParam(property, "property").isOptional().isString().or().isEntityProperty().check();
+        if (property != null) {
+            let prop = (typeof property === 'string') ? this.getProperty(property, true) : property;
+            prop.validators.push(validator);
+        }
+        else {
+            this.validators.push(validator);
+        }
+    }
+    /**
+    Returns all of the properties ( dataProperties and navigationProperties) for this EntityType.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let arrayOfProps = custType.getProperties();
+    @return An array of Data and Navigation properties.
+    **/
+    getProperties() {
+        return this.dataProperties.concat(this.navigationProperties);
+    }
+    /**
+    Returns all of the property names ( for both dataProperties and navigationProperties) for this EntityType.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let arrayOfPropNames = custType.getPropertyNames();
+    **/
+    getPropertyNames() {
+        return this.getProperties().map(core.pluck('name'));
+    }
+    /**
+    Returns a data property with the specified name or null.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let customerNameDataProp = custType.getDataProperty("CustomerName");
+    @return A DataProperty or null if not found.
+    **/
+    getDataProperty(propertyName) {
+        return core.arrayFirst(this.dataProperties, core.propEq('name', propertyName));
+    }
+    /**
+    Returns a navigation property with the specified name or null.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let customerOrdersNavProp = custType.getDataProperty("Orders");
+    @return A NavigationProperty or null if not found.
+    **/
+    getNavigationProperty(propertyName) {
+        return core.arrayFirst(this.navigationProperties, core.propEq('name', propertyName));
+    }
+    /**
+    Returns either a DataProperty or a NavigationProperty with the specified name or null.
+    
+    This method also accepts a '.' delimited property path and will return the 'property' at the
+    end of the path.
+    >      let custType = em1.metadataStore.getEntityType("Customer");
+    >      let companyNameProp = custType.getProperty("CompanyName");
+  
+    This method can also walk a property path to return a property
+    >      let orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
+    >      let companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
+    >      // companyNameProp === companyNameProp2
+    @param [throwIfNotFound=false] {Boolean} Whether to throw an exception if not found.
+    @return A DataProperty or NavigationProperty or null if not found.
+    **/
+    getProperty(propertyPath, throwIfNotFound = false) {
+        let props = this.getPropertiesOnPath(propertyPath, false, throwIfNotFound);
+        return (props && props.length > 0) ? props[props.length - 1] : null;
+    }
+    /** @hidden @internal */
+    // TODO: have this return empty array instead of null and fix consumers.
+    // TODO: think about renaming with '_' prefix.
+    getPropertiesOnPath(propertyPath, useServerName, throwIfNotFound = false) {
+        let propertyNames = (Array.isArray(propertyPath)) ? propertyPath : propertyPath.trim().split('.');
+        let ok = true;
+        let key = useServerName === true ? "nameOnServer" : useServerName === false ? "name" : null;
+        let parentType = this;
+        const getProps = (propName) => {
+            const fn = key === null ? core.propsEq("name", "nameOnServer", propName) : core.propEq(key, propName);
+            let prop = core.arrayFirst(parentType.getProperties(), fn);
+            if (prop) {
+                parentType = (prop instanceof NavigationProperty) ? prop.entityType : prop.dataType;
+                // parentType = prop.isNavigationProperty ? prop.entityType : prop.dataType;
+            }
+            else if (throwIfNotFound) {
+                throw new Error("unable to locate property: " + propName + " on entityType: " + parentType.name);
+            }
+            else {
+                ok = false;
+            }
+            return prop;
+        };
+        let props = propertyNames.map(getProps);
+        return ok ? props : null;
+    }
+    /** For use in pluggable adapters. */
+    // TODO: document use
+    clientPropertyPathToServer(propertyPath, delimiter = '.') {
+        let propNames;
+        if (this.isAnonymous) {
+            let fn = this.metadataStore.namingConvention.clientPropertyNameToServer;
+            propNames = propertyPath.split(".").map(function (propName) {
+                return fn(propName);
+            });
+        }
+        else {
+            let props = this.getPropertiesOnPath(propertyPath, false, true);
+            propNames = props.map((prop) => prop.nameOnServer);
+        }
+        return propNames.join(delimiter);
+    }
+    /** For use in pluggable adapters. */
+    // TODO: document use
+    getEntityKeyFromRawEntity(rawEntity, rawValueFn) {
+        let keyValues = this.keyProperties.map((dp) => {
+            let val = rawValueFn(rawEntity, dp);
+            return DataType.parseRawValue(val, dp.dataType);
+        });
+        return new EntityKey(this, keyValues);
+    }
+    /** @hidden @internal */
+    _updateTargetFromRaw(target, raw, rawValueFn) {
+        // called recursively for complex properties
+        this.dataProperties.forEach((dp) => {
+            if (!dp.isSettable)
+                return;
+            let rawVal = rawValueFn(raw, dp);
+            if (rawVal === undefined)
+                return;
+            let dataType = dp.dataType; // this will be a complexType when dp is a complexProperty
+            let oldVal;
+            if (dp.isComplexProperty) {
+                let complexType = dp.dataType;
+                if (rawVal === null)
+                    return; // rawVal may be null in nosql dbs where it was never defined for the given row.
+                oldVal = target.getProperty(dp.name);
+                if (dp.isScalar) {
+                    complexType._updateTargetFromRaw(oldVal, rawVal, rawValueFn);
+                }
+                else {
+                    if (Array.isArray(rawVal)) {
+                        let newVal = rawVal.map(function (rawCo) {
+                            let newCo = complexType._createInstanceCore(target, dp);
+                            complexType._updateTargetFromRaw(newCo, rawCo, rawValueFn);
+                            complexType._initializeInstance(newCo);
+                            return newCo;
+                        });
+                        if (!core.arrayEquals(oldVal, newVal, coEquals)) {
+                            // clear the old array and push new objects into it.
+                            oldVal.length = 0;
+                            newVal.forEach(function (nv) {
+                                oldVal.push(nv);
+                            });
+                        }
+                    }
+                    else {
+                        oldVal.length = 0;
+                    }
+                }
+            }
+            else {
+                if (dp.isScalar) {
+                    let newVal = DataType.parseRawValue(rawVal, dataType);
+                    target.setProperty(dp.name, newVal);
+                }
+                else {
+                    oldVal = target.getProperty(dp.name);
+                    if (Array.isArray(rawVal)) {
+                        // need to compare values
+                        let newVal = rawVal.map((rv) => {
+                            return DataType.parseRawValue(rv, dataType);
+                        });
+                        if (!core.arrayEquals(oldVal, newVal)) {
+                            // clear the old array and push new objects into it.
+                            oldVal.length = 0;
+                            newVal.forEach(function (nv) {
+                                oldVal.push(nv);
+                            });
+                        }
+                    }
+                    else {
+                        oldVal.length = 0;
+                    }
+                }
+            }
+        });
+        // if merging from an import then raw will have an entityAspect or a complexAspect
+        let rawAspect = raw.entityAspect || raw.complexAspect;
+        if (rawAspect) {
+            let targetAspect = EntityAspect.isEntity(target) ? target.entityAspect : target.complexAspect;
+            if (rawAspect.originalValuesMap) {
+                targetAspect.originalValues = rawAspect.originalValuesMap;
+            }
+            if (rawAspect.extraMetadata) {
+                targetAspect.extraMetadata = rawAspect.extraMetadata;
+            }
+        }
+    }
+    /**
+    Returns a string representation of this EntityType.
+    **/
+    toString() {
+        return this.name;
+    }
+    toJSON() {
+        return core.toJson(this, {
+            shortName: null,
+            namespace: null,
+            baseTypeName: null,
+            isAbstract: false,
+            autoGeneratedKeyType: null,
+            defaultResourceName: null,
+            dataProperties: localPropsOnly,
+            navigationProperties: localPropsOnly,
+            validators: null,
+            custom: null
+        });
+    }
+    /** @hidden @internal */
+    _updateNames(property) {
+        let nc = this.metadataStore.namingConvention;
+        updateClientServerNames(nc, property, "name");
+        if (property.isNavigationProperty) {
+            updateClientServerNames(nc, property, "foreignKeyNames");
+            updateClientServerNames(nc, property, "invForeignKeyNames");
+            // these will get set later via _updateNps
+            // this.inverse
+            // this.entityType
+            // this.relatedDataProperties
+            //    dataProperty.relatedNavigationProperty
+            //    dataProperty.inverseNavigationProperty
+        }
+    }
+    /** @hidden @internal */
+    _checkNavProperty(navigationProperty) {
+        // if (navigationProperty.isNavigationProperty) {
+        if (navigationProperty instanceof NavigationProperty) {
+            if (navigationProperty.parentType !== this) {
+                throw new Error(core.formatString("The navigationProperty '%1' is not a property of entity type '%2'", navigationProperty.name, this.name));
+            }
+            return navigationProperty;
+        }
+        if (typeof (navigationProperty) === 'string') {
+            let np = this.getProperty(navigationProperty);
+            // if (np && np.isNavigationProperty) return np;
+            if (np && np instanceof NavigationProperty)
+                return np;
+        }
+        throw new Error("The 'navigationProperty' parameter must either be a NavigationProperty or the name of a NavigationProperty");
+    }
+    /** @hidden @internal */
+    _addDataProperty(dp) {
+        this.dataProperties.push(dp);
+        if (dp.isPartOfKey) {
+            this.keyProperties.push(dp);
+        }
+        if (dp.isComplexProperty) {
+            this.complexProperties.push(dp);
+        }
+        if (dp.concurrencyMode && dp.concurrencyMode !== "None") {
+            this.concurrencyProperties.push(dp);
+        }
+        if (dp.isUnmapped) {
+            this.unmappedProperties.push(dp);
+        }
+    }
+    /** @hidden @internal */
+    _addNavigationProperty(np) {
+        this.navigationProperties.push(np);
+        if (!isQualifiedTypeName(np.entityTypeName)) {
+            np.entityTypeName = qualifyTypeName(np.entityTypeName, this.namespace);
+        }
+    }
+    /** @hidden @internal */
+    _updateCps() {
+        let metadataStore = this.metadataStore;
+        let incompleteTypeMap = metadataStore._incompleteComplexTypeMap;
+        this.complexProperties.forEach(function (cp) {
+            if (cp.complexType)
+                return;
+            if (!resolveCp(cp, metadataStore)) {
+                core.getArray(incompleteTypeMap, cp.complexTypeName).push(cp);
+            }
+        });
+        if (this.isComplexType) {
+            (incompleteTypeMap[this.name] || []).forEach(function (cp) {
+                resolveCp(cp, metadataStore);
+            });
+            delete incompleteTypeMap[this.name];
+        }
+    }
+    /** @hidden @internal */
+    _updateNps() {
+        let metadataStore = this.metadataStore;
+        // resolve all navProps for this entityType
+        this.navigationProperties.forEach(function (np) {
+            tryResolveNp(np, metadataStore);
+        });
+        let incompleteTypeMap = metadataStore._incompleteTypeMap;
+        // next resolve all navProp that point to this entityType.
+        (incompleteTypeMap[this.name] || []).forEach(function (np) {
+            tryResolveNp(np, metadataStore);
+        });
+        // every navProp that pointed to this type should now be resolved
+        delete incompleteTypeMap[this.name];
+    }
+}
+/** @hidden @internal */
+EntityType.__nextAnonIx = 0;
+/** @hidden @internal */
+EntityType.qualifyTypeName = qualifyTypeName;
+EntityType.prototype._$typeName = "EntityType";
+function getRawValueFromConfig(rawEntity, dp) {
+    // 'true' fork can happen if an initializer contains an actaul instance of an already created complex object.
+    return (rawEntity.entityAspect || rawEntity.complexAspect) ? rawEntity.getProperty(dp.name) : rawEntity[dp.name];
+}
+function updateClientServerNames(nc, parent, clientPropName) {
+    let serverPropName = clientPropName + "OnServer";
+    let clientName = parent[clientPropName];
+    if (clientName && clientName.length) {
+        // if (parent.isUnmapped) return;
+        let serverNames = core.toArray(clientName).map(function (cName) {
+            let sName = nc.clientPropertyNameToServer(cName, parent);
+            let testName = nc.serverPropertyNameToClient(sName, parent);
+            if (cName !== testName) {
+                throw new Error("NamingConvention for this client property name does not roundtrip properly:" + cName + "-->" + testName);
+            }
+            return sName;
+        });
+        parent[serverPropName] = Array.isArray(clientName) ? serverNames : serverNames[0];
+    }
+    else {
+        let serverName = parent[serverPropName];
+        if ((!serverName) || serverName.length === 0)
+            return;
+        let clientNames = core.toArray(serverName).map(function (sName) {
+            let cName = nc.serverPropertyNameToClient(sName, parent);
+            let testName = nc.clientPropertyNameToServer(cName, parent);
+            if (sName !== testName) {
+                throw new Error("NamingConvention for this server property name does not roundtrip properly:" + sName + "-->" + testName);
+            }
+            return cName;
+        });
+        parent[clientPropName] = Array.isArray(serverName) ? clientNames : clientNames[0];
+    }
+}
+function createEmptyCtor(type) {
+    if (config.noEval) {
+        let Entity = function () { };
+        return Entity;
+    }
+    else {
+        let name = type.name.replace(/\W/g, '_');
+        return Function('return function ' + name + '(){}')();
+    }
+}
+function coEquals(co1, co2) {
+    let complexType = co1.complexAspect.parentProperty.dataType;
+    let dataProps = complexType.dataProperties;
+    let areEqual = dataProps.every(function (dp) {
+        if (!dp.isSettable)
+            return true;
+        let v1 = co1.getProperty(dp.name);
+        let v2 = co2.getProperty(dp.name);
+        if (dp.isComplexProperty && dp.isScalar) {
+            return coEquals(v1, v2);
+        }
+        else if (dp.isComplexProperty && !dp.isScalar) {
+            return core.arrayEquals(v1, v2, coEquals);
+        }
+        else {
+            let dataType = dp.dataType; // this will be a complexType when dp is a complexProperty
+            return (v1 === v2 || (dataType && dataType.normalize && v1 && v2 && dataType.normalize(v1) === dataType.normalize(v2)));
+        }
+    });
+    return areEqual;
+}
+function localPropsOnly(props) {
+    return props.filter(function (prop) {
+        return prop.baseProperty == null;
+    });
+}
+function resolveCp(cp, metadataStore) {
+    let complexType = metadataStore._getStructuralType(cp.complexTypeName, true);
+    if (!complexType)
+        return false;
+    if (!(complexType instanceof ComplexType)) {
+        throw new Error("Unable to resolve ComplexType with the name: " + cp.complexTypeName + " for the property: " + cp.name);
+    }
+    cp.dataType = complexType;
+    cp.defaultValue = null;
+    return true;
+}
+function tryResolveNp(np, metadataStore) {
+    if (np.entityType)
+        return true;
+    let entityType = metadataStore._getStructuralType(np.entityTypeName, true);
+    if (entityType) {
+        np.entityType = entityType;
+        np._resolveNp();
+        // don't bother removing - _updateNps will do it later.
+        // __arrayRemoveItem(incompleteNps, np, false);
+    }
+    else {
+        let incompleteNps = core.getArray(metadataStore._incompleteTypeMap, np.entityTypeName);
+        core.arrayAddItemUnique(incompleteNps, np);
+    }
+    return !!entityType;
+}
+function calcUnmappedProperties(stype, instance) {
+    let metadataPropNames = stype.getPropertyNames();
+    let modelLib = config.interfaceRegistry.modelLibrary.getDefaultInstance();
+    let trackablePropNames = modelLib.getTrackablePropertyNames(instance);
+    trackablePropNames.forEach(function (pn) {
+        if (metadataPropNames.indexOf(pn) === -1) {
+            let val = instance[pn];
+            try {
+                if (typeof val === "function")
+                    val = val();
+            }
+            catch (e) {
+            }
+            let dt = DataType.fromValue(val);
+            let newProp = new DataProperty({
+                name: pn,
+                dataType: dt,
+                isNullable: true,
+                isUnmapped: true
+            });
+            newProp.isSettable = core.isSettable(instance, pn);
+            if (stype instanceof EntityType && stype.subtypes != null && stype.subtypes.length) {
+                stype.getSelfAndSubtypes().forEach((st) => {
+                    st._addPropertyCore(new DataProperty(newProp));
+                });
+            }
+            else {
+                stype._addPropertyCore(newProp);
+            }
+        }
+    });
+}
+/**  Container for all of the metadata about a specific type of Complex object.
+>     let complexType = new ComplexType( {
+>         shortName: "address",
+>         namespace: "myAppNamespace"
+>     });
+@param config - Configuration settings
+**/
+export class ComplexType {
+    constructor(config) {
+        /** For polymorphic purpose only - always true here */
+        this.isComplexType = true;
+        // copy entityType methods onto complexType
+        /** See [[EntityType.getCtor]] */
+        this.getCtor = EntityType.prototype.getCtor;
+        // note the name change.
+        this.createInstance = EntityType.prototype.createEntity;
+        /** See [EntityType.addValidator] */
+        this.addValidator = EntityType.prototype.addValidator;
+        this.getProperty = EntityType.prototype.getProperty;
+        this.getPropertiesOnPath = EntityType.prototype.getPropertiesOnPath;
+        this.getPropertyNames = EntityType.prototype.getPropertyNames;
+        /** @hidden @internal */
+        this._addPropertyCore = EntityType.prototype._addPropertyCore;
+        /** @hidden @internal */
+        this._addDataProperty = EntityType.prototype._addDataProperty;
+        /** @hidden @internal */
+        this._updateNames = EntityType.prototype._updateNames;
+        /** @hidden @internal */
+        this._updateCps = EntityType.prototype._updateCps;
+        /** @hidden @internal */
+        this._initializeInstance = EntityType.prototype._initializeInstance;
+        /** @hidden @internal */
+        this._updateTargetFromRaw = EntityType.prototype._updateTargetFromRaw;
+        /** @hidden @internal */
+        this._setCtor = EntityType.prototype._setCtor;
+        if (arguments.length > 1) {
+            throw new Error("The ComplexType ctor has a single argument that is a configuration object.");
+        }
+        assertConfig(config)
+            .whereParam("shortName").isNonEmptyString()
+            .whereParam("namespace").isString().isOptional().withDefault("")
+            .whereParam("dataProperties").isOptional()
+            .whereParam("isComplexType").isOptional().isBoolean() // needed because this ctor can get called from the addEntityType method which needs the isComplexType prop
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+        this.name = qualifyTypeName(this.shortName, this.namespace);
+        this.isComplexType = true;
+        this.dataProperties = [];
+        this.complexProperties = [];
+        this.validators = [];
+        this.concurrencyProperties = [];
+        this.unmappedProperties = [];
+        this._mappedPropertiesCount = 0;
+        // keyProperties and navigationProperties are not used on complexTypes - but here to allow sharing of code between EntityType and ComplexType.
+        this.navigationProperties = [];
+        this.keyProperties = []; // may be used later to enforce uniqueness on arrays of complextypes.
+        if (config.dataProperties) {
+            addProperties(this, config.dataProperties, DataProperty);
+        }
+    }
+    /**
+    General purpose property set method
+    >      // assume em1 is an EntityManager
+    >      let addresstType = em1.metadataStore.getEntityType("Address");
+    >      addressType.setProperties( {
+    >          custom: { foo: 7, bar: "test" }
+    >      });
+    @param config - Custom config object
+    @param config.custom - {Object}
+    **/
+    setProperties(config) {
+        assertConfig(config)
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+    }
+    getAllValidators() {
+        // ComplexType inheritance is not YET supported.
+        return this.validators;
+    }
+    /** @hidden @internal */
+    _createInstanceCore(parent, parentProperty) {
+        let aCtor = this.getCtor();
+        let instance = new aCtor();
+        new ComplexAspect(instance, parent, parentProperty);
+        // initialization occurs during either attach or in createInstance call.
+        return instance;
+    }
+    addProperty(dataProperty) {
+        assertParam(dataProperty, "dataProperty").isInstanceOf(DataProperty).check();
+        return this._addPropertyCore(dataProperty);
+    }
+    getProperties() {
+        return this.dataProperties;
+    }
+    toJSON() {
+        return core.toJson(this, {
+            shortName: null,
+            namespace: null,
+            isComplexType: null,
+            dataProperties: null,
+            validators: null,
+            custom: null
+        });
+    }
+}
+ComplexType.prototype._$typeName = "ComplexType";
+/** Creates an instance of this complexType */
+ComplexType.prototype.createInstance = EntityType.prototype.createEntity;
+/**
+A DataProperty describes the metadata for a single property of an  [[EntityType]] that contains simple data.
+
+Instances of the DataProperty class are constructed automatically during Metadata retrieval. However it is also possible to construct them
+directly via the constructor.
+**/
+export class DataProperty {
+    /** DataProperty constructor
+    >      let lastNameProp = new DataProperty( {
+    >          name: "lastName",
+    >          dataType: DataType.String,
+    >          isNullable: true,
+    >          maxLength: 20
+    >      });
+    >      // assuming personEntityType is a newly constructed EntityType
+    >      personEntityType.addProperty(lastNameProperty);
+    @param config - A configuration Object or a DataProperty
+    */
+    constructor(config) {
+        /** Is this a DataProperty? - always true here. Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+        this.isDataProperty = true;
+        /** Is this a NavigationProperty? - always false here.  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+        this.isNavigationProperty = false;
+        assertConfig(config)
+            .whereParam("name").isString().isOptional()
+            .whereParam("nameOnServer").isString().isOptional()
+            .whereParam("dataType").isEnumOf(DataType).isOptional().or().isString().or().isInstanceOf(ComplexType)
+            .whereParam("complexTypeName").isOptional()
+            .whereParam("isNullable").isBoolean().isOptional().withDefault(true)
+            .whereParam("isScalar").isOptional().withDefault(true) // will be false for some NoSQL databases.
+            .whereParam("defaultValue").isOptional()
+            .whereParam("isPartOfKey").isBoolean().isOptional()
+            .whereParam("isUnmapped").isBoolean().isOptional()
+            .whereParam("isSettable").isBoolean().isOptional().withDefault(true)
+            .whereParam("concurrencyMode").isString().isOptional()
+            .whereParam("maxLength").isNumber().isOptional()
+            .whereParam("validators").isInstanceOf(Validator).isArray().isOptional().withDefault([])
+            .whereParam("displayName").isOptional()
+            .whereParam("enumType").isOptional()
+            .whereParam("rawTypeName").isOptional() // occurs with undefined datatypes
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+        let hasName = !!(this.name || this.nameOnServer);
+        if (!hasName) {
+            throw new Error("A DataProperty must be instantiated with either a 'name' or a 'nameOnServer' property");
+        }
+        // name/nameOnServer is resolved later when a metadataStore is available.
+        if (this.complexTypeName) {
+            this.isComplexProperty = true;
+            // this.dataType = null; // TODO: would like to remove this line because dataType will be set later.
+        }
+        else if (typeof (this.dataType) === "string") {
+            let dt = DataType.fromName(this.dataType);
+            if (!dt) {
+                throw new Error("Unable to find a DataType enumeration by the name of: " + this.dataType);
+            }
+            this.dataType = dt;
+        }
+        else if (!this.dataType) {
+            this.dataType = DataType.String;
+        }
+        // == as opposed to === is deliberate here.
+        if (this.defaultValue == null) {
+            if (this.isNullable) {
+                this.defaultValue = null;
+            }
+            else {
+                if (this.isComplexProperty) {
+                    // what to do? - shouldn't happen from EF - but otherwise ???
+                }
+                else if (this.dataType === DataType.Binary) {
+                    this.defaultValue = "AAAAAAAAJ3U="; // hack for all binary fields but value is specifically valid for timestamp fields - arbitrary valid 8 byte base64 value.
+                }
+                else {
+                    this.defaultValue = this.dataType.defaultValue;
+                    const msg = "A nonnullable DataProperty cannot have a null defaultValue. Name: " + (this.name || this.nameOnServer);
+                    if (this.defaultValue === null) {
+                        throw new Error(msg); // if defaultValue is explicity set to null, that's an error
+                    }
+                    else if (this.defaultValue == null) {
+                        console.warn(msg); // if defaultValue is not set, that's a warning
+                    }
+                }
+            }
+        }
+        else if (this.dataType.isNumeric) {
+            // in case the defaultValue comes in as a string ( which it does in EF6).
+            if (typeof (this.defaultValue) === "string") {
+                this.defaultValue = parseFloat(this.defaultValue);
+            }
+        }
+        if (this.isComplexProperty) {
+            this.isScalar = this.isScalar == null || this.isScalar === true;
+        }
+    }
+    static getRawValueFromServer(rawEntity, dp) {
+        if (dp.isUnmapped) {
+            return rawEntity[dp.nameOnServer || dp.name];
+        }
+        else {
+            let val = rawEntity[dp.nameOnServer];
+            return val !== undefined ? val : dp.defaultValue;
+        }
+    }
+    static getRawValueFromClient(rawEntity, dp) {
+        let val = rawEntity[dp.name];
+        return val !== undefined ? val : dp.defaultValue;
+    }
+    resolveProperty(propName) {
+        let result = this[propName];
+        let baseProp = this.baseProperty;
+        while (result == undefined && baseProp != null) {
+            result = baseProp[propName];
+            baseProp = baseProp.baseProperty;
+        }
+        return result;
+    }
+    formatName() {
+        return this.parentType.name + "--" + this.name;
+    }
+    /**
+    General purpose property set method
+    >      // assume em1 is an EntityManager
+    >      let prop = myEntityType.getProperty("myProperty");
+    >      prop.setProperties( {
+    >          custom: { foo: 7, bar: "test" }
+    >      });
+    @param config - A configuration object.
+    **/
+    setProperties(config) {
+        assertConfig(config)
+            .whereParam("displayName").isOptional()
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+    }
+    getAllValidators() {
+        let validators = this.validators.slice(0);
+        let baseProp = this.baseProperty;
+        while (baseProp) {
+            validators.push.apply(validators, baseProp.validators);
+            baseProp = baseProp.baseProperty;
+        }
+        return validators;
+    }
+    toJSON() {
+        // do not serialize dataTypes that are complexTypes
+        return core.toJson(this, {
+            name: null,
+            dataType: function (v) {
+                return (v && v instanceof DataType) ? v.name : undefined;
+            },
+            complexTypeName: null,
+            isNullable: true,
+            defaultValue: null,
+            isPartOfKey: false,
+            isUnmapped: false,
+            isSettable: true,
+            concurrencyMode: null,
+            maxLength: null,
+            validators: null,
+            displayName: null,
+            enumType: null,
+            rawTypeName: null,
+            isScalar: true,
+            custom: null
+        });
+    }
+    static fromJSON(json) {
+        json.dataType = DataType.fromName(json.dataType);
+        // Parse default value into correct data type. (dateTime instances require extra work to deserialize properly.)
+        if (json.defaultValue && json.dataType && json.dataType.parse) {
+            json.defaultValue = json.dataType.parse(json.defaultValue, typeof json.defaultValue);
+        }
+        if (json.validators) {
+            json.validators = json.validators.map(Validator.fromJSON);
+        }
+        return new DataProperty(json);
+    }
+}
+DataProperty.prototype._$typeName = "DataProperty";
+/**   A NavigationProperty describes the metadata for a single property of an [[EntityType]] that return instances of other EntityTypes.
+
+Instances of the NavigationProperty class are constructed automatically during Metadata retrieval.   However it is also possible to construct them
+directly via the constructor.
+**/
+export class NavigationProperty {
+    /** NavigationProperty constructor
+    >      let homeAddressProp = new NavigationProperty( {
+    >          name: "homeAddress",
+    >          entityTypeName: "Address:#myNamespace",
+    >          isScalar: true,
+    >          associationName: "address_person",
+    >          foreignKeyNames: ["homeAddressId"]
+    >      });
+    >      let homeAddressIdProp = new DataProperty( {
+    >          name: "homeAddressId"
+    >          dataType: DataType.Integer
+    >      });
+    >      // assuming personEntityType is a newly constructed EntityType
+    >      personEntityType.addProperty(homeAddressProp);
+    >      personEntityType.addProperty(homeAddressIdProp);
+    @param config - A configuration object.
+    **/
+    constructor(config) {
+        /** Is this a DataProperty? - always false here
+        Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+        this.isDataProperty = false;
+        /** Is this a NavigationProperty? - always true here
+        Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+        this.isNavigationProperty = true;
+        this.formatName = DataProperty.prototype.formatName;
+        this.getAllValidators = DataProperty.prototype.getAllValidators;
+        this.resolveProperty = DataProperty.prototype.resolveProperty;
+        assertConfig(config)
+            .whereParam("name").isString().isOptional()
+            .whereParam("nameOnServer").isString().isOptional()
+            .whereParam("entityTypeName").isString()
+            .whereParam("isScalar").isBoolean().isOptional().withDefault(true)
+            .whereParam("associationName").isString().isOptional()
+            .whereParam("foreignKeyNames").isArray().isString().isOptional().withDefault([])
+            .whereParam("foreignKeyNamesOnServer").isArray().isString().isOptional().withDefault([])
+            .whereParam("invForeignKeyNames").isArray().isString().isOptional().withDefault([])
+            .whereParam("invForeignKeyNamesOnServer").isArray().isString().isOptional().withDefault([])
+            .whereParam("validators").isInstanceOf(Validator).isArray().isOptional().withDefault([])
+            .whereParam("displayName").isOptional()
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+        let hasName = !!(this.name || this.nameOnServer);
+        if (!hasName) {
+            throw new Error("A Navigation property must be instantiated with either a 'name' or a 'nameOnServer' property");
+        }
+    }
+    /**
+    General purpose property set method
+    >      // assume myEntityType is an EntityType
+    >      let prop = myEntityType.getProperty("myProperty");
+    >      prop.setProperties( {
+    >          custom: { foo: 7, bar: "test" }
+    >      });
+    @param config - A config object
+    **/
+    // TODO: create an interface for this.
+    setProperties(config) {
+        if (!this.parentType) {
+            throw new Error("Cannot call NavigationProperty.setProperties until the parent EntityType of the NavigationProperty has been set.");
+        }
+        let inverse = config.inverse;
+        if (inverse)
+            delete config.inverse;
+        assertConfig(config)
+            .whereParam("displayName").isOptional()
+            .whereParam("foreignKeyNames").isArray().isString().isOptional().withDefault([])
+            .whereParam("invForeignKeyNames").isArray().isString().isOptional().withDefault([])
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+        this.parentType._updateNames(this);
+        this._resolveNp();
+        if (inverse) {
+            this.setInverse(inverse);
+        }
+    }
+    /** The inverse of this NavigationProperty.  The NavigationProperty that represents a navigation in the opposite direction
+    to this NavigationProperty. May be undefined for a undirectional NavigationProperty. __Read Only__ */
+    get inverse() {
+        return this.getInverse();
+    }
+    /** @hidden @internal */
+    getInverse() {
+        let np = this;
+        while (!np._inverse && np.baseProperty) {
+            np = np.baseProperty;
+        }
+        return np._inverse;
+    }
+    setInverse(inverseNp) {
+        // let invNp: NavigationProperty;
+        let invNp = (inverseNp instanceof NavigationProperty) ? inverseNp : this.entityType.getNavigationProperty(inverseNp);
+        if (!invNp) {
+            throw throwSetInverseError(this, "Unable to find inverse property: " + inverseNp);
+        }
+        if (this._inverse || invNp._inverse) {
+            throwSetInverseError(this, "It has already been set on one side or the other.");
+        }
+        if (invNp.entityType !== this.parentType) {
+            throwSetInverseError(this, invNp.formatName + " is not a valid inverse property for this.");
+        }
+        if (this.associationName) {
+            invNp.associationName = this.associationName;
+        }
+        else {
+            if (!invNp.associationName) {
+                invNp.associationName = this.formatName() + "_" + invNp.formatName();
+            }
+            this.associationName = invNp.associationName;
+        }
+        this._resolveNp();
+        invNp._resolveNp();
+    }
+    // // In progress - will be used for manual metadata config
+    // createInverse(config: any) {
+    //   if (!this.entityType) {
+    //     throwCreateInverseError(this, "has not yet been defined.");
+    //   }
+    //   if (this.entityType.isFrozen) {
+    //     throwCreateInverseError(this, "is frozen.");
+    //   }
+    //   let metadataStore = this.entityType.metadataStore;
+    //   if (metadataStore == null) {
+    //     throwCreateInverseError(this, "has not yet been added to the metadataStore.");
+    //   }
+    //   config.entityTypeName = this.parentEntityType.name;
+    //   config.associationName = this.associationName;
+    //   let invNp = new NavigationProperty(config);
+    //   this.parentEntityType.addNavigationProperty(invNp);
+    //   return invNp;
+    // };
+    toJSON() {
+        return core.toJson(this, {
+            name: null,
+            entityTypeName: null,
+            isScalar: null,
+            associationName: null,
+            validators: null,
+            displayName: null,
+            foreignKeyNames: null,
+            invForeignKeyNames: null,
+            custom: null
+        });
+    }
+    static fromJSON(json) {
+        if (json.validators) {
+            json.validators = json.validators.map(Validator.fromJSON);
+        }
+        return new NavigationProperty(json);
+    }
+    /** @hidden @internal */
+    _resolveNp() {
+        let np = this;
+        let entityType = np.entityType;
+        let invNp = core.arrayFirst(entityType.navigationProperties, (altNp) => {
+            // Can't do this because of possibility of comparing a base class np with a subclass altNp.
+            // return altNp.associationName === np.associationName
+            //    && altNp !== np;
+            // So use this instead.
+            return altNp.associationName === np.associationName &&
+                (altNp.name !== np.name || altNp.entityTypeName !== np.entityTypeName);
+        });
+        np._inverse = invNp || undefined;
+        //if (invNp && invNp.inverse == null) {
+        //    invNp._resolveNp();
+        //}
+        if (!invNp) {
+            // unidirectional 1-n relationship
+            np.invForeignKeyNames.forEach(function (invFkName) {
+                let fkProp = entityType.getDataProperty(invFkName);
+                if (fkProp == null) {
+                    throw new Error("EntityType '" + np.entityTypeName + "' has no foreign key matching '" + invFkName + "'");
+                }
+                let invEntityType = np.parentType;
+                invNp = core.arrayFirst(invEntityType.navigationProperties, (np2) => {
+                    return np2.invForeignKeyNames && np2.invForeignKeyNames.indexOf(fkProp.name) >= 0 && np2.entityType === fkProp.parentType;
+                });
+                fkProp.inverseNavigationProperty = invNp || undefined;
+                core.arrayAddItemUnique(entityType.foreignKeyProperties, fkProp);
+            });
+        }
+        resolveRelated(np);
+    }
+}
+NavigationProperty.prototype._$typeName = "NavigationProperty";
+function throwSetInverseError(np, message) {
+    throw new Error("Cannot set the inverse property for: " + np.formatName() + ". " + message);
+}
+// Not current used.
+// function throwCreateInverseError(np: NavigationProperty, message: string) {
+//   throw new Error("Cannot create inverse for: " + np.formatName() + ". The entityType for this navigation property " + message);
+// }
+// sets navigation property: relatedDataProperties and dataProperty: relatedNavigationProperty
+function resolveRelated(np) {
+    let fkNames = np.foreignKeyNames;
+    if (fkNames.length === 0)
+        return;
+    let parentEntityType = np.parentType;
+    let fkProps = fkNames.map(function (fkName) {
+        return parentEntityType.getDataProperty(fkName);
+    });
+    let fkPropCollection = parentEntityType.foreignKeyProperties;
+    fkProps.forEach((dp) => {
+        core.arrayAddItemUnique(fkPropCollection, dp);
+        dp.relatedNavigationProperty = np;
+        // now update the inverse
+        core.arrayAddItemUnique(np.entityType.inverseForeignKeyProperties, dp);
+        if (np.relatedDataProperties) {
+            core.arrayAddItemUnique(np.relatedDataProperties, dp);
+        }
+        else {
+            np.relatedDataProperties = [dp];
+        }
+    });
+}
+/**
+AutoGeneratedKeyType is an 'Enum' containing all of the valid states for an automatically generated key.
+**/
+export class AutoGeneratedKeyType extends BreezeEnum {
+}
+/**
+This entity does not have an autogenerated key.
+The client must set the key before adding the entity to the EntityManager
+**/
+AutoGeneratedKeyType.None = new AutoGeneratedKeyType();
+/**
+This entity's key is an Identity column and is set by the backend database.
+Keys for new entities will be temporary until the entities are saved at which point the keys will
+be converted to their 'real' versions.
+**/
+AutoGeneratedKeyType.Identity = new AutoGeneratedKeyType();
+/**
+This entity's key is generated by a KeyGenerator and is set by the backend database.
+Keys for new entities will be temporary until the entities are saved at which point the keys will
+be converted to their 'real' versions.
+**/
+AutoGeneratedKeyType.KeyGenerator = new AutoGeneratedKeyType();
+AutoGeneratedKeyType.prototype._$typeName = "AutoGeneratedKeyType";
+Error['x'] = AutoGeneratedKeyType.resolveSymbols();
+let proto = Param.prototype;
+// 'this' below is TS annotation 
+proto.isEntity = function () {
+    return this._addContext({
+        fn: isEntity,
+        msg: " must be an entity"
+    });
+};
+function isEntity(context, v) {
+    if (v == null)
+        return false;
+    return (v.entityType !== undefined);
+}
+proto.isEntityProperty = function () {
+    return this._addContext({
+        fn: isEntityProperty,
+        msg: " must be either a DataProperty or a NavigationProperty"
+    });
+};
+function isEntityProperty(context, v) {
+    if (v == null)
+        return false;
+    return (v.isDataProperty || v.isNavigationProperty);
+}
+// functions shared between classes related to Metadata
+function isQualifiedTypeName(entityTypeName) {
+    return entityTypeName.indexOf(":#") >= 0;
+}
+export function qualifyTypeName(shortName, ns) {
+    if (ns && ns.length > 0) {
+        return shortName + ":#" + ns;
+    }
+    else {
+        return shortName;
+    }
+}
+// Used by both ComplexType and EntityType
+function addProperties(entityType, propObj, ctor) {
+    if (propObj == null)
+        return;
+    if (Array.isArray(propObj)) {
+        propObj.forEach(entityType._addPropertyCore.bind(entityType));
+    }
+    else if (typeof (propObj) === 'object') {
+        for (let key in propObj) {
+            if (core.hasOwnProperty(propObj, key)) {
+                let value = propObj[key];
+                value.name = key;
+                let prop = new ctor(value);
+                entityType._addPropertyCore(prop);
+            }
+        }
+    }
+    else {
+        throw new Error("The 'dataProperties' or 'navigationProperties' values must be either an array of data/nav properties or an object where each property defines a data/nav property");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-metadata.js","sourceRoot":"ng://breeze-client/","sources":["src/entity-metadata.ts"],"names":[],"mappings":"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","sourcesContent":["import { core, ErrorCallback } from './core';\r\nimport { config } from './config';\r\nimport { BreezeEvent } from './event';\r\nimport { assertParam, assertConfig, Param } from './assert-param';\r\nimport { DataType } from './data-type';\r\nimport { EntityAspect, ComplexAspect, Entity, ComplexObject, StructuralObject } from './entity-aspect';\r\nimport { EntityKey } from './entity-key';\r\nimport { Validator } from './validate';\r\nimport { BreezeEnum } from './enum';\r\nimport { DataService } from './data-service';\r\nimport { NamingConvention } from './naming-convention';\r\nimport { CsdlMetadataParser } from './csdl-metadata-parser'; // TODO isolate this later;\r\nimport { LocalQueryComparisonOptions } from './local-query-comparison-options';\r\nimport { defaultPropertyInterceptor } from './default-property-interceptor';\r\n\r\nexport type EntityProperty = DataProperty | NavigationProperty;\r\nexport type StructuralType = EntityType | ComplexType;\r\n\r\n/** @hidden @internal */\r\nexport interface IStructuralTypeMap {\r\n  [index: string]: StructuralType;\r\n}\r\n/** Keep track of constructors and initializers for StructuralTypes */\r\ninterface CtorRecord { \r\n  ctor: { new (): StructuralObject };\r\n  initFn?: Function | string; \r\n  noTrackingFn?: Function;\r\n}\r\n\r\n// TODO: consider exposing later\r\n/** @hidden @internal */\r\nexport interface IMetadataJson {\r\n  metadataVersion: string;\r\n  name: string;\r\n  namingConvention: string;\r\n  localQueryComparisonOptions: string;\r\n  dataServices: Object[]; // IDataServiceJson[]\r\n  structuralTypes: Object[]; // IStructuralTypeJson[]; \r\n  resourceEntityTypeMap: Object[]; // IResourceEntityTypeJson[]\r\n  incompleteTypeMap: Object[];\r\n}\r\n\r\n/** Configuration info to be passed to the [[MetadataStore]] constructor */\r\nexport interface MetadataStoreConfig {\r\n  /** The  [[NamingConvention]] associated with this MetadataStore. */\r\n  namingConvention?: NamingConvention;\r\n  /** The  [[LocalQueryComparisonOptions]] associated with this MetadataStore. */\r\n  localQueryComparisonOptions?: LocalQueryComparisonOptions;\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n  name?: string;\r\n}\r\n\r\nexport interface MetadataFetchedEventArgs {\r\n  metadataStore: MetadataStore;\r\n  dataService: DataService | string;\r\n  rawMetadata: any;\r\n}\r\n\r\n/**\r\nAn instance of the MetadataStore contains all of the metadata about a collection of [[EntityType]]'s.\r\nMetadataStores may be shared across [[EntityManager]]'s.  If an EntityManager is created without an\r\nexplicit MetadataStore, the MetadataStore from the MetadataStore.defaultInstance property will be used.\r\n@dynamic\r\n**/\r\nexport class MetadataStore {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on proto\r\n\r\n  /** @hidden @internal */\r\n  static __id = 0;\r\n  /** @hidden @internal */\r\n  static ANONTYPE_PREFIX = \"_IB_\";\r\n  /** The version of any MetadataStores created by this class */\r\n  static metadataVersion = '1.0.5';\r\n\r\n  name: string;\r\n  dataServices: DataService[];\r\n\r\n  /** The  [[NamingConvention]] associated with this MetadataStore. __Read Only__ */\r\n  namingConvention: NamingConvention;\r\n  /** The  [[LocalQueryComparisonOptions]] associated with this MetadataStore. __Read Only__ */\r\n  localQueryComparisonOptions: LocalQueryComparisonOptions;\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n  /**\r\n  An [[BreezeEvent]] that fires after a MetadataStore has completed fetching metadata from a remote service.\r\n  \r\n  @eventArgs -\r\n    - metadataStore - The MetadataStore into which the metadata was fetched.\r\n    - dataService - The [[DataService]] that metadata was fetched from.\r\n    - rawMetadata - {Object} The raw metadata returned from the service. (It will have already been processed by this point).\r\n  >      let ms = myEntityManager.metadataStore;\r\n  >      ms.metadataFetched.subscribe(function(args) {\r\n  >          let metadataStore = args.metadataStore;\r\n  >          let dataService = args.dataService;\r\n  >      });\r\n  @event\r\n  **/\r\n  metadataFetched: BreezeEvent<MetadataFetchedEventArgs>;\r\n  /** @hidden @internal */\r\n  _resourceEntityTypeMap: Record<string, string>;\r\n  /** @hidden @internal */\r\n  _entityTypeResourceMap: Record<string, string>;\r\n  /** @hidden @internal key is qualified structuraltype name - value is structuralType. ( structural = entityType or complexType). */\r\n  _structuralTypeMap: IStructuralTypeMap;\r\n  /** @hidden @internal key is shortName, value is qualified name - does not need to be serialized. **/\r\n  _shortNameMap: Record<string, string>;\r\n  /** @hidden @internal key is either short or qual type name - value is ctor; **/\r\n  _ctorRegistry: Record<string, CtorRecord>;\r\n  /** @hidden @internal key is entityTypeName; value is array of nav props **/\r\n  _incompleteTypeMap: Record<string, NavigationProperty[]>;\r\n  /** @hidden @internal **/\r\n  _incompleteComplexTypeMap: Record<string, DataProperty[]>;\r\n  /** @hidden @internal { json: any, stype: StructuralType }[] | { entityType: EntityType, csdlEntityType: any }[] **/\r\n  _deferredTypes: Record<string, any>;\r\n  /** @hidden @internal **/\r\n  _id: number;\r\n\r\n  /**\r\n  Constructs a new MetadataStore.\r\n  \r\n  >     let ms = new MetadataStore();\r\n\r\n  The store can then be associated with an EntityManager\r\n  >     let entityManager = new EntityManager( {\r\n  >         serviceName: \"breeze/NorthwindIBModel\", \r\n  >         metadataStore: ms \r\n  >     });\r\n\r\n  or for an existing EntityManager\r\n  >    // Assume em1 is an existing EntityManager\r\n  >    em1.setProperties( { metadataStore: ms });\r\n  \r\n  @param config - Configuration settings .\r\n    - namingConvention - (default=NamingConvention.defaultInstance) NamingConvention to be used in mapping property names\r\n  between client and server. Uses the NamingConvention.defaultInstance if not specified.\r\n    - localQueryComparisonOptions - (default=LocalQueryComparisonOptions.defaultInstance) The LocalQueryComparisonOptions to be\r\n  used when performing \"local queries\" in order to match the semantics of queries against a remote service.\r\n    - serializerFn - A function that is used to mediate the serialization of instances of this type.\r\n  **/\r\n  constructor(config?: MetadataStoreConfig) {\r\n    config = config || {};\r\n    assertConfig(config)\r\n      .whereParam(\"namingConvention\").isOptional().isInstanceOf(NamingConvention).withDefault(NamingConvention.defaultInstance)\r\n      .whereParam(\"localQueryComparisonOptions\").isOptional().isInstanceOf(LocalQueryComparisonOptions).withDefault(LocalQueryComparisonOptions.defaultInstance)\r\n      .whereParam(\"serializerFn\").isOptional().isFunction()\r\n      .applyAll(this);\r\n    this.dataServices = []; // array of dataServices;\r\n    this._resourceEntityTypeMap = {}; // key is resource name - value is qualified entityType name\r\n    this._structuralTypeMap = {}; // key is qualified structuraltype name - value is structuralType. ( structural = entityType or complexType).\r\n    this._shortNameMap = {}; // key is shortName, value is qualified name - does not need to be serialized.\r\n    this._ctorRegistry = {}; // key is either short or qual type name - value is ctor;\r\n\r\n    this._incompleteTypeMap = {}; // key is entityTypeName; value is array of nav props\r\n    this._incompleteComplexTypeMap = {}; // key is complexTypeName; value is array of complexType props\r\n    this._id = MetadataStore.__id++;\r\n    this.metadataFetched = new BreezeEvent(\"metadataFetched\", this);\r\n\r\n  }\r\n\r\n  // needs to be made avail to dataService.xxx files\r\n  static normalizeTypeName = core.memoize(function (rawTypeName: string) {\r\n    return rawTypeName && MetadataStore.parseTypeName(rawTypeName).typeName;\r\n  });\r\n  // for debugging use the line below instead.\r\n  //ctor.normalizeTypeName = function (rawTypeName) { return parseTypeName(rawTypeName).typeName; };\r\n\r\n  /**\r\n  General purpose property set method\r\n  \r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     em1.metadataStore.setProperties( {\r\n  >         version: \"6.1.3\",\r\n  >         serializerFn: function(prop, value) {\r\n  >         return (prop.isUnmapped) ? undefined : value;\r\n  >         }\r\n  >     )};\r\n  @param config -  An object containing the selected properties and values to set.\r\n  **/\r\n  setProperties(config: MetadataStoreConfig) {\r\n    assertConfig(config)\r\n      .whereParam(\"name\").isString().isOptional()\r\n      .whereParam(\"serializerFn\").isFunction().isOptional()\r\n      .applyAll(this);\r\n  }\r\n\r\n  /**\r\n  Adds a DataService to this MetadataStore. If a DataService with the same serviceName is already\r\n  in the MetadataStore an exception will be thrown.\r\n  @param dataService - The [[DataService]] to add\r\n  @param shouldOverwrite - (default=false) Permit overwrite of existing DataService rather than throw exception\r\n  **/\r\n  addDataService(dataService: DataService, shouldOverwrite?: boolean) {\r\n    assertParam(dataService, \"dataService\").isInstanceOf(DataService).check();\r\n    assertParam(shouldOverwrite, \"shouldOverwrite\").isBoolean().isOptional().check();\r\n    let ix = this._getDataServiceIndex(dataService.serviceName);\r\n    if (ix >= 0) {\r\n      if (!!shouldOverwrite) {\r\n        this.dataServices[ix] = dataService;\r\n      } else {\r\n        throw new Error(\"A dataService with this name '\" + dataService.serviceName + \"' already exists in this MetadataStore\");\r\n      }\r\n    } else {\r\n      this.dataServices.push(dataService);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _getDataServiceIndex(serviceName: string) {\r\n    return core.arrayIndexOf(this.dataServices, function (ds) {\r\n      return ds.serviceName === serviceName;\r\n    });\r\n  }\r\n\r\n  /**\r\n  Adds an EntityType to this MetadataStore.  No additional properties may be added to the EntityType after its has\r\n  been added to the MetadataStore.\r\n  @param structuralType - The EntityType or ComplexType to add\r\n  **/\r\n  addEntityType(stype: StructuralType | EntityTypeConfig | ComplexTypeConfig) {\r\n    let structuralType: StructuralType;\r\n    if (stype instanceof EntityType || stype instanceof ComplexType) {\r\n      structuralType = stype;\r\n    } else {\r\n      structuralType = (stype as any).isComplexType ? new ComplexType(stype) : new EntityType(stype);\r\n    }\r\n\r\n    // if (!structuralType.isComplexType) { // same as below but isn't a 'type guard'\r\n    if (structuralType instanceof EntityType) {\r\n      if (structuralType.baseTypeName && !structuralType.baseEntityType) {\r\n        let baseEntityType = this._getStructuralType(structuralType.baseTypeName, true);\r\n        // safe cast because we know that baseEntityType must be an EntityType if the structuralType is an EntityType\r\n        structuralType._updateFromBase(baseEntityType as EntityType);\r\n      }\r\n      if (structuralType.keyProperties.length === 0 && !structuralType.isAbstract) {\r\n        throw new Error(\"Unable to add \" + structuralType.name +\r\n          \" to this MetadataStore.  An EntityType must have at least one property designated as a key property - See the 'DataProperty.isPartOfKey' property.\");\r\n      }\r\n    }\r\n\r\n    structuralType.metadataStore = this;\r\n    // don't register anon types\r\n    if (!(structuralType as any).isAnonymous) {\r\n      if (this._structuralTypeMap[structuralType.name]) {\r\n        throw new Error(\"Type \" + structuralType.name + \" already exists in this MetadataStore.\");\r\n      }\r\n\r\n      this._structuralTypeMap[structuralType.name] = structuralType;\r\n      this._shortNameMap[structuralType.shortName] = structuralType.name;\r\n    }\r\n\r\n    structuralType.getProperties().forEach(p => {\r\n      structuralType._updateNames(p);\r\n      if (!p.isUnmapped) {\r\n        structuralType._mappedPropertiesCount++;\r\n      }\r\n    });\r\n\r\n    structuralType._updateCps();\r\n\r\n    // 'isEntityType' is a type guard\r\n    if (structuralType instanceof EntityType) {\r\n      structuralType._updateNps();\r\n      // give the type it's base's resource name if it doesn't have its own.\r\n      let defResourceName = structuralType.defaultResourceName || (structuralType.baseEntityType && structuralType.baseEntityType.defaultResourceName);\r\n      if (defResourceName && !this.getEntityTypeNameForResourceName(defResourceName)) {\r\n        this.setEntityTypeForResourceName(defResourceName, structuralType.name);\r\n      }\r\n      structuralType.defaultResourceName = defResourceName;\r\n      // check if this structural type's name, short version or qualified version has a registered ctor.\r\n      structuralType.getEntityCtor();\r\n    }\r\n\r\n  }\r\n\r\n\r\n  /**\r\n  Exports this MetadataStore to a serialized string appropriate for local storage.   This operation is also called\r\n  internally when exporting an EntityManager.\r\n  >      // assume ms is a previously created MetadataStore\r\n  >      let metadataAsString = ms.exportMetadata();\r\n  >      window.localStorage.setItem(\"metadata\", metadataAsString);\r\n  >      // and later, usually in a different session imported\r\n  >      let metadataFromStorage = window.localStorage.getItem(\"metadata\");\r\n  >      let newMetadataStore = new MetadataStore();\r\n  >      newMetadataStore.importMetadata(metadataFromStorage);\r\n  @return A serialized version of this MetadataStore that may be stored locally and later restored.\r\n  **/\r\n  exportMetadata() {\r\n    let result = JSON.stringify({\r\n      \"metadataVersion\": MetadataStore.metadataVersion,\r\n      \"name\": this.name,\r\n      \"namingConvention\": this.namingConvention.name,\r\n      \"localQueryComparisonOptions\": this.localQueryComparisonOptions.name,\r\n      \"dataServices\": this.dataServices,\r\n      \"structuralTypes\": core.objectMap(this._structuralTypeMap),\r\n      \"resourceEntityTypeMap\": this._resourceEntityTypeMap\r\n    }, null, config.stringifyPad);\r\n    return result;\r\n  }\r\n\r\n  /**\r\n  Imports a previously exported serialized MetadataStore into this MetadataStore.\r\n    \r\n  >      // assume ms is a previously created MetadataStore\r\n  >      let metadataAsString = ms.exportMetadata();\r\n  >      window.localStorage.setItem(\"metadata\", metadataAsString);\r\n  >      // and later, usually in a different session\r\n  >      let metadataFromStorage = window.localStorage.getItem(\"metadata\");\r\n  >      let newMetadataStore = new MetadataStore();\r\n  >      newMetadataStore.importMetadata(metadataFromStorage);\r\n  @param exportedMetadata - A previously exported MetadataStore.\r\n  @param allowMerge -  Allows custom metadata to be merged into existing metadata types.\r\n  @return This MetadataStore.\r\n  @chainable\r\n  **/\r\n  importMetadata(exportedMetadata: string | Object, allowMerge: boolean = false) {\r\n    assertParam(allowMerge, \"allowMerge\").isOptional().isBoolean().check();\r\n    this._deferredTypes = {};\r\n    // insure that we don't mutate incoming exportedMetadata ( if its an object)\r\n    let metadataAsString = (typeof (exportedMetadata) === \"string\") ? exportedMetadata : JSON.stringify(exportedMetadata);\r\n    const metadataJson = JSON.parse(metadataAsString);\r\n\r\n    if (metadataJson.schema) {\r\n      return CsdlMetadataParser.parse(this, metadataJson.schema, metadataJson.altMetadata);\r\n    }\r\n\r\n    let json = metadataJson as IMetadataJson;\r\n    if (json.metadataVersion && json.metadataVersion !== MetadataStore.metadataVersion) {\r\n      let msg = core.formatString(\"Cannot import metadata with a different 'metadataVersion' (%1) than the current 'MetadataStore.metadataVersion' (%2) \",\r\n        json.metadataVersion, MetadataStore.metadataVersion);\r\n      throw new Error(msg);\r\n    }\r\n\r\n    let ncName = json.namingConvention;\r\n    let lqcoName = json.localQueryComparisonOptions;\r\n    if (this.isEmpty()) {\r\n      this.namingConvention = config._fetchObject(NamingConvention, ncName) || this.namingConvention;\r\n      this.localQueryComparisonOptions = config._fetchObject(LocalQueryComparisonOptions, lqcoName) || this.localQueryComparisonOptions;\r\n    } else {\r\n      if (ncName && this.namingConvention.name !== ncName) {\r\n        throw new Error(\"Cannot import metadata with a different 'namingConvention' from the current MetadataStore\");\r\n      }\r\n      if (lqcoName && this.localQueryComparisonOptions.name !== lqcoName) {\r\n        throw new Error(\"Cannot import metadata with different 'localQueryComparisonOptions' from the current MetadataStore\");\r\n      }\r\n    }\r\n\r\n    //noinspection JSHint\r\n    json.dataServices && json.dataServices.forEach((ds) => {\r\n      let realDs = DataService.fromJSON(ds);\r\n      this.addDataService(realDs, true);\r\n    });\r\n\r\n    json.structuralTypes && json.structuralTypes.forEach((stype) => {\r\n      structuralTypeFromJson(this, stype, allowMerge);\r\n    });\r\n    core.extend(this._resourceEntityTypeMap, json.resourceEntityTypeMap);\r\n    core.extend(this._incompleteTypeMap, json.incompleteTypeMap);\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n  Creates a new MetadataStore from a previously exported serialized MetadataStore\r\n  >      // assume ms is a previously created MetadataStore\r\n  >      let metadataAsString = ms.exportMetadata();\r\n  >      window.localStorage.setItem(\"metadata\", metadataAsString);\r\n  >      // and later, usually in a different session\r\n  >      let metadataFromStorage = window.localStorage.getItem(\"metadata\");\r\n  >      let newMetadataStore = MetadataStore.importMetadata(metadataFromStorage);\r\n  @param exportedString - A previously exported MetadataStore.\r\n  @return A new MetadataStore.\r\n  **/\r\n  static importMetadata(exportedString: string) {\r\n    let ms = new MetadataStore();\r\n    ms.importMetadata(exportedString);\r\n    return ms;\r\n  }\r\n\r\n  /**\r\n  Returns whether Metadata has been retrieved for a specified service name.\r\n  >      // Assume em1 is an existing EntityManager.\r\n  >      if (!em1.metadataStore.hasMetadataFor(\"breeze/NorthwindIBModel\"))) {\r\n  >          // do something interesting\r\n  >      }\r\n  @param serviceName - The service name.\r\n  @return Whether metadata has already been retrieved for the specified service name.\r\n  **/\r\n  hasMetadataFor(serviceName: string) {\r\n    return !!this.getDataService(serviceName);\r\n  }\r\n\r\n  /**\r\n  Returns the DataService for a specified service name\r\n  >      // Assume em1 is an existing EntityManager.\r\n  >      let ds = em1.metadataStore.getDataService(\"breeze/NorthwindIBModel\");\r\n  >      let adapterName = ds.adapterName; // may be null\r\n  @param serviceName - The service name.\r\n  @return The DataService with the specified name.\r\n  **/\r\n  getDataService(serviceName: string) {\r\n    assertParam(serviceName, \"serviceName\").isString().check();\r\n\r\n    serviceName = DataService._normalizeServiceName(serviceName);\r\n    return core.arrayFirst(this.dataServices, function (ds: DataService) {\r\n      return ds.serviceName === serviceName;\r\n    });\r\n  }\r\n\r\n  /**\r\n  Fetches the metadata for a specified 'service'. This method is automatically called\r\n  internally by an EntityManager before its first query against a new service. __Async__\r\n\r\n  Usually you will not actually process the results of a fetchMetadata call directly, but will instead\r\n  ask for the metadata from the EntityManager after the fetchMetadata call returns.\r\n  >      let ms = new MetadataStore();\r\n  >      // or more commonly\r\n  >      // let ms = anEntityManager.metadataStore;\r\n  >      ms.fetchMetadata(\"breeze/NorthwindIBModel\").then(function(rawMetadata) {\r\n  >            // do something with the metadata\r\n  >      }).catch(function(exception) {\r\n  >          // handle exception here\r\n  >      });\r\n  @param dataService -  Either a DataService or just the name of the DataService to fetch metadata for.\r\n  @param callback - Function called on success.\r\n  @param errorCallback - Function called on failure.\r\n  @return Promise\r\n  **/\r\n  fetchMetadata(dataService: string | DataService, callback?: (schema: any) => void, errorCallback?: ErrorCallback) {\r\n    try {\r\n      assertParam(dataService, \"dataService\").isString().or().isInstanceOf(DataService).check();\r\n      assertParam(callback, \"callback\").isFunction().isOptional().check();\r\n      assertParam(errorCallback, \"errorCallback\").isFunction().isOptional().check();\r\n\r\n      if (typeof dataService === \"string\") {\r\n        // use the dataService with a matching name or create a new one.\r\n        dataService = this.getDataService(dataService) || new DataService({ serviceName: dataService });\r\n      }\r\n\r\n      dataService = DataService.resolve([dataService]);\r\n\r\n      if (this.hasMetadataFor(dataService.serviceName)) {\r\n        throw new Error(\"Metadata for a specific serviceName may only be fetched once per MetadataStore. ServiceName: \" + dataService.serviceName);\r\n      }\r\n\r\n      return dataService.adapterInstance!.fetchMetadata(this, dataService).then((rawMetadata: any) => {\r\n        this.metadataFetched.publish({ metadataStore: this, dataService: dataService, rawMetadata: rawMetadata });\r\n        if (callback) callback(rawMetadata);\r\n        return Promise.resolve(rawMetadata);\r\n      }, function (error: any) {\r\n        if (errorCallback) errorCallback(error);\r\n        return Promise.reject(error);\r\n      });\r\n    } catch (e) {\r\n      return Promise.reject(e);\r\n    }\r\n  }\r\n\r\n\r\n  // TODO: strongly type interceptor below.\r\n  /**\r\n  Used to register a constructor for an EntityType that is not known via standard Metadata discovery;\r\n  i.e. an unmapped type.\r\n  @param entityCtor - The constructor function for the 'unmapped' type.\r\n  @param interceptor - An interceptor function\r\n  **/\r\n  trackUnmappedType(entityCtor: any, interceptor: any) {\r\n    assertParam(entityCtor, \"entityCtor\").isFunction().check();\r\n    assertParam(interceptor, \"interceptor\").isFunction().isOptional().check();\r\n    // TODO: think about adding this to the MetadataStore.\r\n    let entityType = new EntityType(this);\r\n    entityType._setCtor(entityCtor, interceptor);\r\n  }\r\n\r\n  /**\r\n  Provides a mechanism to register a 'custom' constructor to be used when creating new instances\r\n  of the specified entity type.  If this call is not made, a default constructor is created for\r\n  the entity as needed.\r\n  This call may be made before or after the corresponding EntityType has been discovered via\r\n  Metadata discovery.\r\n  >      let Customer = function () {\r\n  >              this.miscData = \"asdf\";\r\n  >          };\r\n  >      Customer.prototype.doFoo() {\r\n  >              ...\r\n  >          }\r\n  >      // assume em1 is a preexisting EntityManager;\r\n  >      em1.metadataStore.registerEntityTypeCtor(\"Customer\", Customer);\r\n  >      // any queries or EntityType.create calls from this point on will call the Customer constructor\r\n  >      // registered above.\r\n  @param structuralTypeName - The name of the EntityType or ComplexType.\r\n  @param aCtor - The constructor for this EntityType or ComplexType; may be null if all you want to do is set the next parameter.\r\n  @param initFn - A function or the name of a function on the entity that is to be executed immediately after the entity has been created\r\n  and populated with any initial values. Called with 'initFn(entity)'\r\n  @param noTrackingFn - A function that is executed immediately after a noTracking entity has been created and whose return\r\n  value will be used in place of the noTracking entity.\r\n  **/\r\n  registerEntityTypeCtor(structuralTypeName: string, aCtor?: any, initFn?: Function | string, noTrackingFn?: Function) {\r\n    assertParam(structuralTypeName, \"structuralTypeName\").isString().check();\r\n    assertParam(aCtor, \"aCtor\").isFunction().isOptional().check();\r\n    assertParam(initFn, \"initFn\").isOptional().isFunction().or().isString().check();\r\n    assertParam(noTrackingFn, \"noTrackingFn\").isOptional().isFunction().check();\r\n\r\n    let qualifiedTypeName = getQualifiedTypeName(this, structuralTypeName, false);\r\n    let typeName = qualifiedTypeName || structuralTypeName;\r\n\r\n    if (aCtor) {\r\n      if (aCtor._$typeName && aCtor._$typeName !== typeName) {\r\n        // TODO: wrap this - console and especially console.warn does not exist in all browsers.\r\n        console.warn(\"Registering a constructor for \" + typeName + \" that is already used for \" + aCtor._$typeName + \".\");\r\n      }\r\n      aCtor._$typeName = typeName;\r\n    }\r\n\r\n    this._ctorRegistry[typeName] = { ctor: aCtor, initFn: initFn, noTrackingFn: noTrackingFn };\r\n    if (qualifiedTypeName) {\r\n      let stype = this._structuralTypeMap[qualifiedTypeName];\r\n      stype && stype.getCtor(true); // this will complete the registration if avail now.\r\n    }\r\n\r\n  }\r\n\r\n  /**\r\n  Returns whether this MetadataStore contains any metadata yet.\r\n  >      // assume em1 is a preexisting EntityManager;\r\n  >      if (em1.metadataStore.isEmpty()) {\r\n  >          // do something interesting\r\n  >      }\r\n  **/\r\n  isEmpty() {\r\n    return core.isEmpty(this._structuralTypeMap);\r\n  }\r\n\r\n  /**\r\n  Returns an [[EntityType]] or null given its name.\r\n  >      // assume em1 is a preexisting EntityManager\r\n  >      let odType = em1.metadataStore.getAsEntityType(\"OrderDetail\");\r\n\r\n  or to throw an error if the type is not found\r\n  >      let badType = em1.metadataStore.getAsEntityType(\"Foo\", false);\r\n  >      // badType will not get set and an exception will be thrown.\r\n  @param structuralTypeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share\r\n  that same short name an exception will be thrown.\r\n  @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.\r\n  @return The EntityType. ComplexType or 'null' if not not found.\r\n  **/\r\n  getAsEntityType(typeName: string, okIfNotFound: boolean = false) {\r\n    const st = this.getStructuralType(typeName, okIfNotFound);\r\n    if (st instanceof EntityType) {\r\n      return st as EntityType;\r\n    } else if (okIfNotFound) {\r\n      return null;\r\n    } else {\r\n      let msg = core.formatString(\"Unable to locate an 'EntityType' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.\", typeName);\r\n      throw new Error(msg);\r\n    }\r\n  }\r\n\r\n  /**\r\n  Returns an [[EntityType]] or null given its name.\r\n  >      // assume em1 is a preexisting EntityManager\r\n  >      let locType = em1.metadataStore.getAsComplexType(\"Location\");\r\n\r\n  or to throw an error if the type is not found\r\n  >      let badType = em1.metadataStore.getAsComplexType(\"Foo\", false);\r\n  >      // badType will not get set and an exception will be thrown.\r\n  @param structuralTypeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share\r\n  that same short name an exception will be thrown.\r\n  @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.\r\n  @return The EntityType. ComplexType or 'null' if not not found.\r\n  **/\r\n getAsComplexType(typeName: string, okIfNotFound: boolean = false) {\r\n  const st = this.getStructuralType(typeName, okIfNotFound);\r\n  if (st instanceof ComplexType) {\r\n    return st as ComplexType;\r\n  } else if (okIfNotFound) {\r\n    return null;\r\n  } else {\r\n    let msg = core.formatString(\"Unable to locate an 'ComplexType' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.\", typeName);\r\n    throw new Error(msg);\r\n  }\r\n}\r\n\r\n\r\n  /**\r\n  Returns an [[EntityType]] or a [[ComplexType]] given its name.\r\n  @deprecated Replaced by getStructuralType but ... it is probably more usefull to call either getAsEntityType or getAsComplexType instead\r\n  @param typeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share\r\n  that same short name an exception will be thrown.\r\n  @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.\r\n  @return The EntityType. ComplexType or 'null' if not not found.\r\n  **/\r\n  getEntityType(typeName: string, okIfNotFound: boolean = false) {\r\n    return this.getStructuralType(typeName, okIfNotFound);\r\n  }\r\n\r\n  /**\r\n  Returns an [[EntityType]] or a [[ComplexType]] given its name.\r\n  >      // assume em1 is a preexisting EntityManager\r\n  >      let odType = em1.metadataStore.getStructuralType(\"OrderDetail\");\r\n\r\n  or to throw an error if the type is not found\r\n  >      let badType = em1.metadataStore.getStructuralType(\"Foo\", false);\r\n  >      // badType will not get set and an exception will be thrown.\r\n  @deprecated Preferably use either getAsEntityType or getAsComplexType.  Get\r\n  @param typeName - Either the fully qualified name or a short name may be used. If a short name is specified and multiple types share\r\n  that same short name an exception will be thrown.\r\n  @param okIfNotFound - (default=false) Whether to throw an error if the specified EntityType is not found.\r\n  @return The EntityType. ComplexType or 'null' if not not found.\r\n  **/\r\n  getStructuralType(typeName: string, okIfNotFound: boolean = false) {\r\n    assertParam(typeName, \"typeName\").isString().check();\r\n    assertParam(okIfNotFound, \"okIfNotFound\").isBoolean().isOptional().check(false);\r\n    return this._getStructuralType(typeName, okIfNotFound);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _getStructuralType(typeName: string, okIfNotFound: boolean = false) {\r\n    let qualTypeName = getQualifiedTypeName(this, typeName, false);\r\n    let type = this._structuralTypeMap[qualTypeName];\r\n    if (!type) {\r\n      if (okIfNotFound) return null;\r\n      let msg = core.formatString(\"Unable to locate a 'Type' by the name: '%1'. Be sure to execute a query or call fetchMetadata first.\", typeName);\r\n      throw new Error(msg);\r\n    }\r\n    return type;\r\n  }\r\n\r\n  /**\r\n  Returns an array containing all of the [[EntityType]]s or [[ComplexType]]s in this MetadataStore.\r\n  >      // assume em1 is a preexisting EntityManager\r\n  >      let allTypes = em1.metadataStore.getEntityTypes();\r\n  **/\r\n  getEntityTypes() {\r\n    return getTypesFromMap(this._structuralTypeMap);\r\n  }\r\n\r\n  getIncompleteNavigationProperties() {\r\n    return core.objectMap(this._incompleteTypeMap, function (key, value) {\r\n      return value;\r\n    });\r\n  }\r\n\r\n  /**\r\n  Returns a fully qualified entityTypeName for a specified resource name.  The reverse of this operation\r\n  can be obtained via the  [[EntityType.defaultResourceName]] property\r\n  **/\r\n  getEntityTypeNameForResourceName(resourceName: string) {\r\n    assertParam(resourceName, \"resourceName\").isString().check();\r\n    return this._resourceEntityTypeMap[resourceName];\r\n  }\r\n\r\n  /**\r\n  Associates a resourceName with an entityType.\r\n\r\n  This method is only needed in those cases where multiple resources return the same\r\n  entityType.  In this case Metadata discovery will only determine a single resource name for\r\n  each entityType.\r\n  @param resourceName - The resource name\r\n  @param entityTypeOrName - If passing a string either the fully qualified name or a short name may be used. If a short name is specified and multiple types share\r\n  that same short name an exception will be thrown. If the entityType has not yet been discovered then a fully qualified name must be used.\r\n  **/\r\n  setEntityTypeForResourceName(resourceName: string, entityTypeOrName: EntityType | string) {\r\n    assertParam(resourceName, \"resourceName\").isString().check();\r\n    assertParam(entityTypeOrName, \"entityTypeOrName\").isInstanceOf(EntityType).or().isString().check();\r\n\r\n    let entityTypeName: string;\r\n    if (entityTypeOrName instanceof EntityType) {\r\n      entityTypeName = entityTypeOrName.name;\r\n    } else {\r\n      entityTypeName = getQualifiedTypeName(this, entityTypeOrName, true);\r\n    }\r\n\r\n    this._resourceEntityTypeMap[resourceName] = entityTypeName;\r\n    let entityType = this._getStructuralType(entityTypeName, true);\r\n    if (entityType && entityType instanceof EntityType && !entityType.defaultResourceName) {\r\n      entityType.defaultResourceName = resourceName;\r\n    }\r\n  }\r\n\r\n  /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */\r\n  static parseTypeName(entityTypeName: string) {\r\n    // TODO: removed \r\n    // if (!entityTypeName) {\r\n    //   return null;\r\n    // }\r\n\r\n    let typeParts = entityTypeName.split(\":#\");\r\n    if (typeParts.length > 1) {\r\n      return MetadataStore.makeTypeHash(typeParts[0], typeParts[1]);\r\n    }\r\n\r\n    if (core.stringStartsWith(entityTypeName, MetadataStore.ANONTYPE_PREFIX)) {\r\n      let typeHash = MetadataStore.makeTypeHash(entityTypeName);\r\n      (typeHash as any).isAnonymous = true;\r\n      return typeHash;\r\n    }\r\n    let entityTypeNameNoAssembly = entityTypeName.split(\",\")[0];\r\n    typeParts = entityTypeNameNoAssembly.split(\".\");\r\n    if (typeParts.length > 1) {\r\n      let shortName = typeParts[typeParts.length - 1];\r\n      let namespaceParts = typeParts.slice(0, typeParts.length - 1);\r\n      let ns = namespaceParts.join(\".\");\r\n      return MetadataStore.makeTypeHash(shortName, ns);\r\n    } else {\r\n      return MetadataStore.makeTypeHash(entityTypeName);\r\n    }\r\n  }\r\n\r\n  /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */\r\n  static makeTypeHash(shortName: string, ns?: string) {\r\n    return {\r\n      shortTypeName: shortName,\r\n      namespace: ns,\r\n      typeName: qualifyTypeName(shortName, ns)\r\n    };\r\n  }\r\n\r\n  // protected methods\r\n  /** @hidden @internal */\r\n  _checkEntityType(entity: Entity) {\r\n    if (entity.entityType) return;\r\n    let typeName = entity.prototype._$typeName;\r\n    if (!typeName) {\r\n      throw new Error(\"This entity has not been registered. See the MetadataStore.registerEntityTypeCtor method\");\r\n    }\r\n    // we know that it is an EntityType ( as opposed to a ComplexType)\r\n    let entityType = this._getStructuralType(typeName) as EntityType;\r\n    if (entityType) {\r\n      entity.entityType = entityType;\r\n    }\r\n  }\r\n\r\n\r\n}\r\nMetadataStore.prototype._$typeName = \"MetadataStore\";\r\n\r\nBreezeEvent.bubbleEvent(MetadataStore.prototype);\r\n\r\nfunction getTypesFromMap(typeMap: IStructuralTypeMap) {\r\n  let types: (StructuralType)[] = [];\r\n  for (let key in typeMap) {\r\n    let value = typeMap[key];\r\n    // skip 'shortName' entries\r\n    if (key === value.name) {\r\n      types.push(typeMap[key]);\r\n    }\r\n  }\r\n  return types;\r\n}\r\n\r\nfunction structuralTypeFromJson(metadataStore: MetadataStore, json: any, allowMerge: boolean) {\r\n  let typeName = qualifyTypeName(json.shortName, json.namespace);\r\n  let stype = metadataStore._getStructuralType(typeName, true);\r\n  if (stype) {\r\n    if (allowMerge) {\r\n      return mergeStructuralType(stype, json);\r\n    } else {\r\n      // allow it but don't replace anything.\r\n      return stype;\r\n    }\r\n  }\r\n  let config = {\r\n    shortName: json.shortName,\r\n    namespace: json.namespace,\r\n    isAbstract: json.isAbstract,\r\n    autoGeneratedKeyType: AutoGeneratedKeyType.fromName(json.autoGeneratedKeyType),\r\n    defaultResourceName: json.defaultResourceName,\r\n    custom: json.custom\r\n  };\r\n\r\n  stype = json.isComplexType ? new ComplexType(config) : new EntityType(config);\r\n\r\n  // baseType may not have been imported yet so we need to defer handling this type until later.\r\n  if (json.baseTypeName && stype instanceof EntityType) {\r\n    stype.baseTypeName = json.baseTypeName;\r\n    let baseEntityType = metadataStore._getStructuralType(json.baseTypeName, true);\r\n    if (baseEntityType) {\r\n      completeStructuralTypeFromJson(metadataStore, json, stype);\r\n    } else {\r\n      core.getArray(metadataStore._deferredTypes, json.baseTypeName).push({ json: json, stype: stype });\r\n\r\n    }\r\n  } else {\r\n    completeStructuralTypeFromJson(metadataStore, json, stype);\r\n  }\r\n\r\n  // stype may or may not have been added to the metadataStore at this point.\r\n  return stype;\r\n}\r\n\r\nfunction mergeStructuralType(stype: StructuralType, json: any) {\r\n  if (json.custom) {\r\n    stype.custom = json.custom;\r\n  }\r\n\r\n  mergeProps(stype, json.dataProperties);\r\n  mergeProps(stype, json.navigationProperties);\r\n  return stype;\r\n}\r\n\r\nfunction mergeProps(stype: StructuralType, jsonProps: any[]) {\r\n  if (!jsonProps) return;\r\n  jsonProps.forEach((jsonProp) => {\r\n    let propName = jsonProp.name;\r\n    if (!propName) {\r\n      if (jsonProp.nameOnServer) {\r\n        propName = stype.metadataStore.namingConvention.serverPropertyNameToClient(jsonProp.nameOnServer, {});\r\n      } else {\r\n        // backslash-quote works around compiler bug\r\n        const msg = \"Unable to complete \\'importMetadata\\' - cannot locate a \\'name\\' or \\'nameOnServer\\' for one of the imported property nodes\";\r\n        throw new Error(msg);\r\n      }\r\n    }\r\n    if (jsonProp.custom) {\r\n      let prop = stype.getProperty(propName, true);\r\n      prop!.custom = jsonProp.custom;\r\n    }\r\n  });\r\n}\r\n\r\nfunction completeStructuralTypeFromJson(metadataStore: MetadataStore, json: any, stype: any) {\r\n\r\n  // validators from baseType work because validation walks thru base types\r\n  // so no need to copy down.\r\n  if (json.validators) {\r\n    stype.validators = json.validators.map(Validator.fromJSON);\r\n  }\r\n\r\n  json.dataProperties.forEach(function (dp: Object) {\r\n    stype._addPropertyCore(DataProperty.fromJSON(dp));\r\n  });\r\n\r\n\r\n  let isEntityType = !json.isComplexType;\r\n  if (isEntityType) {\r\n    //noinspection JSHint\r\n    json.navigationProperties && json.navigationProperties.forEach(function (np: Object) {\r\n      stype._addPropertyCore(NavigationProperty.fromJSON(np));\r\n    });\r\n  }\r\n\r\n  metadataStore.addEntityType(stype);\r\n\r\n  let deferredTypes = metadataStore._deferredTypes;\r\n  let deferrals = deferredTypes[stype.name];\r\n  if (deferrals) {\r\n    deferrals.forEach(function (d: any) {\r\n      completeStructuralTypeFromJson(metadataStore, d.json, d.stype);\r\n    });\r\n    delete deferredTypes[stype.name];\r\n  }\r\n}\r\n\r\nfunction getQualifiedTypeName(metadataStore: MetadataStore, structTypeName: string, throwIfNotFound?: boolean) {\r\n  if (isQualifiedTypeName(structTypeName)) return structTypeName;\r\n  let result = metadataStore._shortNameMap[structTypeName];\r\n  if (!result && throwIfNotFound) {\r\n    throw new Error(\"Unable to locate 'entityTypeName' of: \" + structTypeName);\r\n  }\r\n  return result;\r\n}\r\n\r\n/** Configuration info to be passed to the [[EntityType]] constructor */\r\nexport interface EntityTypeConfig {\r\n  shortName?: string;\r\n  namespace?: string;\r\n  baseTypeName?: string;\r\n  isAbstract?: boolean;\r\n  autoGeneratedKeyType?: AutoGeneratedKeyType;\r\n  defaultResourceName?: string;\r\n  dataProperties?: DataProperty[] | Object[] | Object;  // TODO: see if we can't qualify Object[] a little better.\r\n  navigationProperties?: NavigationProperty[] | Object[] | Object;\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n  custom?: any;\r\n}\r\n\r\n/** Configuration info to be passed to the [[EntityType.setProperties]] method */\r\nexport interface EntityTypeSetConfig {\r\n  autoGeneratedKeyType?: AutoGeneratedKeyType;\r\n  defaultResourceName?: string;\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n  custom?: any;\r\n}\r\n\r\n/** Container for all of the metadata about a specific type of Entity.\r\n**/\r\nexport class EntityType {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on proto\r\n  /** @hidden @internal */\r\n  static __nextAnonIx = 0;\r\n  /** Always false for an EntityType. **/\r\n  isComplexType = false;\r\n  /** The [[MetadataStore]] that contains this EntityType. __Read Only__ **/\r\n  metadataStore: MetadataStore;\r\n  /** The DataProperties (see [[DataProperty]] associated with this EntityType. __Read Only__  **/\r\n  dataProperties: DataProperty[];\r\n  /**  The NavigationProperties (see [[NavigationProperty]] associated with this EntityType. __Read Only__  **/\r\n  navigationProperties: NavigationProperty[];\r\n  /**\r\n  The DataProperties associated with this EntityType that make up it's [[EntityKey]]. __Read Only__ **/\r\n  keyProperties: DataProperty[];\r\n  /** The DataProperties associated with this EntityType that are foreign key properties. __Read Only__ **/\r\n  foreignKeyProperties: DataProperty[];\r\n  inverseForeignKeyProperties: DataProperty[];\r\n  /**  The DataProperties associated with this EntityType that are concurrency properties. __Read Only__ **/\r\n  concurrencyProperties: DataProperty[];\r\n  /** The DataProperties for this EntityType that contain instances of a [[ComplexType]]. __Read Only__   **/\r\n  complexProperties: DataProperty[];\r\n  /** The DataProperties associated with this EntityType that are not mapped to any backend datastore. These are effectively free standing\r\n  properties. __Read Only__ **/\r\n  unmappedProperties: DataProperty[];\r\n\r\n  /** The fully qualified name of this EntityType. __Read Only__  **/\r\n  name: string;\r\n  /** The short, unqualified, name for this EntityType. __Read Only__  **/\r\n  shortName: string;\r\n  /** The namespace for this EntityType. __Read Only__  **/\r\n  namespace: string;\r\n  /** The name of this EntityType's base EntityType  (if any) */\r\n  baseTypeName?: string;\r\n  /** The base EntityType (if any) for this EntityType. __Read Only__   **/\r\n  baseEntityType: EntityType;\r\n  subtypes: EntityType[];\r\n\r\n  /**  Whether this EntityType is abstract. __Read Only__ **/\r\n  isAbstract: boolean;\r\n  /**  Whether this EntityType is anonymous. Anonymous types will never be communicated to or from the server. They are purely for\r\n  client side use and are given an automatically generated name.  __Read Only__ **/\r\n  isAnonymous: boolean;\r\n  /** Whether this EntityType has been 'frozen'.  EntityTypes become frozen after the first instance \r\n  of that type has been created and attached to an EntityManager. */\r\n  isFrozen: boolean;\r\n\r\n  /** The [[AutoGeneratedKeyType]] for this EntityType. __Read Only__ **/\r\n  autoGeneratedKeyType: AutoGeneratedKeyType;\r\n  /**   The default resource name associated with this EntityType.  An EntityType may be queried via a variety of 'resource names' but this one\r\n  is used as the default when no resource name is provided.  This will occur when calling [[EntityAspect.loadNavigationProperty]]\r\n  or when executing any [[EntityQuery]] that was created via an [[EntityKey]]. __Read Only__ **/\r\n  defaultResourceName: string;\r\n  /** A function that is used to customize the serialization of any EntityProperties of this type. */\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n  /**  A free form object that can be used to define any custom metadata for this EntityType. __Read Only__  **/\r\n  custom?: any;\r\n  /** The entity level validators associated with this EntityType. Validators can be added and\r\n  removed from this collection. __Read Only__.   **/\r\n  validators: Validator[];\r\n\r\n  warnings: any[];\r\n  initFn: Function | string;\r\n  noTrackingFn: Function;\r\n\r\n  /** @hidden @internal */\r\n  _extra: any;\r\n  /** @hidden @internal */\r\n  _ctor: { new (): StructuralObject };\r\n  /** @hidden @internal */\r\n  _mappedPropertiesCount: number;\r\n\r\n  /** \r\n  @deprecated Use [[getCtor]] instead.   \r\n  */\r\n  getEntityCtor = this.getCtor;\r\n\r\n  /** @hidden @internal */\r\n  static qualifyTypeName = qualifyTypeName;\r\n\r\n\r\n  /** EntityType constructor  \r\n  >      let entityType = new EntityType( {\r\n  >          shortName: \"person\",\r\n  >          namespace: \"myAppNamespace\"\r\n  >      });\r\n  @param config - Configuration settings or a MetadataStore.  If this parameter is just a MetadataStore\r\n  then what will be created is an 'anonymous' type that will never be communicated to or from the server. It is purely for\r\n  client side use and will be given an automatically generated name. Normally, however, you will use a configuration object.\r\n  **/\r\n  constructor(config: MetadataStore | EntityTypeConfig) {\r\n    if (arguments.length > 1) {\r\n      throw new Error(\"The EntityType ctor has a single argument that is either a 'MetadataStore' or a configuration object.\");\r\n    }\r\n    // let etConfig =  <EntityTypeConfig> <any> undefined;\r\n    let etConfig: EntityTypeConfig | undefined = undefined;\r\n\r\n    if ((config as any)._$typeName === \"MetadataStore\") {\r\n      this.metadataStore = config as MetadataStore;\r\n      this.shortName = \"Anon_\" + (++EntityType.__nextAnonIx);\r\n      this.namespace = \"\";\r\n      this.isAnonymous = true;\r\n      // etConfig = undefined;\r\n    } else {\r\n      etConfig = config as EntityTypeConfig;\r\n      assertConfig(config)\r\n        .whereParam(\"shortName\").isNonEmptyString()\r\n        .whereParam(\"namespace\").isString().isOptional().withDefault(\"\")\r\n        .whereParam(\"baseTypeName\").isString().isOptional()\r\n        .whereParam(\"isAbstract\").isBoolean().isOptional().withDefault(false)\r\n        .whereParam(\"autoGeneratedKeyType\").isEnumOf(AutoGeneratedKeyType).isOptional().withDefault(AutoGeneratedKeyType.None)\r\n        .whereParam(\"defaultResourceName\").isNonEmptyString().isOptional().withDefault(null)\r\n        .whereParam(\"dataProperties\").isOptional()\r\n        .whereParam(\"navigationProperties\").isOptional()\r\n        .whereParam(\"serializerFn\").isOptional().isFunction()\r\n        .whereParam(\"custom\").isOptional()\r\n        .applyAll(this);\r\n    }\r\n\r\n    this.name = qualifyTypeName(this.shortName, this.namespace);\r\n\r\n    // the defaultResourceName may also be set up either via metadata lookup or first query or via the 'setProperties' method\r\n    this.dataProperties = [];\r\n    this.navigationProperties = [];\r\n    this.complexProperties = [];\r\n    this.keyProperties = [];\r\n    this.foreignKeyProperties = [];\r\n    this.inverseForeignKeyProperties = [];\r\n    this.concurrencyProperties = [];\r\n    this.unmappedProperties = []; // will be updated later.\r\n    this.validators = [];\r\n    this.warnings = [];\r\n    this._mappedPropertiesCount = 0;\r\n    this.subtypes = [];\r\n    // now process any data/nav props\r\n    if (etConfig && etConfig.dataProperties) {\r\n      addProperties(this, etConfig.dataProperties, DataProperty);\r\n    }\r\n    if (etConfig && etConfig.navigationProperties) {\r\n      addProperties(this, etConfig.navigationProperties, NavigationProperty);\r\n    }\r\n  }\r\n\r\n  /**\r\n  General purpose property set method\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      custType.setProperties( {\r\n  >          autoGeneratedKeyType: AutoGeneratedKeyType.Identity;\r\n  >          defaultResourceName: \"CustomersAndIncludedOrders\"\r\n  >      )};\r\n  @param config - a configuration object\r\n  **/\r\n  setProperties(config: EntityTypeSetConfig) {\r\n    assertConfig(config)\r\n      .whereParam(\"autoGeneratedKeyType\").isEnumOf(AutoGeneratedKeyType).isOptional()\r\n      .whereParam(\"defaultResourceName\").isString().isOptional()\r\n      .whereParam(\"serializerFn\").isFunction().isOptional()\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n    if (config.defaultResourceName) {\r\n      this.defaultResourceName = config.defaultResourceName;\r\n    }\r\n  }\r\n\r\n  /**\r\n  Returns whether this type is a subtype of a specified type.\r\n  **/\r\n  isSubtypeOf(entityType: EntityType) {\r\n    assertParam(entityType, \"entityType\").isInstanceOf(EntityType).check();\r\n    let baseType: EntityType = this;\r\n    do {\r\n      if (baseType === entityType) return true;\r\n      baseType = baseType.baseEntityType;\r\n    } while (baseType);\r\n    return false;\r\n  }\r\n\r\n  /**\r\n  Returns an array containing this type and any/all subtypes of this type down thru the hierarchy.\r\n  **/\r\n  getSelfAndSubtypes() {\r\n    let result = [this];\r\n    this.subtypes.forEach(function (st) {\r\n      let subtypes = st.getSelfAndSubtypes();\r\n      result.push.apply(result, subtypes);\r\n    });\r\n    return result;\r\n  }\r\n\r\n  getAllValidators() {\r\n    let result = this.validators.slice(0);\r\n    let bt = this.baseEntityType;\r\n    while (bt) {\r\n      result.push.apply(result, bt.validators);\r\n      bt = bt.baseEntityType;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n  Adds a  [[DataProperty]] or a [[NavigationProperty]] to this EntityType.\r\n  >      // assume myEntityType is a newly constructed EntityType.\r\n  >      myEntityType.addProperty(dataProperty1);\r\n  >      myEntityType.addProperty(dataProperty2);\r\n  >      myEntityType.addProperty(navigationProperty1);\r\n  **/\r\n  addProperty(property: EntityProperty) {\r\n    assertParam(property, \"property\").isInstanceOf(DataProperty).or().isInstanceOf(NavigationProperty).check();\r\n\r\n    // true is 2nd arg to force resolve of any navigation properties.\r\n    let newprop = this._addPropertyCore(property, true);\r\n\r\n    if (this.subtypes && this.subtypes.length) {\r\n      let stype = this;\r\n      stype.getSelfAndSubtypes().forEach(function (st) {\r\n        if (st !== stype) {\r\n          if (property.isNavigationProperty) {\r\n            st._addPropertyCore(new NavigationProperty(property), true);\r\n          } else {\r\n            st._addPropertyCore(new DataProperty(property as DataProperty), true);\r\n          }\r\n        }\r\n      });\r\n    }\r\n    return newprop;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateFromBase(baseEntityType: EntityType) {\r\n    this.baseEntityType = baseEntityType;\r\n    if (this.autoGeneratedKeyType === AutoGeneratedKeyType.None) {\r\n      this.autoGeneratedKeyType = baseEntityType.autoGeneratedKeyType;\r\n    }\r\n\r\n    baseEntityType.dataProperties.forEach((dp) => {\r\n      let newDp = new DataProperty(dp);\r\n      // don't need to copy validators becaue we will walk the hierarchy to find them\r\n      newDp.validators = [];\r\n      newDp.baseProperty = dp;\r\n      this._addPropertyCore(newDp);\r\n    }, this);\r\n    baseEntityType.navigationProperties.forEach((np) => {\r\n      let newNp = new NavigationProperty(np);\r\n      // don't need to copy validators becaue we will walk the hierarchy to find them\r\n      newNp.validators = [];\r\n      newNp.baseProperty = np;\r\n      this._addPropertyCore(newNp);\r\n    }, this);\r\n    baseEntityType.subtypes.push(this);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _addPropertyCore(property: EntityProperty, shouldResolve: boolean = false) {\r\n    if (this.isFrozen) {\r\n      throw new Error(\"The '\" + this.name + \"' EntityType/ComplexType has been frozen. You can only add properties to an EntityType/ComplexType before any instances of that type have been created and attached to an entityManager.\");\r\n    }\r\n    let parentType = property.parentType;\r\n    if (parentType) {\r\n      if (parentType !== this) {\r\n        throw new Error(\"This property: \" + property.name + \" has already been added to \" + property.parentType.name);\r\n      } else {\r\n        // adding the same property more than once to the same entityType is just ignored.\r\n        return;\r\n      }\r\n    }\r\n    property.parentType = this;\r\n    let ms = this.metadataStore;\r\n    // if (property.isDataProperty) { // modified because doesn't act as a type guard \r\n    if (property instanceof DataProperty) {\r\n      this._addDataProperty(property);\r\n    } else {\r\n      this._addNavigationProperty(property);\r\n      // metadataStore can be undefined if this entityType has not yet been added to a MetadataStore.\r\n      if (shouldResolve && ms) {\r\n        tryResolveNp(property, ms);\r\n      }\r\n    }\r\n    // unmapped properties can be added AFTER entityType has already resolved all property names.\r\n    if (ms && !(property.name && property.nameOnServer)) {\r\n      updateClientServerNames(ms.namingConvention, property, \"name\");\r\n    }\r\n    // props can be added after entity prototype has already been wrapped.\r\n    if (ms && this._extra) {\r\n      if (this._extra.alreadyWrappedProps) {\r\n        let proto = this._ctor.prototype;\r\n        config.interfaceRegistry.modelLibrary.getDefaultInstance().initializeEntityPrototype(proto);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n  Create a new entity of this type.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getAsEntityType(\"Customer\");\r\n  >      let cust1 = custType.createEntity();\r\n  >      em1.addEntity(cust1);\r\n  @param initialValues- Configuration object of the properties to set immediately after creation.\r\n  @return The new entity.\r\n  **/\r\n  createEntity(initialValues?: any): any {\r\n    // ignore the _$eref once the entity is attached to an entityManager.\r\n    if (initialValues && initialValues._$eref && !initialValues._$eref.entityAspect.entityManager) return initialValues._$eref;\r\n\r\n    let instance = this._createInstanceCore();\r\n\r\n    if (initialValues) {\r\n      // only assign an _eref if the object is fully \"keyed\"\r\n      if (this.keyProperties.every(function (kp) {\r\n        return initialValues[kp.name] != null;\r\n      })) {\r\n        initialValues._$eref = instance;\r\n      }\r\n\r\n      this._updateTargetFromRaw(instance, initialValues, getRawValueFromConfig);\r\n\r\n      this.navigationProperties.forEach(function (np) {\r\n        let relatedEntity: any;\r\n        let val = initialValues[np.name];\r\n        if (val != undefined) {\r\n          let navEntityType = np.entityType;\r\n          if (np.isScalar) {\r\n            relatedEntity = val.entityAspect ? val : navEntityType.createEntity(val);\r\n            instance.setProperty(np.name, relatedEntity);\r\n          } else {\r\n            let relatedEntities = instance.getProperty(np.name);\r\n            val.forEach((v: any) => {\r\n              relatedEntity = v.entityAspect ? v : navEntityType.createEntity(v);\r\n              relatedEntities.push(relatedEntity);\r\n            });\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    this._initializeInstance(instance);\r\n    return instance;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _createInstanceCore() {\r\n    let aCtor = this.getCtor();\r\n    let instance = new aCtor();\r\n    new EntityAspect(instance as Entity);\r\n    return instance;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _initializeInstance(instance: any) {\r\n    if (this.baseEntityType) {\r\n      this.baseEntityType._initializeInstance(instance);\r\n    }\r\n    let initFn = this.initFn;\r\n    if (initFn) {\r\n      let fn = (typeof initFn === \"string\") ? instance[initFn] : initFn;\r\n      fn(instance);\r\n    }\r\n    this.complexProperties && this.complexProperties.forEach(function (cp) {\r\n      let complexType = cp.dataType as ComplexType;\r\n      let ctInstance = instance.getProperty(cp.name);\r\n      if (Array.isArray(ctInstance)) {\r\n        ctInstance.forEach((ctInst) => {\r\n          complexType._initializeInstance(ctInst);\r\n        });\r\n      } else {\r\n        complexType._initializeInstance(ctInstance);\r\n      }\r\n    });\r\n    // not needed for complexObjects\r\n    if (instance.entityAspect) {\r\n      instance.entityAspect._initialized = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n  Returns the constructor for this EntityType.\r\n  @param forceRefresh - Whether to ignore any cached version of this constructor. (default == false)\r\n  @return The constructor for this EntityType.\r\n  **/\r\n  getCtor(forceRefresh: boolean = false): { new (): StructuralObject } {\r\n    if (this._ctor && !forceRefresh) return this._ctor;\r\n\r\n    let ctorRegistry = this.metadataStore._ctorRegistry;\r\n    let r = ctorRegistry[this.name] || ctorRegistry[this.shortName] || {} as CtorRecord;\r\n    let aCtor = r.ctor || this._ctor;\r\n\r\n    let ctorType = aCtor && aCtor.prototype && (aCtor.prototype.entityType || aCtor.prototype.complexType);\r\n    if (ctorType && ctorType.metadataStore !== this.metadataStore) {\r\n      // We can't risk a mismatch between the ctor and the type info in a specific metadatastore\r\n      // because modelLibraries rely on type info to intercept ctor properties\r\n      throw new Error(\"Cannot register the same constructor for \" + this.name + \" in different metadata stores.  Please define a separate constructor for each metadata store.\");\r\n    }\r\n\r\n\r\n    if (r.ctor && forceRefresh) {\r\n      this._extra = undefined;\r\n    }\r\n\r\n    if (!aCtor) {\r\n      let createCtor = config.interfaceRegistry.modelLibrary.getDefaultInstance().createCtor;\r\n      aCtor = createCtor ? createCtor(this) : createEmptyCtor(this);\r\n    }\r\n\r\n    this.initFn = r.initFn;\r\n    this.noTrackingFn = r.noTrackingFn;\r\n\r\n    aCtor.prototype._$typeName = this.name;\r\n    this._setCtor(aCtor);\r\n    return aCtor;\r\n  }\r\n\r\n\r\n  /** @hidden @internal */\r\n  // May make public later.\r\n  _setCtor(aCtor: { new (): StructuralObject }, interceptor?: any) {\r\n\r\n    let instanceProto = aCtor.prototype;\r\n\r\n    // place for extra breeze related data\r\n    this._extra = this._extra || {};\r\n\r\n    let instance = new aCtor();\r\n    calcUnmappedProperties(this, instance);\r\n\r\n    if (this._$typeName === \"EntityType\") {\r\n      // insure that all of the properties are on the 'template' instance before watching the class.\r\n      instanceProto.entityType = this;\r\n    } else {\r\n      instanceProto.complexType = this;\r\n    }\r\n\r\n    // defaultPropertyInterceptor is a 'global' (but internal to breeze) function;\r\n    (instanceProto as any)._$interceptor = interceptor || defaultPropertyInterceptor;\r\n    config.interfaceRegistry.modelLibrary.getDefaultInstance().initializeEntityPrototype(instanceProto);\r\n    this._ctor = aCtor;\r\n  }\r\n\r\n  /**\r\n  Adds either an entity or property level validator to this EntityType.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let countryProp = custType.getProperty(\"Country\");\r\n  >      let valFn = function (v) {\r\n  >              if (v == null) return true;\r\n  >              return (core.stringStartsWith(v, \"US\"));\r\n  >          };\r\n  >      let countryValidator = new Validator(\"countryIsUS\", valFn,\r\n  >      { displayName: \"Country\", messageTemplate: \"'%displayName%' must start with 'US'\" });\r\n  >      custType.addValidator(countryValidator, countryProp);\r\n\r\n  This is the same as adding an entity level validator via the 'validators' property of DataProperty or NavigationProperty\r\n  >      countryProp.validators.push(countryValidator);\r\n\r\n  Entity level validators can also be added by omitting the 'property' parameter.\r\n  >      custType.addValidator(someEntityLevelValidator);\r\n\r\n  or\r\n  >      custType.validators.push(someEntityLevelValidator);\r\n  @param validator - Validator to add.\r\n  @param property - Property to add this validator to.  If omitted, the validator is assumed to be an\r\n  entity level validator and is added to the EntityType's 'validators'.\r\n  **/\r\n  addValidator(validator: Validator, property?: EntityProperty | string) {\r\n    assertParam(validator, \"validator\").isInstanceOf(Validator).check();\r\n    assertParam(property, \"property\").isOptional().isString().or().isEntityProperty().check();\r\n    if (property != null) {\r\n      let prop = (typeof property === 'string') ? this.getProperty(property, true) : property;\r\n      prop!.validators.push(validator);\r\n    } else {\r\n      this.validators.push(validator);\r\n    }\r\n  }\r\n\r\n  /**\r\n  Returns all of the properties ( dataProperties and navigationProperties) for this EntityType.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let arrayOfProps = custType.getProperties();\r\n  @return An array of Data and Navigation properties.\r\n  **/\r\n  getProperties(): EntityProperty[] {\r\n    return (this.dataProperties as EntityProperty[]).concat(this.navigationProperties);\r\n  }\r\n\r\n  /**\r\n  Returns all of the property names ( for both dataProperties and navigationProperties) for this EntityType.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let arrayOfPropNames = custType.getPropertyNames();\r\n  **/\r\n  getPropertyNames() {\r\n    return this.getProperties().map(core.pluck('name'));\r\n  }\r\n\r\n  /**\r\n  Returns a data property with the specified name or null.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let customerNameDataProp = custType.getDataProperty(\"CustomerName\");\r\n  @return A DataProperty or null if not found.\r\n  **/\r\n  getDataProperty(propertyName: string) {\r\n    return core.arrayFirst(this.dataProperties, core.propEq('name', propertyName));\r\n  }\r\n\r\n  /**\r\n  Returns a navigation property with the specified name or null.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let customerOrdersNavProp = custType.getDataProperty(\"Orders\");\r\n  @return A NavigationProperty or null if not found.\r\n  **/\r\n  getNavigationProperty(propertyName: string) {\r\n    return core.arrayFirst(this.navigationProperties, core.propEq('name', propertyName));\r\n  }\r\n\r\n  /**\r\n  Returns either a DataProperty or a NavigationProperty with the specified name or null.\r\n  \r\n  This method also accepts a '.' delimited property path and will return the 'property' at the\r\n  end of the path.\r\n  >      let custType = em1.metadataStore.getEntityType(\"Customer\");\r\n  >      let companyNameProp = custType.getProperty(\"CompanyName\");\r\n\r\n  This method can also walk a property path to return a property\r\n  >      let orderDetailType = em1.metadataStore.getEntityType(\"OrderDetail\");\r\n  >      let companyNameProp2 = orderDetailType.getProperty(\"Order.Customer.CompanyName\");\r\n  >      // companyNameProp === companyNameProp2\r\n  @param [throwIfNotFound=false] {Boolean} Whether to throw an exception if not found.\r\n  @return A DataProperty or NavigationProperty or null if not found.\r\n  **/\r\n  getProperty(propertyPath: string, throwIfNotFound: boolean = false) {\r\n    let props = this.getPropertiesOnPath(propertyPath, false, throwIfNotFound);\r\n    return (props && props.length > 0) ? props[props.length - 1] : null;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  // TODO: have this return empty array instead of null and fix consumers.\r\n  // TODO: think about renaming with '_' prefix.\r\n  getPropertiesOnPath(propertyPath: string, useServerName: boolean | null, throwIfNotFound: boolean = false) {\r\n    let propertyNames: string[] = (Array.isArray(propertyPath)) ? propertyPath : propertyPath.trim().split('.');\r\n\r\n    let ok = true;\r\n    let key = useServerName === true ? \"nameOnServer\" : useServerName === false ? \"name\" : null;\r\n    let parentType = this as StructuralType;\r\n    \r\n    const getProps = (propName: string) => { \r\n      const fn = key === null ? core.propsEq(\"name\", \"nameOnServer\", propName) : core.propEq(key, propName);\r\n      let prop = core.arrayFirst(parentType.getProperties(), fn);\r\n      if (prop) {\r\n        parentType = (prop instanceof NavigationProperty) ? prop.entityType : prop.dataType as ComplexType;\r\n        // parentType = prop.isNavigationProperty ? prop.entityType : prop.dataType;\r\n      } else if (throwIfNotFound) {\r\n        throw new Error(\"unable to locate property: \" + propName + \" on entityType: \" + parentType.name);\r\n      } else {\r\n        ok = false;\r\n      }\r\n      return prop;\r\n    };\r\n\r\n    let props = propertyNames.map(getProps) as EntityProperty[];\r\n    return ok ? props : null;\r\n  }\r\n\r\n  /** For use in pluggable adapters. */\r\n  // TODO: document use\r\n  clientPropertyPathToServer(propertyPath: string, delimiter: string = '.') {\r\n    let propNames: string[];\r\n    if (this.isAnonymous) {\r\n      let fn = this.metadataStore.namingConvention.clientPropertyNameToServer;\r\n      propNames = propertyPath.split(\".\").map(function (propName) {\r\n        return fn(propName);\r\n      });\r\n    } else {\r\n      let props = this.getPropertiesOnPath(propertyPath, false, true);\r\n      propNames = props!.map((prop: EntityProperty) => prop.nameOnServer);\r\n    }\r\n    return propNames.join(delimiter);\r\n  }\r\n\r\n  /** For use in pluggable adapters. */\r\n  // TODO: document use\r\n  getEntityKeyFromRawEntity(rawEntity: any, rawValueFn: Function) {\r\n    let keyValues = this.keyProperties.map((dp) => {\r\n      let val = rawValueFn(rawEntity, dp);\r\n      return DataType.parseRawValue(val, dp.dataType as DataType);\r\n    });\r\n    return new EntityKey(this, keyValues);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateTargetFromRaw(target: StructuralObject, raw: any, rawValueFn: Function) {\r\n    // called recursively for complex properties\r\n    this.dataProperties.forEach((dp) => {\r\n      if (!dp.isSettable) return;\r\n      let rawVal = rawValueFn(raw, dp);\r\n      if (rawVal === undefined) return;\r\n      let dataType = dp.dataType; // this will be a complexType when dp is a complexProperty\r\n      let oldVal: any;\r\n      if (dp.isComplexProperty) {\r\n        let complexType = dp.dataType as ComplexType;\r\n        if (rawVal === null) return; // rawVal may be null in nosql dbs where it was never defined for the given row.\r\n        oldVal = target.getProperty(dp.name);\r\n        if (dp.isScalar) {\r\n          complexType._updateTargetFromRaw(oldVal, rawVal, rawValueFn);\r\n        } else {\r\n          if (Array.isArray(rawVal)) {\r\n            let newVal = rawVal.map(function (rawCo) {\r\n              let newCo = complexType._createInstanceCore(target, dp);\r\n              complexType._updateTargetFromRaw(newCo, rawCo, rawValueFn);\r\n              complexType._initializeInstance(newCo);\r\n              return newCo;\r\n            });\r\n            if (!core.arrayEquals(oldVal, newVal, coEquals)) {\r\n              // clear the old array and push new objects into it.\r\n              oldVal.length = 0;\r\n              newVal.forEach(function (nv) {\r\n                oldVal.push(nv);\r\n              });\r\n            }\r\n          } else {\r\n            oldVal.length = 0;\r\n          }\r\n        }\r\n      } else {\r\n        if (dp.isScalar) {\r\n          let newVal = DataType.parseRawValue(rawVal, dataType as DataType);\r\n          target.setProperty(dp.name, newVal);\r\n        } else {\r\n          oldVal = target.getProperty(dp.name);\r\n          if (Array.isArray(rawVal)) {\r\n            // need to compare values\r\n            let newVal = rawVal.map((rv) => {\r\n              return DataType.parseRawValue(rv, dataType as DataType);\r\n            });\r\n            if (!core.arrayEquals(oldVal, newVal)) {\r\n              // clear the old array and push new objects into it.\r\n              oldVal.length = 0;\r\n              newVal.forEach(function (nv) {\r\n                oldVal.push(nv);\r\n              });\r\n            }\r\n          } else {\r\n            oldVal.length = 0;\r\n          }\r\n\r\n        }\r\n      }\r\n    });\r\n\r\n    // if merging from an import then raw will have an entityAspect or a complexAspect\r\n    let rawAspect = raw.entityAspect || raw.complexAspect;\r\n    if (rawAspect) {\r\n\r\n      let targetAspect = EntityAspect.isEntity(target) ? target.entityAspect : target.complexAspect;\r\n      if (rawAspect.originalValuesMap) {\r\n        targetAspect.originalValues = rawAspect.originalValuesMap;\r\n      }\r\n      if (rawAspect.extraMetadata) {\r\n        targetAspect.extraMetadata = rawAspect.extraMetadata;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n\r\n  /**\r\n  Returns a string representation of this EntityType.\r\n  **/\r\n  toString() {\r\n    return this.name;\r\n  }\r\n\r\n  toJSON() {\r\n    return core.toJson(this, {\r\n      shortName: null,\r\n      namespace: null,\r\n      baseTypeName: null,\r\n      isAbstract: false,\r\n      autoGeneratedKeyType: null, // do not suppress default value\r\n      defaultResourceName: null,\r\n      dataProperties: localPropsOnly,\r\n      navigationProperties: localPropsOnly,\r\n      validators: null,\r\n      custom: null\r\n    });\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateNames(property: EntityProperty) {\r\n    let nc = this.metadataStore.namingConvention;\r\n    updateClientServerNames(nc, property, \"name\");\r\n\r\n    if (property.isNavigationProperty) {\r\n      updateClientServerNames(nc, property, \"foreignKeyNames\");\r\n      updateClientServerNames(nc, property, \"invForeignKeyNames\");\r\n\r\n      // these will get set later via _updateNps\r\n      // this.inverse\r\n      // this.entityType\r\n      // this.relatedDataProperties\r\n      //    dataProperty.relatedNavigationProperty\r\n      //    dataProperty.inverseNavigationProperty\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _checkNavProperty(navigationProperty: NavigationProperty | string) {\r\n    // if (navigationProperty.isNavigationProperty) {\r\n    if (navigationProperty instanceof NavigationProperty) {\r\n      if (navigationProperty.parentType !== this) {\r\n        throw new Error(core.formatString(\"The navigationProperty '%1' is not a property of entity type '%2'\",\r\n          navigationProperty.name, this.name));\r\n      }\r\n      return navigationProperty;\r\n    }\r\n\r\n    if (typeof (navigationProperty) === 'string') {\r\n      let np = this.getProperty(navigationProperty);\r\n      // if (np && np.isNavigationProperty) return np;\r\n      if (np && np instanceof NavigationProperty) return np;\r\n    }\r\n    throw new Error(\"The 'navigationProperty' parameter must either be a NavigationProperty or the name of a NavigationProperty\");\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _addDataProperty(dp: DataProperty) {\r\n\r\n    this.dataProperties.push(dp);\r\n\r\n    if (dp.isPartOfKey) {\r\n      this.keyProperties.push(dp);\r\n    }\r\n\r\n    if (dp.isComplexProperty) {\r\n      this.complexProperties.push(dp);\r\n    }\r\n\r\n    if (dp.concurrencyMode && dp.concurrencyMode !== \"None\") {\r\n      this.concurrencyProperties.push(dp);\r\n    }\r\n\r\n    if (dp.isUnmapped) {\r\n      this.unmappedProperties.push(dp);\r\n    }\r\n\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _addNavigationProperty(np: NavigationProperty) {\r\n\r\n    this.navigationProperties.push(np);\r\n\r\n    if (!isQualifiedTypeName(np.entityTypeName)) {\r\n      np.entityTypeName = qualifyTypeName(np.entityTypeName, this.namespace);\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateCps() {\r\n    let metadataStore = this.metadataStore;\r\n    let incompleteTypeMap = metadataStore._incompleteComplexTypeMap;\r\n    this.complexProperties.forEach(function (cp) {\r\n      if (cp.complexType) return;\r\n      if (!resolveCp(cp, metadataStore)) {\r\n        core.getArray(incompleteTypeMap, cp.complexTypeName).push(cp);\r\n      }\r\n    });\r\n\r\n    if (this.isComplexType) {\r\n      (incompleteTypeMap[this.name] || []).forEach(function (cp: DataProperty) {\r\n        resolveCp(cp, metadataStore);\r\n      });\r\n      delete incompleteTypeMap[this.name];\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _updateNps() {\r\n    let metadataStore = this.metadataStore;\r\n\r\n    // resolve all navProps for this entityType\r\n    this.navigationProperties.forEach(function (np) {\r\n      tryResolveNp(np, metadataStore);\r\n    });\r\n    let incompleteTypeMap = metadataStore._incompleteTypeMap;\r\n    // next resolve all navProp that point to this entityType.\r\n    (incompleteTypeMap[this.name] || []).forEach(function (np: NavigationProperty) {\r\n      tryResolveNp(np, metadataStore);\r\n    });\r\n    // every navProp that pointed to this type should now be resolved\r\n    delete incompleteTypeMap[this.name];\r\n  }\r\n}\r\n\r\nEntityType.prototype._$typeName = \"EntityType\";\r\n\r\nfunction getRawValueFromConfig(rawEntity: any, dp: DataProperty) {\r\n  // 'true' fork can happen if an initializer contains an actaul instance of an already created complex object.\r\n  return (rawEntity.entityAspect || rawEntity.complexAspect) ? rawEntity.getProperty(dp.name) : rawEntity[dp.name];\r\n}\r\n\r\nfunction updateClientServerNames(nc: NamingConvention, parent: any, clientPropName: string) {\r\n  let serverPropName = clientPropName + \"OnServer\";\r\n  let clientName = parent[clientPropName];\r\n  if (clientName && clientName.length) {\r\n    // if (parent.isUnmapped) return;\r\n    let serverNames = core.toArray(clientName).map(function (cName) {\r\n      let sName = nc.clientPropertyNameToServer(cName, parent);\r\n      let testName = nc.serverPropertyNameToClient(sName, parent);\r\n      if (cName !== testName) {\r\n        throw new Error(\"NamingConvention for this client property name does not roundtrip properly:\" + cName + \"-->\" + testName);\r\n      }\r\n      return sName;\r\n    });\r\n    parent[serverPropName] = Array.isArray(clientName) ? serverNames : serverNames[0];\r\n  } else {\r\n    let serverName = parent[serverPropName];\r\n    if ((!serverName) || serverName.length === 0) return;\r\n    let clientNames = core.toArray(serverName).map(function (sName) {\r\n      let cName = nc.serverPropertyNameToClient(sName, parent);\r\n      let testName = nc.clientPropertyNameToServer(cName, parent);\r\n      if (sName !== testName) {\r\n        throw new Error(\"NamingConvention for this server property name does not roundtrip properly:\" + sName + \"-->\" + testName);\r\n      }\r\n      return cName;\r\n    });\r\n    parent[clientPropName] = Array.isArray(serverName) ? clientNames : clientNames[0];\r\n  }\r\n}\r\n\r\nfunction createEmptyCtor(type: any) {\r\n  if (config.noEval) {\r\n    let Entity = function() {};\r\n    return Entity;\r\n  } else {\r\n    let name = type.name.replace(/\\W/g, '_');\r\n    return Function('return function ' + name + '(){}')();\r\n  }\r\n}\r\n\r\nfunction coEquals(co1: ComplexObject, co2: ComplexObject): boolean {\r\n  let complexType = co1.complexAspect!.parentProperty!.dataType as ComplexType;\r\n  let dataProps = complexType.dataProperties;\r\n  let areEqual = dataProps.every(function (dp) {\r\n    if (!dp.isSettable) return true;\r\n    let v1 = co1.getProperty(dp.name);\r\n    let v2 = co2.getProperty(dp.name);\r\n    if (dp.isComplexProperty && dp.isScalar) {\r\n      return coEquals(v1, v2);\r\n    }\r\n    else if (dp.isComplexProperty && !dp.isScalar) {\r\n      return core.arrayEquals(v1, v2, coEquals);\r\n    } else {\r\n      let dataType = <any>dp.dataType; // this will be a complexType when dp is a complexProperty\r\n      return (v1 === v2 || (dataType && dataType.normalize && v1 && v2 && dataType.normalize(v1) === dataType.normalize(v2)));\r\n    }\r\n  });\r\n  return areEqual;\r\n}\r\n\r\nfunction localPropsOnly(props: EntityProperty[]) {\r\n  return props.filter(function (prop) {\r\n    return prop.baseProperty == null;\r\n  });\r\n}\r\n\r\n\r\nfunction resolveCp(cp: DataProperty, metadataStore: MetadataStore) {\r\n  let complexType = metadataStore._getStructuralType(cp.complexTypeName, true);\r\n  if (!complexType) return false;\r\n  if (!(complexType instanceof ComplexType)) {\r\n    throw new Error(\"Unable to resolve ComplexType with the name: \" + cp.complexTypeName + \" for the property: \" + cp.name);\r\n  }\r\n  cp.dataType = complexType;\r\n  cp.defaultValue = null;\r\n  return true;\r\n}\r\n\r\nfunction tryResolveNp(np: NavigationProperty, metadataStore: MetadataStore) {\r\n  if (np.entityType) return true;\r\n\r\n  let entityType = metadataStore._getStructuralType(np.entityTypeName, true) as EntityType;\r\n  if (entityType) {\r\n    np.entityType = entityType;\r\n    np._resolveNp();\r\n    // don't bother removing - _updateNps will do it later.\r\n    // __arrayRemoveItem(incompleteNps, np, false);\r\n  } else {\r\n    let incompleteNps = core.getArray(metadataStore._incompleteTypeMap, np.entityTypeName);\r\n    core.arrayAddItemUnique(incompleteNps, np);\r\n  }\r\n  return !!entityType;\r\n}\r\n\r\nfunction calcUnmappedProperties(stype: StructuralType, instance: any) {\r\n  let metadataPropNames = stype.getPropertyNames();\r\n  let modelLib = config.interfaceRegistry.modelLibrary.getDefaultInstance();\r\n  let trackablePropNames = modelLib.getTrackablePropertyNames(instance);\r\n  trackablePropNames.forEach(function (pn: string) {\r\n    if (metadataPropNames.indexOf(pn) === -1) {\r\n      let val = instance[pn];\r\n      try {\r\n        if (typeof val === \"function\") val = val();\r\n      } catch (e) {\r\n      }\r\n      let dt = DataType.fromValue(val);\r\n      let newProp = new DataProperty({\r\n        name: pn,\r\n        dataType: dt,\r\n        isNullable: true,\r\n        isUnmapped: true\r\n      });\r\n      newProp.isSettable = core.isSettable(instance, pn);\r\n      if (stype instanceof EntityType && stype.subtypes != null && stype.subtypes.length) {\r\n        stype.getSelfAndSubtypes().forEach((st) => {\r\n          st._addPropertyCore(new DataProperty(newProp));\r\n        });\r\n      } else {\r\n        stype._addPropertyCore(newProp);\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\nexport interface ComplexTypeConfig {\r\n  shortName?: string;\r\n  namespace?: string;\r\n  dataProperties?: DataProperty[] | Object[] | Object;\r\n  isComplexType?: boolean;  // needed because this ctor can get called from the addEntityType method which needs the isComplexType prop\r\n  custom?: any;\r\n}\r\n\r\n/**  Container for all of the metadata about a specific type of Complex object.\r\n>     let complexType = new ComplexType( {\r\n>         shortName: \"address\",\r\n>         namespace: \"myAppNamespace\"\r\n>     });\r\n@param config - Configuration settings\r\n**/\r\nexport class ComplexType {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on proto\r\n  /** For polymorphic purpose only - always true here */\r\n  isComplexType = true;\r\n\r\n  /** The [[MetadataStore]] containing this ComplexType. */\r\n  metadataStore: MetadataStore;\r\n\r\n  /**  The fully qualifed name of this ComplexType. __Read Only__  **/\r\n  name: string;\r\n  /**  The short, unqualified, name for this ComplexType. __Read Only__ **/\r\n  shortName: string;\r\n\r\n  /** The namespace for this ComplexType. __Read Only__ **/\r\n  namespace: string;\r\n  /** The DataProperties (see [[DataProperty]] associated with this ComplexType. __Read Only__ */\r\n  dataProperties: DataProperty[];\r\n  /** The DataProperties for this ComplexType that contain instances of a [[ComplexType]]. __Read Only__ */\r\n  complexProperties: DataProperty[];\r\n\r\n  /**\r\n  The entity level validators associated with this ComplexType. Validators can be added and\r\n  removed from this collection. __Read Only__  **/\r\n  validators: Validator[];\r\n  /** For polymorphic purpose only - always empty here */\r\n  concurrencyProperties: DataProperty[];\r\n  /** The DataProperties associated with this ComplexType that are not mapped to any backend datastore. These are effectively free standing\r\n  properties. __Read Only__   **/\r\n  unmappedProperties: DataProperty[];\r\n\r\n  // keyProperties and navigationProperties are not used on complexTypes - but here to allow sharing of code between EntityType and ComplexType.\r\n  navigationProperties: DataProperty[];\r\n  // and may be used later to enforce uniqueness on arrays of complextypes.\r\n  keyProperties: DataProperty[];\r\n  warnings: any[];\r\n  serializerFn?: (prop: EntityProperty, val: any) => any;\r\n\r\n  /** A free form object that can be used to define any custom metadata for this ComplexType. ***/\r\n  custom?: any;\r\n  /** @hidden @internal */\r\n  _mappedPropertiesCount: number;\r\n  /** @hidden @internal */\r\n  _extra?: any;\r\n\r\n  // copy entityType methods onto complexType\r\n  /** See [[EntityType.getCtor]] */\r\n  getCtor = EntityType.prototype.getCtor;\r\n  // note the name change.\r\n  createInstance = EntityType.prototype.createEntity;\r\n  /** See [EntityType.addValidator] */\r\n  addValidator = EntityType.prototype.addValidator;\r\n  getProperty = EntityType.prototype.getProperty;\r\n  getPropertiesOnPath = EntityType.prototype.getPropertiesOnPath;\r\n  getPropertyNames = EntityType.prototype.getPropertyNames;\r\n  /** @hidden @internal */\r\n  _addPropertyCore = EntityType.prototype._addPropertyCore;\r\n  /** @hidden @internal */\r\n  _addDataProperty = EntityType.prototype._addDataProperty;\r\n  /** @hidden @internal */\r\n  _updateNames = EntityType.prototype._updateNames;\r\n  /** @hidden @internal */\r\n  _updateCps = EntityType.prototype._updateCps;\r\n  /** @hidden @internal */\r\n  _initializeInstance = EntityType.prototype._initializeInstance;\r\n  /** @hidden @internal */\r\n  _updateTargetFromRaw = EntityType.prototype._updateTargetFromRaw;\r\n  /** @hidden @internal */\r\n  _setCtor = EntityType.prototype._setCtor;\r\n\r\n  constructor(config: ComplexTypeConfig) {\r\n    if (arguments.length > 1) {\r\n      throw new Error(\"The ComplexType ctor has a single argument that is a configuration object.\");\r\n    }\r\n\r\n    assertConfig(config)\r\n      .whereParam(\"shortName\").isNonEmptyString()\r\n      .whereParam(\"namespace\").isString().isOptional().withDefault(\"\")\r\n      .whereParam(\"dataProperties\").isOptional()\r\n      .whereParam(\"isComplexType\").isOptional().isBoolean()   // needed because this ctor can get called from the addEntityType method which needs the isComplexType prop\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n\r\n    this.name = qualifyTypeName(this.shortName, this.namespace);\r\n    this.isComplexType = true;\r\n    this.dataProperties = [];\r\n    this.complexProperties = [];\r\n    this.validators = [];\r\n    this.concurrencyProperties = [];\r\n    this.unmappedProperties = [];\r\n    this._mappedPropertiesCount = 0;\r\n    // keyProperties and navigationProperties are not used on complexTypes - but here to allow sharing of code between EntityType and ComplexType.\r\n    this.navigationProperties = [];\r\n    this.keyProperties = []; // may be used later to enforce uniqueness on arrays of complextypes.\r\n    if (config.dataProperties) {\r\n      addProperties(this, config.dataProperties, DataProperty);\r\n    }\r\n  }\r\n\r\n  /**\r\n  General purpose property set method\r\n  >      // assume em1 is an EntityManager\r\n  >      let addresstType = em1.metadataStore.getEntityType(\"Address\");\r\n  >      addressType.setProperties( {\r\n  >          custom: { foo: 7, bar: \"test\" }\r\n  >      });\r\n  @param config - Custom config object\r\n  @param config.custom - {Object}\r\n  **/\r\n  setProperties(config: { custom?: any }) {\r\n    assertConfig(config)\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n  }\r\n\r\n\r\n  getAllValidators() {\r\n    // ComplexType inheritance is not YET supported.\r\n    return this.validators;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _createInstanceCore(parent: StructuralObject, parentProperty: DataProperty) {\r\n    let aCtor = this.getCtor();\r\n    let instance = new aCtor() as ComplexObject;\r\n    new ComplexAspect(instance, parent, parentProperty);\r\n    // initialization occurs during either attach or in createInstance call.\r\n    return instance;\r\n  }\r\n\r\n\r\n  addProperty(dataProperty: DataProperty) {\r\n    assertParam(dataProperty, \"dataProperty\").isInstanceOf(DataProperty).check();\r\n    return this._addPropertyCore(dataProperty);\r\n  }\r\n\r\n  getProperties(): EntityProperty[] {\r\n    return this.dataProperties;\r\n  }\r\n\r\n  toJSON() {\r\n    return core.toJson(this, {\r\n      shortName: null,\r\n      namespace: null,\r\n      isComplexType: null,\r\n      dataProperties: null,\r\n      validators: null,\r\n      custom: null\r\n    });\r\n  }\r\n\r\n}\r\nComplexType.prototype._$typeName = \"ComplexType\";\r\n/** Creates an instance of this complexType */\r\nComplexType.prototype.createInstance = EntityType.prototype.createEntity;\r\n\r\nexport interface DataPropertyConfig {\r\n  name?: string;\r\n  nameOnServer?: string;\r\n  dataType?: DataType | string | ComplexType;\r\n  complexTypeName?: string;\r\n  isNullable?: boolean;\r\n  isScalar?: boolean; // will be false for some NoSQL databases.\r\n  defaultValue?: any;\r\n  isPartOfKey?: boolean;\r\n  isUnmapped?: boolean;\r\n  isSettable?: boolean;\r\n  concurrencyMode?: string;\r\n  maxLength?: number;\r\n  validators?: Validator[];\r\n  displayName?: string;\r\n  enumType?: string;\r\n  rawTypeName?: string;  // occurs with undefined datatypes\r\n  custom?: any;\r\n}\r\n\r\n/**\r\nA DataProperty describes the metadata for a single property of an  [[EntityType]] that contains simple data.\r\n\r\nInstances of the DataProperty class are constructed automatically during Metadata retrieval. However it is also possible to construct them\r\ndirectly via the constructor.\r\n**/\r\nexport class DataProperty {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // on proto\r\n  /** Is this a DataProperty? - always true here. Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */\r\n  isDataProperty = true;\r\n  /** Is this a NavigationProperty? - always false here.  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */\r\n  isNavigationProperty = false;\r\n  /** The name of this property. __Read Only__  **/\r\n  declare name: string;\r\n  /** The name of this property on the server. __Read Only__ **/\r\n  declare nameOnServer: string;\r\n  /** The [[DataType]] of this property. __Read Only__ */\r\n  declare dataType: DataType | ComplexType; // this will be a complexType when dp is a complexProperty\r\n  /** The name of the [[ComplexType]] associated with this property; may be null. __Read Only__ */\r\n  declare complexTypeName: string;\r\n  /** The [[ComplexType]] associated with this property; may be undefined. __Read Only__ */\r\n  declare complexType?: ComplexType;\r\n  /**  Whether the contents of this property is an instance of a [[ComplexType]]. __Read Only__ */\r\n  declare isComplexProperty: boolean;\r\n  /** Whether this property is nullable. __Read Only__ */\r\n  declare isNullable: boolean;\r\n  /**  Whether this property is scalar (i.e., returns a single value as opposed to an array). __Read Only__ */\r\n  declare isScalar: boolean; // will be false for some NoSQL databases.\r\n  /** The default value for this property. __Read Only__ */\r\n  declare defaultValue: any;\r\n  /**  Whether this property is a 'key' property. __Read Only__ */\r\n  declare isPartOfKey: boolean;\r\n  /** Whether this property is an 'unmapped' property. __Read Only__ */\r\n  declare isUnmapped: boolean;\r\n  /** Whether this property is 'settable'. __Read Only__ */\r\n  declare isSettable: boolean;\r\n  // TODO: doc this\r\n  declare concurrencyMode: string;\r\n  /**  The maximum length for the value of this property. Only meaningful for strings. __Read Only__ */\r\n  declare maxLength?: number;\r\n  /** The [[Validator]] instances that are associated with this property. Validators can be added and\r\n  removed from this collection. __Read Only__ */\r\n  declare validators: Validator[];\r\n  /** The display name of this property. __Read Only__ */\r\n  declare displayName: string;\r\n  /** The full name of the enum type */\r\n  declare enumType?: string;\r\n  /** The raw type name of this property. will only be defined for properties with a DataType of 'Undefined' */\r\n  declare rawTypeName?: string;  // occurs with undefined datatypes\r\n  /**  A free form object that can be used to define any custom metadata for this DataProperty. __Read Only__ */\r\n  declare custom?: any;\r\n  // TODO: doc this\r\n  declare inverseNavigationProperty?: NavigationProperty;\r\n  /**\r\n  The navigation property related to this property.  Will only be set if this is a foreign key property. __Read Only__ */\r\n  declare relatedNavigationProperty?: NavigationProperty;\r\n  /** The parent type that this property belongs to - will be either a [[EntityType]] or a [[ComplexType]]. __Read Only__ */\r\n  declare parentType: StructuralType;\r\n  /** Property on the base type that this property is inherited from. Will be null if the property is not on the base type. __Read Only__ */\r\n  declare baseProperty?: DataProperty;\r\n\r\n  /** DataProperty constructor\r\n  >      let lastNameProp = new DataProperty( {\r\n  >          name: \"lastName\",\r\n  >          dataType: DataType.String,\r\n  >          isNullable: true,\r\n  >          maxLength: 20\r\n  >      });\r\n  >      // assuming personEntityType is a newly constructed EntityType\r\n  >      personEntityType.addProperty(lastNameProperty);\r\n  @param config - A configuration Object or a DataProperty\r\n  */\r\n  constructor(config: DataPropertyConfig | DataProperty) {\r\n    assertConfig(config)\r\n      .whereParam(\"name\").isString().isOptional()\r\n      .whereParam(\"nameOnServer\").isString().isOptional()\r\n      .whereParam(\"dataType\").isEnumOf(DataType).isOptional().or().isString().or().isInstanceOf(ComplexType)\r\n      .whereParam(\"complexTypeName\").isOptional()\r\n      .whereParam(\"isNullable\").isBoolean().isOptional().withDefault(true)\r\n      .whereParam(\"isScalar\").isOptional().withDefault(true)// will be false for some NoSQL databases.\r\n      .whereParam(\"defaultValue\").isOptional()\r\n      .whereParam(\"isPartOfKey\").isBoolean().isOptional()\r\n      .whereParam(\"isUnmapped\").isBoolean().isOptional()\r\n      .whereParam(\"isSettable\").isBoolean().isOptional().withDefault(true)\r\n      .whereParam(\"concurrencyMode\").isString().isOptional()\r\n      .whereParam(\"maxLength\").isNumber().isOptional()\r\n      .whereParam(\"validators\").isInstanceOf(Validator).isArray().isOptional().withDefault([])\r\n      .whereParam(\"displayName\").isOptional()\r\n      .whereParam(\"enumType\").isOptional()\r\n      .whereParam(\"rawTypeName\").isOptional() // occurs with undefined datatypes\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n    let hasName = !!(this.name || this.nameOnServer);\r\n    if (!hasName) {\r\n      throw new Error(\"A DataProperty must be instantiated with either a 'name' or a 'nameOnServer' property\");\r\n    }\r\n    // name/nameOnServer is resolved later when a metadataStore is available.\r\n\r\n    if (this.complexTypeName) {\r\n      this.isComplexProperty = true;\r\n      // this.dataType = null; // TODO: would like to remove this line because dataType will be set later.\r\n    } else if (typeof (this.dataType) === \"string\") {\r\n      let dt = DataType.fromName(this.dataType);\r\n      if (!dt) {\r\n        throw new Error(\"Unable to find a DataType enumeration by the name of: \" + this.dataType);\r\n      }\r\n      this.dataType = dt;\r\n    } else if (!this.dataType) {\r\n      this.dataType = DataType.String;\r\n    }\r\n\r\n    // == as opposed to === is deliberate here.\r\n    if (this.defaultValue == null) {\r\n      if (this.isNullable) {\r\n        this.defaultValue = null;\r\n      } else {\r\n        if (this.isComplexProperty) {\r\n          // what to do? - shouldn't happen from EF - but otherwise ???\r\n        } else if (this.dataType === DataType.Binary) {\r\n          this.defaultValue = \"AAAAAAAAJ3U=\"; // hack for all binary fields but value is specifically valid for timestamp fields - arbitrary valid 8 byte base64 value.\r\n        } else {\r\n          this.defaultValue = (this.dataType as any).defaultValue;\r\n          const msg = \"A nonnullable DataProperty cannot have a null defaultValue. Name: \" + (this.name || this.nameOnServer);\r\n          if (this.defaultValue === null) {\r\n            throw new Error(msg);  // if defaultValue is explicity set to null, that's an error\r\n          } else if (this.defaultValue == null) {\r\n            console.warn(msg);  // if defaultValue is not set, that's a warning\r\n          }\r\n        }\r\n      }\r\n    } else if ((this.dataType as any).isNumeric) {\r\n      // in case the defaultValue comes in as a string ( which it does in EF6).\r\n      if (typeof (this.defaultValue) === \"string\") {\r\n        this.defaultValue = parseFloat(this.defaultValue);\r\n      }\r\n    }\r\n\r\n    if (this.isComplexProperty) {\r\n      this.isScalar = this.isScalar == null || this.isScalar === true;\r\n    }\r\n\r\n  }\r\n\r\n  static getRawValueFromServer(rawEntity: Object & Record<string, any>, dp: DataProperty) {\r\n    if (dp.isUnmapped) {\r\n      return rawEntity[dp.nameOnServer || dp.name];\r\n    } else {\r\n      let val = rawEntity[dp.nameOnServer];\r\n      return val !== undefined ? val : dp.defaultValue;\r\n    }\r\n  }\r\n\r\n  static getRawValueFromClient(rawEntity: Object & Record<string, any>, dp: DataProperty) {\r\n    let val = rawEntity[dp.name];\r\n    return val !== undefined ? val : dp.defaultValue;\r\n  }\r\n\r\n  resolveProperty(propName: string) {\r\n    let result = this[propName];\r\n    let baseProp = this.baseProperty;\r\n    while (result == undefined && baseProp != null) {\r\n      result = baseProp[propName];\r\n      baseProp = baseProp.baseProperty;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  formatName() {\r\n    return this.parentType.name + \"--\" + this.name;\r\n  }\r\n\r\n\r\n  /**\r\n  General purpose property set method\r\n  >      // assume em1 is an EntityManager\r\n  >      let prop = myEntityType.getProperty(\"myProperty\");\r\n  >      prop.setProperties( {\r\n  >          custom: { foo: 7, bar: \"test\" }\r\n  >      });\r\n  @param config - A configuration object.\r\n  **/\r\n  setProperties(config: { displayName?: string, custom?: Object }) {\r\n    assertConfig(config)\r\n      .whereParam(\"displayName\").isOptional()\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n  }\r\n\r\n  getAllValidators() {\r\n    let validators = this.validators.slice(0);\r\n    let baseProp = this.baseProperty;\r\n    while (baseProp) {\r\n      validators.push.apply(validators, baseProp.validators);\r\n      baseProp = baseProp.baseProperty;\r\n    }\r\n    return validators;\r\n  }\r\n\r\n  toJSON() {\r\n    // do not serialize dataTypes that are complexTypes\r\n    return core.toJson(this, {\r\n      name: null,\r\n      dataType: function (v: any) {\r\n        return (v && v instanceof DataType) ? v.name : undefined;\r\n      }, // do not serialize dataTypes that are complexTypes\r\n      complexTypeName: null,\r\n      isNullable: true,\r\n      defaultValue: null,\r\n      isPartOfKey: false,\r\n      isUnmapped: false,\r\n      isSettable: true,\r\n      concurrencyMode: null,\r\n      maxLength: null,\r\n      validators: null,\r\n      displayName: null,\r\n      enumType: null,\r\n      rawTypeName: null,\r\n      isScalar: true,\r\n      custom: null\r\n    });\r\n  }\r\n\r\n  static fromJSON(json: any) {\r\n    json.dataType = DataType.fromName(json.dataType);\r\n    // Parse default value into correct data type. (dateTime instances require extra work to deserialize properly.)\r\n    if (json.defaultValue && json.dataType && json.dataType.parse) {\r\n      json.defaultValue = json.dataType.parse(json.defaultValue, typeof json.defaultValue);\r\n    }\r\n\r\n    if (json.validators) {\r\n      json.validators = json.validators.map(Validator.fromJSON);\r\n    }\r\n\r\n    return new DataProperty(json);\r\n  }\r\n\r\n}\r\nDataProperty.prototype._$typeName = \"DataProperty\";\r\n\r\nexport interface NavigationPropertyConfig {\r\n  name?: string;\r\n  nameOnServer?: string;\r\n  entityTypeName?: string;\r\n  isScalar?: boolean;\r\n  associationName?: string;\r\n  foreignKeyNames?: string[];\r\n  foreignKeyNamesOnServer?: string[];\r\n  invForeignKeyNames?: string[];\r\n  invForeignKeyNamesOnServer?: string[];\r\n  validators?: Validator[];\r\n  displayName?: string;\r\n  custom?: any;\r\n}\r\n\r\n/**   A NavigationProperty describes the metadata for a single property of an [[EntityType]] that return instances of other EntityTypes.\r\n\r\nInstances of the NavigationProperty class are constructed automatically during Metadata retrieval.   However it is also possible to construct them\r\ndirectly via the constructor.\r\n**/\r\nexport class NavigationProperty {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string;\r\n  /** Is this a DataProperty? - always false here \r\n  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */\r\n  isDataProperty = false;\r\n  /** Is this a NavigationProperty? - always true here\r\n  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */\r\n  isNavigationProperty = true;\r\n\r\n  formatName = DataProperty.prototype.formatName;\r\n  getAllValidators = DataProperty.prototype.getAllValidators;\r\n  resolveProperty = DataProperty.prototype.resolveProperty;\r\n\r\n  /** The [[EntityType]] returned by this property. __Read Only__ */\r\n  declare entityType: EntityType;\r\n  /** The name of the [[EntityType]] returned by this property. __Read Only__ */\r\n  declare entityTypeName: string;\r\n  /** The [[EntityType]] that this property belongs to. ( same as entityType). __Read Only__ */\r\n  declare parentType: EntityType; // ?? same as entityType\r\n  /** The [[EntityType]] that this property belongs to. ( same as entityType). __Read Only__ */\r\n  declare parentEntityType: EntityType; // ?? same as above\r\n  /** Property on the base type that this property is inherited from. Will be null if the property is not on the base type. __Read Only__ */\r\n  declare baseProperty?: NavigationProperty;\r\n  /** The inverse of this NavigationProperty.  The NavigationProperty that represents a navigation in the opposite direction\r\n  to this NavigationProperty. May be undefined for a undirectional NavigationProperty. __Read Only__ */\r\n  declare private _inverse?: NavigationProperty;\r\n  /** The name of this property. __Read Only__ */\r\n  declare name: string;\r\n  /** The name of this property on the server. __Read Only__ */\r\n  declare nameOnServer: string;\r\n  /**\r\n  Whether this property returns a single entity as opposed to  an array of entities. __Read Only__ */\r\n  declare isScalar: boolean;\r\n  /** The name of the association to which that this property belongs.  This associationName will be shared with this\r\n  properties 'inverse'. __Read Only__ */\r\n  declare associationName: string;\r\n  /** The names of the foreign key DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated\r\n  with a Navigation property except in the case of entities with multipart keys. __Read Only__ */\r\n  declare foreignKeyNames: string[];\r\n  /** The server side names of the foreign key DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated\r\n  with a Navigation property except in the case of entities with multipart keys. __Read Only__ */\r\n  declare foreignKeyNamesOnServer: string[];\r\n  /** The names of the foreign key DataProperties at the other end of the relationship. __Read Only__ */\r\n  declare invForeignKeyNames: string[];\r\n  /** The server side names of the foreign key DataProperties at the other end of the relationship. __Read Only__ */\r\n  declare invForeignKeyNamesOnServer: string[];\r\n  /** The 'foreign key' DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated\r\n  with a Navigation property except in the case of entities with multipart keys. __Read Only__ */\r\n  declare relatedDataProperties: DataProperty[];\r\n  /** The [[Validator]] instances that are associated with this property. Validators can be added and\r\n  removed from this collection. __Read Only__ */\r\n  declare validators: Validator[];\r\n  /** The display name of this property. __Read Only__ */\r\n  declare displayName: string;\r\n  declare isUnmapped: boolean;\r\n  /** A free form object that can be used to define any custom metadata for this NavigationProperty.   **/\r\n  declare custom: any;\r\n\r\n  /** NavigationProperty constructor\r\n  >      let homeAddressProp = new NavigationProperty( {\r\n  >          name: \"homeAddress\",\r\n  >          entityTypeName: \"Address:#myNamespace\",\r\n  >          isScalar: true,\r\n  >          associationName: \"address_person\",\r\n  >          foreignKeyNames: [\"homeAddressId\"]\r\n  >      });\r\n  >      let homeAddressIdProp = new DataProperty( {\r\n  >          name: \"homeAddressId\"\r\n  >          dataType: DataType.Integer\r\n  >      });\r\n  >      // assuming personEntityType is a newly constructed EntityType\r\n  >      personEntityType.addProperty(homeAddressProp);\r\n  >      personEntityType.addProperty(homeAddressIdProp);\r\n  @param config - A configuration object.\r\n  **/\r\n  constructor(config: NavigationPropertyConfig) {\r\n    assertConfig(config)\r\n      .whereParam(\"name\").isString().isOptional()\r\n      .whereParam(\"nameOnServer\").isString().isOptional()\r\n      .whereParam(\"entityTypeName\").isString()\r\n      .whereParam(\"isScalar\").isBoolean().isOptional().withDefault(true)\r\n      .whereParam(\"associationName\").isString().isOptional()\r\n      .whereParam(\"foreignKeyNames\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"foreignKeyNamesOnServer\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"invForeignKeyNames\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"invForeignKeyNamesOnServer\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"validators\").isInstanceOf(Validator).isArray().isOptional().withDefault([])\r\n      .whereParam(\"displayName\").isOptional()\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n    let hasName = !!(this.name || this.nameOnServer);\r\n\r\n    if (!hasName) {\r\n      throw new Error(\"A Navigation property must be instantiated with either a 'name' or a 'nameOnServer' property\");\r\n    }\r\n  }\r\n\r\n  /**\r\n  General purpose property set method\r\n  >      // assume myEntityType is an EntityType\r\n  >      let prop = myEntityType.getProperty(\"myProperty\");\r\n  >      prop.setProperties( {\r\n  >          custom: { foo: 7, bar: \"test\" }\r\n  >      });\r\n  @param config - A config object\r\n  **/\r\n  // TODO: create an interface for this.\r\n  setProperties(config: {\r\n    displayName?: string,\r\n    foreignKeyNames?: string[],\r\n    invForeignKeyNames?: string[],\r\n    inverse?: NavigationProperty | string,\r\n    custom?: any\r\n  }) {\r\n    if (!this.parentType) {\r\n      throw new Error(\"Cannot call NavigationProperty.setProperties until the parent EntityType of the NavigationProperty has been set.\");\r\n    }\r\n    let inverse = config.inverse;\r\n    if (inverse) delete config.inverse;\r\n    assertConfig(config)\r\n      .whereParam(\"displayName\").isOptional()\r\n      .whereParam(\"foreignKeyNames\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"invForeignKeyNames\").isArray().isString().isOptional().withDefault([])\r\n      .whereParam(\"custom\").isOptional()\r\n      .applyAll(this);\r\n    this.parentType._updateNames(this);\r\n\r\n    this._resolveNp();\r\n    if (inverse) {\r\n      this.setInverse(inverse);\r\n    }\r\n\r\n  }\r\n\r\n  /** The inverse of this NavigationProperty.  The NavigationProperty that represents a navigation in the opposite direction\r\n  to this NavigationProperty. May be undefined for a undirectional NavigationProperty. __Read Only__ */\r\n  get inverse(): NavigationProperty | undefined {\r\n    return this.getInverse();\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  getInverse(): NavigationProperty | undefined {\r\n    let np: NavigationProperty = this;\r\n    while (!np._inverse && np.baseProperty) {\r\n      np = np.baseProperty;\r\n    }\r\n    return np._inverse;\r\n  }\r\n\r\n  setInverse(inverseNp: NavigationProperty | string) {\r\n    // let invNp: NavigationProperty;\r\n    let invNp = (inverseNp instanceof NavigationProperty) ? inverseNp : this.entityType.getNavigationProperty(inverseNp);\r\n\r\n    if (!invNp) {\r\n      throw throwSetInverseError(this, \"Unable to find inverse property: \" + inverseNp);\r\n    }\r\n\r\n    if (this._inverse || invNp._inverse) {\r\n      throwSetInverseError(this, \"It has already been set on one side or the other.\");\r\n    }\r\n    if (invNp.entityType !== this.parentType) {\r\n      throwSetInverseError(this, invNp.formatName + \" is not a valid inverse property for this.\");\r\n    }\r\n    if (this.associationName) {\r\n      invNp.associationName = this.associationName;\r\n    } else {\r\n      if (!invNp.associationName) {\r\n        invNp.associationName = this.formatName() + \"_\" + invNp.formatName();\r\n      }\r\n      this.associationName = invNp.associationName;\r\n    }\r\n    this._resolveNp();\r\n    invNp._resolveNp();\r\n  }\r\n\r\n  // // In progress - will be used for manual metadata config\r\n  // createInverse(config: any) {\r\n\r\n  //   if (!this.entityType) {\r\n  //     throwCreateInverseError(this, \"has not yet been defined.\");\r\n  //   }\r\n  //   if (this.entityType.isFrozen) {\r\n  //     throwCreateInverseError(this, \"is frozen.\");\r\n  //   }\r\n  //   let metadataStore = this.entityType.metadataStore;\r\n  //   if (metadataStore == null) {\r\n  //     throwCreateInverseError(this, \"has not yet been added to the metadataStore.\");\r\n  //   }\r\n\r\n  //   config.entityTypeName = this.parentEntityType.name;\r\n  //   config.associationName = this.associationName;\r\n  //   let invNp = new NavigationProperty(config);\r\n  //   this.parentEntityType.addNavigationProperty(invNp);\r\n  //   return invNp;\r\n  // };\r\n\r\n\r\n\r\n  toJSON() {\r\n    return core.toJson(this, {\r\n      name: null,\r\n      entityTypeName: null,\r\n      isScalar: null,\r\n      associationName: null,\r\n      validators: null,\r\n      displayName: null,\r\n      foreignKeyNames: null,\r\n      invForeignKeyNames: null,\r\n      custom: null\r\n    });\r\n  }\r\n\r\n  static fromJSON(json: any) {\r\n    if (json.validators) {\r\n      json.validators = json.validators.map(Validator.fromJSON);\r\n    }\r\n    return new NavigationProperty(json);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _resolveNp() {\r\n    let np = this;\r\n    let entityType = np.entityType;\r\n    let invNp = core.arrayFirst(entityType.navigationProperties, (altNp) => {\r\n      // Can't do this because of possibility of comparing a base class np with a subclass altNp.\r\n      // return altNp.associationName === np.associationName\r\n      //    && altNp !== np;\r\n      // So use this instead.\r\n      return altNp.associationName === np.associationName &&\r\n        (altNp.name !== np.name || altNp.entityTypeName !== np.entityTypeName);\r\n    });\r\n    np._inverse = invNp || undefined;\r\n    //if (invNp && invNp.inverse == null) {\r\n    //    invNp._resolveNp();\r\n    //}\r\n    if (!invNp) {\r\n      // unidirectional 1-n relationship\r\n      np.invForeignKeyNames.forEach(function (invFkName) {\r\n        let fkProp = entityType.getDataProperty(invFkName);\r\n        if (fkProp == null) {\r\n          throw new Error(\"EntityType '\" + np.entityTypeName + \"' has no foreign key matching '\" + invFkName + \"'\");\r\n        }\r\n        let invEntityType = np.parentType;\r\n        invNp = core.arrayFirst(invEntityType.navigationProperties, (np2) => {\r\n          return np2.invForeignKeyNames && np2.invForeignKeyNames.indexOf(fkProp!.name) >= 0 && np2.entityType === fkProp!.parentType;\r\n        });\r\n        fkProp.inverseNavigationProperty = invNp || undefined;\r\n        core.arrayAddItemUnique(entityType.foreignKeyProperties, fkProp);\r\n      });\r\n    }\r\n\r\n    resolveRelated(np);\r\n  }\r\n\r\n}\r\nNavigationProperty.prototype._$typeName = \"NavigationProperty\";\r\n\r\nfunction throwSetInverseError(np: NavigationProperty, message: string) {\r\n  throw new Error(\"Cannot set the inverse property for: \" + np.formatName() + \". \" + message);\r\n}\r\n\r\n// Not current used.\r\n// function throwCreateInverseError(np: NavigationProperty, message: string) {\r\n//   throw new Error(\"Cannot create inverse for: \" + np.formatName() + \". The entityType for this navigation property \" + message);\r\n// }\r\n\r\n// sets navigation property: relatedDataProperties and dataProperty: relatedNavigationProperty\r\nfunction resolveRelated(np: NavigationProperty) {\r\n\r\n  let fkNames = np.foreignKeyNames;\r\n  if (fkNames.length === 0) return;\r\n\r\n  let parentEntityType = np.parentType;\r\n  let fkProps = fkNames.map(function (fkName) {\r\n    return parentEntityType.getDataProperty(fkName);\r\n  });\r\n  let fkPropCollection = parentEntityType.foreignKeyProperties;\r\n\r\n  fkProps.forEach((dp: DataProperty) => {\r\n    core.arrayAddItemUnique(fkPropCollection, dp);\r\n    dp.relatedNavigationProperty = np;\r\n    // now update the inverse\r\n    core.arrayAddItemUnique(np.entityType.inverseForeignKeyProperties, dp);\r\n    if (np.relatedDataProperties) {\r\n      core.arrayAddItemUnique(np.relatedDataProperties, dp);\r\n    } else {\r\n      np.relatedDataProperties = [dp];\r\n    }\r\n  });\r\n}\r\n\r\n\r\n/**\r\nAutoGeneratedKeyType is an 'Enum' containing all of the valid states for an automatically generated key.\r\n**/\r\nexport class AutoGeneratedKeyType extends BreezeEnum {\r\n\r\n  /**\r\n  This entity does not have an autogenerated key.\r\n  The client must set the key before adding the entity to the EntityManager\r\n  **/\r\n  static None = new AutoGeneratedKeyType();\r\n  /** \r\n  This entity's key is an Identity column and is set by the backend database.\r\n  Keys for new entities will be temporary until the entities are saved at which point the keys will\r\n  be converted to their 'real' versions.\r\n  **/\r\n  static Identity = new AutoGeneratedKeyType();\r\n  /**\r\n  This entity's key is generated by a KeyGenerator and is set by the backend database.\r\n  Keys for new entities will be temporary until the entities are saved at which point the keys will\r\n  be converted to their 'real' versions.\r\n  **/\r\n  static KeyGenerator = new AutoGeneratedKeyType();\r\n\r\n}\r\nAutoGeneratedKeyType.prototype._$typeName = \"AutoGeneratedKeyType\";\r\nError['x'] = AutoGeneratedKeyType.resolveSymbols();\r\n\r\n\r\n// mixin methods\r\n/** @hidden @internal */\r\ndeclare module \"./assert-param\" {\r\n  interface Param {\r\n    isEntity(): Param;\r\n    isEntityProperty(): Param;\r\n  }\r\n}\r\n\r\nlet proto = Param.prototype;\r\n\r\n// 'this' below is TS annotation \r\nproto.isEntity = function (this: Param) {\r\n  return this._addContext({\r\n    fn: isEntity,\r\n    msg: \" must be an entity\"\r\n  });\r\n};\r\n\r\nfunction isEntity(context: any, v: any) {\r\n  if (v == null) return false;\r\n  return (v.entityType !== undefined);\r\n}\r\n\r\nproto.isEntityProperty = function (this: Param) {\r\n  return this._addContext({\r\n    fn: isEntityProperty,\r\n    msg: \" must be either a DataProperty or a NavigationProperty\"\r\n  });\r\n};\r\n\r\nfunction isEntityProperty(context: any, v: any) {\r\n  if (v == null) return false;\r\n  return (v.isDataProperty || v.isNavigationProperty);\r\n}\r\n\r\n// functions shared between classes related to Metadata\r\n\r\nfunction isQualifiedTypeName(entityTypeName: string) {\r\n  return entityTypeName.indexOf(\":#\") >= 0;\r\n}\r\n\r\nexport function qualifyTypeName(shortName: string, ns?: string) {\r\n  if (ns && ns.length > 0) {\r\n    return shortName + \":#\" + ns;\r\n  } else {\r\n    return shortName;\r\n  }\r\n}\r\n\r\n// Used by both ComplexType and EntityType\r\nfunction addProperties(entityType: StructuralType, propObj: Object | undefined, ctor: any) {\r\n  if (propObj == null) return;\r\n  if (Array.isArray(propObj)) {\r\n    propObj.forEach(entityType._addPropertyCore.bind(entityType));\r\n  } else if (typeof (propObj) === 'object') {\r\n    for (let key in propObj) {\r\n      if (core.hasOwnProperty(propObj, key)) {\r\n        let value = propObj[key];\r\n        value.name = key;\r\n        let prop = new ctor(value);\r\n        entityType._addPropertyCore(prop);\r\n      }\r\n    }\r\n  } else {\r\n    throw new Error(\"The 'dataProperties' or 'navigationProperties' values must be either an array of data/nav properties or an object where each property defines a data/nav property\");\r\n  }\r\n}\r\n\r\n\r\n\r\n\r\n\r\n"]}