breeze-client 2.2.2 → 3.0.0

package/metadata/entity-metadata.js

@@ -0,0 +1,2502 @@
+import { core, hasOwnProperty as hasOwnProp, stringStartsWith } from '../core/core.js';
+import { config, setDefaultAdapters } from '../config/config.js';
+import { BreezeEvent } from '../core/event.js';
+import { assertParam, assertConfig } from '../core/assert-param.js';
+import { DataType } from './data-type.js';
+import { EntityAspect, ComplexAspect } from '../entity/entity-aspect.js';
+import { EntityKey } from '../entity/entity-key.js';
+import { Validator } from '../validation/validate.js';
+import { BreezeEnum } from '../core/enum.js';
+import { DataService } from './data-service.js';
+import { NamingConvention } from './naming-convention.js';
+import { LocalQueryComparisonOptions } from './local-query-comparison-options.js';
+import { defaultPropertyInterceptor } from '../entity/default-property-interceptor.js';
+import { ModelLibraryBackingStoreAdapter } from '../adapters/adapter-model-library-backing-store.js';
+/**
+An instance of the MetadataStore contains all of the metadata about a collection of {@link EntityType}'s.
+MetadataStores may be shared across {@link EntityManager}'s.  If an EntityManager is created without an
+explicit MetadataStore, the MetadataStore from the MetadataStore.defaultInstance property will be used.
+*/
+export class MetadataStore {
+    /** @hidden @internal */
+    static __id = 0;
+    /** @hidden @internal */
+    static ANONTYPE_PREFIX = "_IB_";
+    /** The version of any MetadataStores created by this class */
+    static metadataVersion = '1.0.5';
+    /** An optional name for this MetadataStore, set with {@link MetadataStore.setProperties}.
+    {@link MetadataStore.exportMetadata} writes it, but {@link MetadataStore.importMetadata} does not
+    restore it. When {@link EntityManager.exportEntities} leaves out the metadata it records this name,
+    and {@link EntityManager.importEntities} passes it to {@link ImportConfig.metadataVersionFn}. */
+    name;
+    /** The {@link DataService}s this store has metadata for, one per service name. Entries are added by
+    {@link MetadataStore.fetchMetadata}, {@link MetadataStore.importMetadata} and
+    {@link MetadataStore.addDataService}. __Read Only__ */
+    dataServices;
+    /** The  {@link NamingConvention} associated with this MetadataStore. __Read Only__ */
+    namingConvention;
+    /** The  {@link LocalQueryComparisonOptions} associated with this MetadataStore. __Read Only__ */
+    localQueryComparisonOptions;
+    /** A function that customizes how data property values are serialized, both when entities are
+    sent to the server in a save and when {@link EntityManager.exportEntities} writes them. It is called
+    as `serializerFn(property, value)`; its return value is used in place of `value`, and returning
+    `undefined` leaves the property out. Applies to every type in the store that has no
+    `serializerFn` of its own (see {@link EntityType.serializerFn}). */
+    serializerFn;
+    /**
+    An {@link BreezeEvent} that fires after a MetadataStore has completed fetching metadata from a remote service.
+    
+    @eventArgs -
+      - metadataStore - The MetadataStore into which the metadata was fetched.
+      - dataService - The {@link DataService} that metadata was fetched from.
+      - rawMetadata - {Object} The raw metadata returned from the service. (It will have already been processed by this point).
+    ```ts
+    const ms = myEntityManager.metadataStore;
+    ms.metadataFetched.subscribe(args => {
+        const metadataStore = args.metadataStore;
+        const dataService = args.dataService;
+    });
+    ```
+    @event
+    */
+    metadataFetched;
+    /** @hidden @internal */
+    _resourceEntityTypeMap;
+    /** @hidden @internal */
+    _entityTypeResourceMap;
+    /** @hidden @internal key is qualified structuraltype name - value is structuralType. ( structural = entityType or complexType). */
+    _structuralTypeMap;
+    /** @hidden @internal key is shortName, value is qualified name - does not need to be serialized. */
+    _shortNameMap;
+    /** @hidden @internal key is either short or qual type name - value is ctor; */
+    _ctorRegistry;
+    /** @hidden @internal key is entityTypeName; value is array of nav props */
+    _incompleteTypeMap;
+    /** @hidden @internal */
+    _incompleteComplexTypeMap;
+    /** @hidden @internal { json: any, stype: StructuralType }[] */
+    _deferredTypes;
+    /** @hidden @internal */
+    _id;
+    /** @hidden @internal Whether the comparison options were chosen on the client; they then win over imported metadata. */
+    _hasClientLqco;
+    /**
+    Constructs a new MetadataStore.
+    
+    ```ts
+    const ms = new MetadataStore();
+    ```
+  
+    The store can then be associated with an EntityManager
+    ```ts
+    const entityManager = new EntityManager({
+        serviceName: "breeze/NorthwindIBModel",
+        metadataStore: ms
+    });
+    ```
+  
+    or for an existing EntityManager
+    ```ts
+    // 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. Options passed
+    here, or made the default with setAsDefault(), win over any that imported metadata names.
+      - 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()
+            .whereParam("name").isOptional().isString()
+            .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 = new Map(); // key is shortName, value is qualified name - does not need to be serialized.
+        this._ctorRegistry = new Map(); // key is either short or qual type name - value is ctor;
+        this._incompleteTypeMap = new Map(); // key is entityTypeName; value is array of nav props
+        this._incompleteComplexTypeMap = new Map(); // key is complexTypeName; value is array of complexType props
+        this._id = MetadataStore.__id++;
+        this.metadataFetched = new BreezeEvent("metadataFetched", this);
+        // Comparison options passed here, or made the default with setAsDefault(), are a client-side choice:
+        // importMetadata keeps them rather than adopting the ones the metadata names.
+        this._hasClientLqco = config.localQueryComparisonOptions != null ||
+            LocalQueryComparisonOptions.defaultInstance.name !== LocalQueryComparisonOptions.caseInsensitiveSQL.name;
+    }
+    /** __Dev Only__ - for use when writing a {@link DataServiceAdapter} or {@link JsonResultsAdapter}.
+    Converts a type name as a server sends it, such as the .NET `"Northwind.Models.Customer, Northwind"`,
+    into Breeze's qualified form, `"Customer:#Northwind.Models"`. Results are cached; a null or empty
+    name is returned unchanged. */
+    // needs to be made avail to dataService.xxx files
+    static normalizeTypeName = core.memoize(function (rawTypeName) {
+        return rawTypeName && MetadataStore.parseTypeName(rawTypeName).typeName;
+    });
+    // for debugging use the line below instead.
+    //ctor.normalizeTypeName = function (rawTypeName) { return parseTypeName(rawTypeName).typeName; };
+    /**
+    General purpose property set method
+    
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    em1.metadataStore.setProperties({
+        name: "Northwind v6.1.3",
+        serializerFn: (prop, value) => 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 {@link 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 or ComplexType to this MetadataStore. Properties can still be added to the
+    type afterwards, until the first entity of that type is attached to an EntityManager - after
+    that the type is frozen.
+    @param stype - 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.set(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.getCtor();
+        }
+    }
+    /**
+    Exports this MetadataStore to a serialized string appropriate for local storage.   This operation is also called
+    internally when exporting an EntityManager.
+    ```ts
+    // assume ms is a previously created MetadataStore
+    const metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    // and later, usually in a different session imported
+    const metadataFromStorage = window.localStorage.getItem("metadata");
+    const newMetadataStore = new MetadataStore();
+    newMetadataStore.importMetadata(metadataFromStorage);
+    ```
+    @returns 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.
+      
+    ```ts
+    // assume ms is a previously created MetadataStore
+    const metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    // and later, usually in a different session
+    const metadataFromStorage = window.localStorage.getItem("metadata");
+    const newMetadataStore = new MetadataStore();
+    newMetadataStore.importMetadata(metadataFromStorage);
+    ```
+  
+    A type that is already in this store is left as it is unless 'allowMerge' is set, so importing the same metadata
+    twice is harmless. A type that is not in the store is created, with or without 'allowMerge', and its metadata must
+    include 'dataProperties'. The 'localQueryComparisonOptions' the metadata names are adopted only by an empty store
+    whose own options were not chosen on the client (see the constructor).
+    @param exportedMetadata - A previously exported MetadataStore.
+    @param allowMerge -  Allows custom metadata to be merged into existing metadata types.
+    @returns This MetadataStore.
+    @chainable
+    */
+    importMetadata(exportedMetadata, allowMerge = false) {
+        assertParam(allowMerge, "allowMerge").isOptional().isBoolean().check();
+        this._deferredTypes = new Map();
+        // 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);
+        // CSDL (the OData / EDMX format) has a schema property. 2.x parsed it; v3 does not, and
+        // without this check it imported silently as nothing and failed much later.
+        if (metadataJson && metadataJson.schema && !metadataJson.structuralTypes) {
+            throw new Error("This looks like CSDL (OData / EDMX) metadata, which breeze-client 3 does not read. " +
+                "Supply Breeze native JSON metadata instead - see Migrating from 2.x in the Breeze docs.");
+        }
+        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;
+        // Comparison options chosen on the client win; the metadata's apply only to a store without its own.
+        let lqcoName = this._hasClientLqco ? undefined : json.localQueryComparisonOptions;
+        if (this.isEmpty()) {
+            this.namingConvention = config._fetchObject(NamingConvention, ncName) || this.namingConvention;
+            this.localQueryComparisonOptions = (lqcoName && 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);
+        // the serialized form is a plain object; the in-memory form is a Map
+        if (json.incompleteTypeMap) {
+            Object.entries(json.incompleteTypeMap).forEach(([k, v]) => this._incompleteTypeMap.set(k, v));
+        }
+        return this;
+    }
+    /**
+    Creates a new MetadataStore from a previously exported serialized MetadataStore
+    ```ts
+    // assume ms is a previously created MetadataStore
+    const metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    // and later, usually in a different session
+    const metadataFromStorage = window.localStorage.getItem("metadata");
+    const newMetadataStore = MetadataStore.importMetadata(metadataFromStorage);
+    ```
+    @param exportedString - A previously exported MetadataStore.
+    @returns 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.
+    ```ts
+    // Assume em1 is an existing EntityManager.
+    if (!em1.metadataStore.hasMetadataFor("breeze/NorthwindIBModel")) {
+        // do something interesting
+    }
+    ```
+    @param serviceName - The service name.
+    @returns 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
+    ```ts
+    // Assume em1 is an existing EntityManager.
+    const ds = em1.metadataStore.getDataService("breeze/NorthwindIBModel");
+    const adapterName = ds.adapterName; // may be null
+    ```
+    @param serviceName - The service name.
+    @returns 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.
+    ```ts
+    const ms = new MetadataStore();
+    // or more commonly
+    // const ms = anEntityManager.metadataStore;
+    const rawMetadata = await ms.fetchMetadata("breeze/NorthwindIBModel");
+    // do something with the metadata
+    ```
+    @param dataService -  Either a DataService or just the name of the DataService to fetch metadata for.
+    @param callback - Deprecated. Function called on success.
+    @param errorCallback - Deprecated. Function called on failure.
+    @returns 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.
+    ```ts
+    class Customer {
+        miscData = "asdf";    // an unmapped property
+        doFoo() {
+            // ...
+        }
+    }
+    // assume em1 is a preexisting EntityManager;
+    em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
+    // any queries or createEntity 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) {
+                console.warn("Registering a constructor for " + typeName + " that is already used for " + aCtor._$typeName + ".");
+            }
+            aCtor._$typeName = typeName;
+        }
+        this._ctorRegistry.set(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.
+    ```ts
+    // assume em1 is a preexisting EntityManager;
+    if (em1.metadataStore.isEmpty()) {
+        // do something interesting
+    }
+    ```
+    */
+    isEmpty() {
+        return core.isEmpty(this._structuralTypeMap);
+    }
+    /**
+    Returns an {@link EntityType} given a registered class or a type name, or null if there is none
+    and `okIfNotFound` is true.
+    ```ts
+    // assume em1 is a preexisting EntityManager, and OrderDetail is registered with its store
+    const odType = em1.metadataStore.getAsEntityType(OrderDetail);
+    const sameType = em1.metadataStore.getAsEntityType("OrderDetail");
+    ```
+  
+    or to throw an error if the type is not found
+    ```ts
+    const badType = em1.metadataStore.getAsEntityType("Foo", false);
+    // badType will not get set and an exception will be thrown.
+    ```
+    @param type - A class registered with {@link MetadataStore.registerEntityTypeCtor}, or a type
+    name: either the fully qualified name or a short name. 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 return null, rather than throw, if the EntityType is not found.
+    @returns The EntityType, or null if it is not found and `okIfNotFound` is true.
+    */
+    getAsEntityType(type, okIfNotFound = false) {
+        // A class stands for its type name, resolved against this store: a class can be registered
+        // with more than one.
+        const typeName = typeof type === "function" ? entityTypeForCtor(type).name : type;
+        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 {@link EntityType} or null given its name.
+    ```ts
+    // assume em1 is a preexisting EntityManager
+    const locType = em1.metadataStore.getAsComplexType("Location");
+    ```
+  
+    or to throw an error if the type is not found
+    ```ts
+    const badType = em1.metadataStore.getAsComplexType("Foo", false);
+    // badType will not get set and an exception will be thrown.
+    ```
+    @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.
+    @returns 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 {@link EntityType} or a {@link ComplexType} given its name.
+    @deprecated Misleading name: it returns an EntityType *or* a ComplexType. Use
+    {@link MetadataStore.getAsEntityType} or {@link MetadataStore.getAsComplexType} when you know
+    which kind you expect, and {@link MetadataStore.getStructuralType} when either will do.
+    @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.
+    @returns The EntityType. ComplexType or 'null' if not not found.
+    */
+    getEntityType(typeName, okIfNotFound = false) {
+        return this._getStructuralType(typeName, okIfNotFound);
+    }
+    /**
+    Returns an {@link EntityType} or a {@link ComplexType} given its name.
+    ```ts
+    // assume em1 is a preexisting EntityManager
+    const odType = em1.metadataStore.getStructuralType("OrderDetail");
+    ```
+  
+    or to throw an error if the type is not found
+    ```ts
+    const badType = em1.metadataStore.getStructuralType("Foo", false);
+    // badType will not get set and an exception will be thrown.
+    ```
+    Prefer {@link MetadataStore.getAsEntityType} or {@link MetadataStore.getAsComplexType} when you
+    know which kind you expect. This is the lookup for when you do not.
+    @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.
+    @returns 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 = qualTypeName ? this._structuralTypeMap[qualTypeName] : undefined;
+        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 {@link EntityType}s or {@link ComplexType}s in this MetadataStore.
+    ```ts
+    // assume em1 is a preexisting EntityManager
+    const allTypes = em1.metadataStore.getEntityTypes();
+    ```
+    */
+    getEntityTypes() {
+        return getTypesFromMap(this._structuralTypeMap);
+    }
+    /**
+    Returns the navigation properties whose target {@link EntityType} has not been added to this store
+    yet, as one array per missing type. An empty result means every navigation property has been
+    resolved; useful for checking metadata that is built by hand or imported in pieces.
+    */
+    getIncompleteNavigationProperties() {
+        return Array.from(this._incompleteTypeMap.values());
+    }
+    /**
+    Returns a fully qualified entityTypeName for a specified resource name.  The reverse of this operation
+    can be obtained via the  {@link 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) {
+        let typeParts = entityTypeName.split(":#");
+        if (typeParts.length > 1) {
+            return MetadataStore.makeTypeHash(typeParts[0], typeParts[1]);
+        }
+        if (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 {
+            /** The unqualified name, such as `"Customer"`. */
+            shortTypeName: shortName,
+            /** The namespace, such as `"Northwind.Models"`; undefined if there is none. */
+            namespace: ns,
+            /** The qualified name, such as `"Customer:#Northwind.Models"`. */
+            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;
+        }
+    }
+}
+MetadataStore.prototype._$typeName = "MetadataStore";
+BreezeEvent.bubbleEvent(MetadataStore.prototype);
+// The model library Breeze falls back to when none is registered (see default-adapters.ts).
+// Installed here because a MetadataStore needs one even in a bundle with no EntityManager, and
+// this module is in every bundle that has entity types. A getter, because the adapter's module
+// imports this one: while this module loads, the adapter class may not exist yet.
+setDefaultAdapters({ modelLibrary: { get ctor() { return ModelLibraryBackingStoreAdapter; } } });
+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;
+        }
+    }
+    if (!json.dataProperties) {
+        // Creating the type needs its properties. A cut-down custom-metadata object for a type that is not in the store
+        // used to fail here with a TypeError.
+        const hint = allowMerge ? " allowMerge only merges into types that are already in the store." : "";
+        throw new Error("Unable to import type '" + typeName + "': it is not in this MetadataStore and its metadata has no 'dataProperties'." + hint);
+    }
+    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.getMapArray(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.get(stype.name);
+    if (deferrals) {
+        deferrals.forEach(function (d) {
+            completeStructuralTypeFromJson(metadataStore, d.json, d.stype);
+        });
+        deferredTypes.delete(stype.name);
+    }
+}
+function getQualifiedTypeName(metadataStore, structTypeName, throwIfNotFound) {
+    if (isQualifiedTypeName(structTypeName))
+        return structTypeName;
+    let result = metadataStore._shortNameMap.get(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 {
+    /** @hidden @internal */
+    static __nextAnonIx = 0;
+    /** Always false for an EntityType. */
+    isComplexType = false;
+    /** The {@link MetadataStore} that contains this EntityType. __Read Only__ */
+    metadataStore;
+    /** The DataProperties (see {@link DataProperty} associated with this EntityType. __Read Only__  */
+    dataProperties;
+    /**  The NavigationProperties (see {@link NavigationProperty} associated with this EntityType. __Read Only__  */
+    navigationProperties;
+    /**
+    The DataProperties associated with this EntityType that make up it's {@link EntityKey}. __Read Only__ */
+    keyProperties;
+    /** The DataProperties associated with this EntityType that are foreign key properties. __Read Only__ */
+    foreignKeyProperties;
+    /** The foreign key DataProperties on *other* EntityTypes that refer to this EntityType. When an
+    entity's key changes, such as when a temporary key is replaced on save, Breeze uses these to update
+    the foreign keys of cached entities it cannot reach through a navigation property. __Read Only__ */
+    inverseForeignKeyProperties;
+    /**  The DataProperties associated with this EntityType that are concurrency properties. __Read Only__ */
+    concurrencyProperties;
+    /** The DataProperties for this EntityType that contain instances of a {@link ComplexType}. __Read Only__   */
+    complexProperties;
+    /** The DataProperties associated with this EntityType that are not mapped to any backend datastore. These are effectively free standing
+    properties. __Read Only__ */
+    unmappedProperties;
+    /** The fully qualified name of this EntityType. __Read Only__  */
+    name;
+    /** The short, unqualified, name for this EntityType. __Read Only__  */
+    shortName;
+    /** The namespace for this EntityType. __Read Only__  */
+    namespace;
+    /** The name of this EntityType's base EntityType  (if any) */
+    baseTypeName;
+    /** The base EntityType (if any) for this EntityType. __Read Only__   */
+    baseEntityType;
+    /** The EntityTypes that derive directly from this one. See {@link EntityType.getSelfAndSubtypes} for
+    the whole hierarchy. __Read Only__ */
+    subtypes;
+    /**  Whether this EntityType is abstract. __Read Only__ */
+    isAbstract;
+    /**  Whether this EntityType is anonymous. Anonymous types will never be communicated to or from the server. They are purely for
+    client side use and are given an automatically generated name.  __Read Only__ */
+    isAnonymous;
+    /** Whether this EntityType has been 'frozen'.  EntityTypes become frozen after the first instance
+    of that type has been created and attached to an EntityManager. */
+    isFrozen;
+    /** The {@link AutoGeneratedKeyType} for this EntityType. __Read Only__ */
+    autoGeneratedKeyType;
+    /**   The default resource name associated with this EntityType.  An EntityType may be queried via a variety of 'resource names' but this one
+    is used as the default when no resource name is provided.  This will occur when calling {@link EntityAspect.loadNavigationProperty}
+    or when executing any {@link EntityQuery} that was created via an {@link EntityKey}. __Read Only__ */
+    defaultResourceName;
+    /** A function that is used to customize the serialization of any EntityProperties of this type. */
+    serializerFn;
+    /**  A free form object that can be used to define any custom metadata for this EntityType. __Read Only__  */
+    custom;
+    /** The entity level validators associated with this EntityType. Validators can be added and
+    removed from this collection. __Read Only__.   */
+    validators;
+    /** Not used by breeze-client 3: always an empty array. In 2.x the CSDL metadata parser recorded
+    data types it did not recognize here; v3 reports them with `console.warn` instead. */
+    warnings;
+    /** The function, or the name of a method on the entity, that is called with each entity of this type
+    once it has been created and populated, whether by {@link EntityType.createEntity} or from query
+    results. A base type's `initFn` runs first. Set from the `initFn` argument of
+    {@link MetadataStore.registerEntityTypeCtor}; applications set it there rather than here. */
+    initFn;
+    /** The function that a query with {@link EntityQuery.noTracking} enabled calls for each result of this
+    type, as `noTrackingFn(node, entityType)`; its return value replaces the result. Set from the
+    `noTrackingFn` argument of {@link MetadataStore.registerEntityTypeCtor}; applications set it there
+    rather than here. */
+    noTrackingFn;
+    /** @hidden @internal */
+    _extra;
+    /** @hidden @internal */
+    _ctor;
+    /** @hidden @internal */
+    _mappedPropertiesCount;
+    /**
+    @deprecated Use {@link EntityType.getCtor} instead.
+    */
+    getEntityCtor = this.getCtor;
+    /** @hidden @internal */
+    static qualifyTypeName = qualifyTypeName;
+    /** EntityType constructor
+    ```ts
+    const 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) {
+        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
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("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;
+    }
+    /**
+    Returns the entity level validators that apply to this type: its own {@link EntityType.validators}
+    followed by those of each base type. Returns a new array, so changing it does not change the type.
+    */
+    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  {@link DataProperty} or a {@link NavigationProperty} to this EntityType.
+    ```ts
+    // 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);
+            }
+        }
+    }
+    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)
+    @returns The constructor for this EntityType.
+    */
+    getCtor(forceRefresh = false) {
+        if (this._ctor && !forceRefresh)
+            return this._ctor;
+        let ctorRegistry = this.metadataStore._ctorRegistry;
+        let r = ctorRegistry.get(this.name) || ctorRegistry.get(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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const countryProp = custType.getProperty("country");
+    const valFn = (v: string | null) => v == null || v.startsWith("US");
+    const 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
+    ```ts
+    countryProp.validators.push(countryValidator);
+    ```
+  
+    Entity level validators can also be added by omitting the 'property' parameter.
+    ```ts
+    custType.addValidator(someEntityLevelValidator);
+    ```
+  
+    or
+    ```ts
+    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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const arrayOfProps = custType.getProperties();
+    ```
+    @returns 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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const arrayOfPropNames = custType.getPropertyNames();
+    ```
+    */
+    getPropertyNames() {
+        return this.getProperties().map(core.pluck('name'));
+    }
+    /**
+    Returns a data property with the specified name or null.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const companyNameDataProp = custType.getDataProperty("companyName");
+    ```
+    @returns 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.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const customerOrdersNavProp = custType.getNavigationProperty("orders");
+    ```
+    @returns 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.
+    ```ts
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const companyNameProp = custType.getProperty("companyName");
+    ```
+  
+    This method can also walk a property path to return a property
+    ```ts
+    const orderDetailType = em1.metadataStore.getAsEntityType("OrderDetail");
+    const companyNameProp2 = orderDetailType.getProperty("order.customer.companyName");
+    // companyNameProp === companyNameProp2
+    ```
+    @param [throwIfNotFound=false] {Boolean} Whether to throw an exception if not found.
+    @returns 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;
+    }
+    /** Translates a client-side property path into the names the server uses, applying this type's
+    {@link NamingConvention} to each segment: with the default camelCase convention,
+    `"company.companyName"` becomes `"Company.CompanyName"`. A {@link UriBuilderAdapter} uses it to
+    write a query the server can read.
+    @param propertyPath - a path of property names separated by `.`
+    @param delimiter - what to join the server names with. Defaults to `.`
+    @returns The same path in server terms. */
+    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);
+    }
+    /** Builds the {@link EntityKey} for an entity still in its raw server form, before it has been
+    materialized. A {@link DataServiceAdapter} or {@link JsonResultsAdapter} uses it to find out whether
+    the cache already holds the entity a node describes.
+    @param rawEntity - the untyped node as it arrived from the server
+    @param rawValueFn - reads one {@link DataProperty} off that node. It is given the node and the
+    property, and is what knows whether the node is keyed by client or by server names
+    @returns The key, with each value parsed into its property's {@link DataType}. */
+    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;
+    }
+    /**
+    Returns this type's metadata as a plain object in Breeze's native JSON metadata format, leaving out
+    default values and empty arrays. Only the properties this type declares are included, not those it
+    inherits from a base type. `JSON.stringify` calls it when {@link MetadataStore.exportMetadata}
+    serializes the store.
+    */
+    toJSON() {
+        return core.toJson(this, {
+            shortName: null,
+            namespace: null,
+            baseTypeName: null,
+            isAbstract: false,
+            autoGeneratedKeyType: null, // do not suppress default value
+            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.getMapArray(incompleteTypeMap, cp.complexTypeName).push(cp);
+            }
+        });
+        if (this.isComplexType) {
+            (incompleteTypeMap.get(this.name) || []).forEach(function (cp) {
+                resolveCp(cp, metadataStore);
+            });
+            incompleteTypeMap.delete(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.get(this.name) || []).forEach(function (np) {
+            tryResolveNp(np, metadataStore);
+        });
+        // every navProp that pointed to this type should now be resolved
+        incompleteTypeMap.delete(this.name);
+    }
+}
+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) {
+    // The only reason this ever built a function from a string was the name: a constructor made
+    // with Function('return function Order(){}')() shows as Order in a debugger. Function.name is
+    // configurable, so it can simply be set - and Breeze then contains no eval and no
+    // new Function, which is what a strict Content Security Policy forbids.
+    const ctor = function () { };
+    Object.defineProperty(ctor, 'name', { value: type.name.replace(/\W/g, '_'), configurable: true });
+    return ctor;
+}
+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.getMapArray(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.
+```ts
+const complexType = new ComplexType({
+    shortName: "address",
+    namespace: "myAppNamespace"
+});
+```
+@param config - Configuration settings
+*/
+export class ComplexType {
+    /** For polymorphic purpose only - always true here */
+    isComplexType = true;
+    /** The {@link MetadataStore} containing this ComplexType. */
+    metadataStore;
+    /**  The fully qualifed name of this ComplexType. __Read Only__  */
+    name;
+    /**  The short, unqualified, name for this ComplexType. __Read Only__ */
+    shortName;
+    /** The namespace for this ComplexType. __Read Only__ */
+    namespace;
+    /** The DataProperties (see {@link DataProperty} associated with this ComplexType. __Read Only__ */
+    dataProperties;
+    /** The DataProperties for this ComplexType that contain instances of a {@link ComplexType}. __Read Only__ */
+    complexProperties;
+    /**
+    The entity level validators associated with this ComplexType. Validators can be added and
+    removed from this collection. __Read Only__  */
+    validators;
+    /** For polymorphic purpose only - always empty here */
+    concurrencyProperties;
+    /** The DataProperties associated with this ComplexType that are not mapped to any backend datastore. These are effectively free standing
+    properties. __Read Only__   */
+    unmappedProperties;
+    /** Always empty: a ComplexType has no navigation properties. Present so that code can treat an
+    EntityType and a ComplexType alike. __Read Only__ */
+    // keyProperties and navigationProperties are not used on complexTypes - but here to allow sharing of code between EntityType and ComplexType.
+    navigationProperties;
+    /** Always empty: a ComplexType has no key. Present so that code can treat an EntityType and a
+    ComplexType alike. __Read Only__ */
+    // and may be used later to enforce uniqueness on arrays of complextypes.
+    keyProperties;
+    /** Not used by breeze-client 3, and never set on a ComplexType. See {@link EntityType.warnings}. */
+    warnings;
+    /** A function that customizes how this type's data properties are serialized when an entity holding
+    it is saved; see {@link MetadataStore.serializerFn}, which is used when this is not set. The
+    constructor does not accept it: assign it directly. */
+    serializerFn;
+    /** A free form object that can be used to define any custom metadata for this ComplexType. */
+    custom;
+    /** @hidden @internal */
+    _mappedPropertiesCount;
+    /** @hidden @internal */
+    _extra;
+    // copy entityType methods onto complexType
+    /** See {@link EntityType.getCtor} */
+    getCtor = EntityType.prototype.getCtor;
+    /** Creates a new instance of this ComplexType, optionally setting the property values given in
+    `initialValues`; the ComplexType counterpart of {@link EntityType.createEntity}.
+    ```ts
+    const locType = em1.metadataStore.getAsComplexType("Location");
+    const loc = locType.createInstance<Location>({ city: "Boston" });   // Location, unchecked
+    ```
+    */
+    // note the name change.
+    createInstance = EntityType.prototype.createEntity;
+    /** See [EntityType.addValidator] */
+    addValidator = EntityType.prototype.addValidator;
+    /** Returns the {@link DataProperty} with the specified name, or null. Also accepts a `.` delimited
+    path through nested complex properties. See {@link EntityType.getProperty}. */
+    getProperty = EntityType.prototype.getProperty;
+    /** Returns the properties along a `.` delimited property path, one per segment, or null if a segment
+    is not found (unless `throwIfNotFound` is true, which throws instead). `useServerName` matches
+    segments against `nameOnServer` when true, `name` when false, and either when null. Used by Breeze
+    internally; applications normally use {@link ComplexType.getProperty}. */
+    getPropertiesOnPath = EntityType.prototype.getPropertiesOnPath;
+    /** Returns the names of all of this type's data properties. */
+    getPropertyNames = EntityType.prototype.getPropertyNames;
+    /** @hidden @internal */
+    _addPropertyCore = EntityType.prototype._addPropertyCore;
+    /** @hidden @internal */
+    _addDataProperty = EntityType.prototype._addDataProperty;
+    /** @hidden @internal */
+    _updateNames = EntityType.prototype._updateNames;
+    /** @hidden @internal */
+    _updateCps = EntityType.prototype._updateCps;
+    /** @hidden @internal */
+    _initializeInstance = EntityType.prototype._initializeInstance;
+    /** @hidden @internal */
+    _updateTargetFromRaw = EntityType.prototype._updateTargetFromRaw;
+    /** @hidden @internal */
+    _setCtor = EntityType.prototype._setCtor;
+    /** Creates a ComplexType from a {@link ComplexTypeConfig}. Add it to a {@link MetadataStore}
+    with {@link MetadataStore.addEntityType} before using it. */
+    constructor(config) {
+        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
+    ```ts
+    // assume em1 is an EntityManager
+    const locType = em1.metadataStore.getAsComplexType("Location");
+    locType.setProperties({
+        custom: { foo: 7, bar: "test" }
+    });
+    ```
+    @param config - Custom config object
+    @param config.custom - {Object}
+    */
+    setProperties(config) {
+        assertConfig(config)
+            .whereParam("custom").isOptional()
+            .applyAll(this);
+    }
+    /** Returns the type level validators for this ComplexType: its own {@link ComplexType.validators}
+    array itself, not a copy, since ComplexTypes have no base types. */
+    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;
+    }
+    /** Adds a {@link DataProperty} to this ComplexType.
+    ```ts
+    // assume addressType is a newly constructed ComplexType.
+    addressType.addProperty(new DataProperty({ name: "city", dataType: DataType.String }));
+    ```
+    */
+    addProperty(dataProperty) {
+        assertParam(dataProperty, "dataProperty").isInstanceOf(DataProperty).check();
+        return this._addPropertyCore(dataProperty);
+    }
+    /** Returns all of the properties of this ComplexType: its {@link ComplexType.dataProperties} array
+    itself, not a copy. */
+    getProperties() {
+        return this.dataProperties;
+    }
+    /** Returns this type's metadata as a plain object in Breeze's native JSON metadata format, leaving
+    out default values and empty arrays. `JSON.stringify` calls it when
+    {@link MetadataStore.exportMetadata} serializes the store. */
+    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  {@link 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 {
+    /** Is this a DataProperty? - always true here. Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isDataProperty = true;
+    /** Is this a NavigationProperty? - always false here.  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isNavigationProperty = false;
+    /** DataProperty constructor
+    ```ts
+    const lastNameProp = new DataProperty({
+        name: "lastName",
+        dataType: DataType.String,
+        isNullable: true,
+        maxLength: 20
+    });
+    // assuming personEntityType is a newly constructed EntityType
+    personEntityType.addProperty(lastNameProp);
+    ```
+    @param config - A configuration Object or a DataProperty
+    */
+    constructor(config) {
+        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;
+        }
+    }
+    /**
+    Reads a property's value from a raw entity whose keys are server property names, such as a node
+    in query results. Returns the property's `defaultValue` when the node has no value for it; for an
+    unmapped property it reads `nameOnServer`, falling back to `name`, and applies no default. Pass it as
+    the `rawValueFn` of {@link EntityType.getEntityKeyFromRawEntity} when writing an adapter;
+    applications do not normally need it.
+    */
+    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;
+        }
+    }
+    /**
+    Reads a property's value from a raw entity whose keys are client property names, such as an entity
+    in the output of {@link EntityManager.exportEntities}. Returns the property's `defaultValue` when the
+    raw entity has no value for it. The client-name counterpart of
+    {@link DataProperty.getRawValueFromServer}; applications do not normally need it.
+    */
+    static getRawValueFromClient(rawEntity, dp) {
+        let val = rawEntity[dp.name];
+        return val !== undefined ? val : dp.defaultValue;
+    }
+    /**
+    Returns the value of the named field of this property, such as `"displayName"`. If it is null or
+    undefined here, the value is taken from the property this one inherits from on a base type (see
+    {@link DataProperty.baseProperty}), and so on up the hierarchy. Validation uses it to find a
+    property's display name.
+    */
+    resolveProperty(propName) {
+        let result = this[propName];
+        let baseProp = this.baseProperty;
+        while (result == undefined && baseProp != null) {
+            result = baseProp[propName];
+            baseProp = baseProp.baseProperty;
+        }
+        return result;
+    }
+    /** Returns a name that identifies this property across the store: the qualified name of its parent
+    type and the property name, joined by `--`. Breeze uses it in error messages and to generate
+    association names; applications do not normally need it. */
+    formatName() {
+        return this.parentType.name + "--" + this.name;
+    }
+    /**
+    General purpose property set method
+    ```ts
+    // assume myEntityType is an EntityType
+    const 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);
+    }
+    /** Returns the validators that apply to this property: its own {@link DataProperty.validators}
+    followed by those of the properties it inherits from on base types. Returns a new array. */
+    getAllValidators() {
+        let validators = this.validators.slice(0);
+        let baseProp = this.baseProperty;
+        while (baseProp) {
+            validators.push.apply(validators, baseProp.validators);
+            baseProp = baseProp.baseProperty;
+        }
+        return validators;
+    }
+    /** Returns this property's metadata as a plain object in Breeze's native JSON metadata format,
+    leaving out default values; a complex property is described by its `complexTypeName`. Used when
+    {@link MetadataStore.exportMetadata} serializes the store. */
+    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;
+            }, // do not serialize dataTypes that are complexTypes
+            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
+        });
+    }
+    /** Creates a DataProperty from the JSON form that {@link DataProperty.toJSON} produces. Used by
+    {@link MetadataStore.importMetadata}. A `dataType` name the client does not know becomes
+    {@link DataType.Undefined}, with the name kept in `rawTypeName` and a console warning. Modifies the
+    object passed in. */
+    static fromJSON(json) {
+        const typeName = json.dataType;
+        json.dataType = DataType.fromName(typeName);
+        if (typeName && !json.dataType) {
+            // A type the client does not know, from a newer server say. Keep the property, as 'Undefined' with the server's
+            // name in 'rawTypeName' - the way the server itself sends spatial types - rather than pass it off as a String.
+            json.dataType = DataType.Undefined;
+            json.rawTypeName = json.rawTypeName || typeName;
+            warnUnknownDataType(typeName);
+        }
+        // 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";
+const _unknownDataTypeNames = new Set();
+function warnUnknownDataType(typeName) {
+    if (_unknownDataTypeNames.has(typeName))
+        return;
+    _unknownDataTypeNames.add(typeName);
+    console.warn("Metadata names a data type the client does not know: '" + typeName +
+        "'. Its properties are imported as DataType.Undefined, with the name in 'rawTypeName'.");
+}
+/**   A NavigationProperty describes the metadata for a single property of an {@link 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 {
+    /** Is this a DataProperty? - always false here
+    Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isDataProperty = false;
+    /** Is this a NavigationProperty? - always true here
+    Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isNavigationProperty = true;
+    /** Returns the qualified name of the parent type and the property name, joined by `--`. See
+    {@link DataProperty.formatName}; applications do not normally need it. */
+    formatName = DataProperty.prototype.formatName;
+    /** Returns the validators that apply to this property, including those inherited from base types.
+    See {@link DataProperty.getAllValidators}. */
+    getAllValidators = DataProperty.prototype.getAllValidators;
+    /** Returns the value of the named field of this property, falling back to the property it inherits
+    from on a base type. See {@link DataProperty.resolveProperty}. */
+    resolveProperty = DataProperty.prototype.resolveProperty;
+    /** NavigationProperty constructor
+    ```ts
+    const homeAddressProp = new NavigationProperty({
+        name: "homeAddress",
+        entityTypeName: "Address:#myNamespace",
+        isScalar: true,
+        associationName: "address_person",
+        foreignKeyNames: ["homeAddressId"]
+    });
+    const homeAddressIdProp = new DataProperty({
+        name: "homeAddressId",
+        dataType: DataType.Int32
+    });
+    // assuming personEntityType is a newly constructed EntityType
+    personEntityType.addProperty(homeAddressProp);
+    personEntityType.addProperty(homeAddressIdProp);
+    ```
+    @param config - A configuration object.
+    */
+    constructor(config) {
+        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
+    ```ts
+    // assume myEntityType is an EntityType
+    const 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;
+    }
+    /**
+    Makes the specified navigation property, on the type this property returns, the inverse of this one.
+    Both get the same {@link NavigationProperty.associationName}: this property's if it has one, otherwise
+    the other's, otherwise a generated one. For metadata built by hand; metadata from the server already
+    pairs inverses by association name. Also available as the `inverse` option of
+    {@link NavigationProperty.setProperties}. Both types must already be in the same MetadataStore.
+    @param inverseNp - The inverse NavigationProperty, or its name on the type this property returns.
+    Throws if it is not found, does not point back at this property's parent type, or either property
+    already has an 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;
+    // };
+    /** Returns this property's metadata as a plain object in Breeze's native JSON metadata format,
+    leaving out default values. Only client-side names are written. Used when
+    {@link MetadataStore.exportMetadata} serializes the store. */
+    toJSON() {
+        return core.toJson(this, {
+            name: null,
+            entityTypeName: null,
+            isScalar: null,
+            associationName: null,
+            validators: null,
+            displayName: null,
+            foreignKeyNames: null,
+            invForeignKeyNames: null,
+            custom: null
+        });
+    }
+    /** Creates a NavigationProperty from the JSON form that {@link NavigationProperty.toJSON} produces.
+    Used by {@link MetadataStore.importMetadata}. Modifies the object passed in. */
+    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
+    */
+    static 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.
+    */
+    static 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.
+    */
+    static KeyGenerator = new AutoGeneratedKeyType();
+}
+AutoGeneratedKeyType.prototype._$typeName = "AutoGeneratedKeyType";
+AutoGeneratedKeyType.resolveSymbols();
+// 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;
+    }
+}
+/**
+The {@link EntityType} a constructor stands for.
+
+{@link MetadataStore.registerEntityTypeCtor} puts the type on the class's prototype, and that is
+what the constructor-taking overloads of `EntityQuery.from`, `EntityManager.createEntity` and the
+rest read. A class that was never registered has nothing to read, so this throws rather than
+letting the caller build a query against `undefined`.
+
+```ts
+em.metadataStore.registerEntityTypeCtor('Customer', Customer);
+entityTypeForCtor(Customer).defaultResourceName;   // 'Customers'
+```
+@param entityCtor - A constructor registered with a MetadataStore.
+*/
+export function entityTypeForCtor(entityCtor) {
+    const entityType = entityCtor && entityCtor.prototype && entityCtor.prototype.entityType;
+    if (!entityType) {
+        const name = (entityCtor && entityCtor.name) || String(entityCtor);
+        throw new Error(core.formatString("'%1' is not registered with a MetadataStore, so its EntityType is unknown. Call " +
+            "metadataStore.registerEntityTypeCtor('%1', %1) before using the constructor with this API.", name));
+    }
+    return entityType;
+}
+// Used by both ComplexType and EntityType
+function addProperties(entityType, propObj, ctor) {
+    if (propObj == null)
+        return;
+    if (Array.isArray(propObj)) {
+        // Each item is a DataProperty/NavigationProperty, or the config to make one from. (Not
+        // forEach(_addPropertyCore): that passed each item's index as `shouldResolve`.)
+        for (const item of propObj) {
+            entityType._addPropertyCore(item instanceof ctor ? item : new ctor(item));
+        }
+    }
+    else if (typeof (propObj) === 'object') {
+        for (let key in propObj) {
+            if (hasOwnProp(propObj, key)) {
+                // A copy with the name added: the caller's config object is left as it was.
+                let value = propObj[key];
+                let prop = new ctor({ ...value, name: key });
+                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=entity-metadata.js.map