breeze-client 2.2.2 → 3.0.0

package/metadata/entity-metadata.d.ts

@@ -0,0 +1,1193 @@
+import { ErrorCallback } from '../core/core.js';
+import { BreezeEvent } from '../core/event.js';
+import { DataType } from './data-type.js';
+import { Entity, StructuralObject } 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';
+/** A property of an {@link EntityType} or {@link ComplexType}: either a {@link DataProperty} or a
+{@link NavigationProperty}. Returned by methods such as {@link EntityType.getProperty}; test
+`isDataProperty` or `isNavigationProperty` to tell which. */
+export type EntityProperty = DataProperty | NavigationProperty;
+/** A type held by a {@link MetadataStore}: either an {@link EntityType} or a {@link ComplexType}.
+Returned by {@link MetadataStore.getStructuralType}; test `isComplexType` to tell which. */
+export type StructuralType = EntityType | ComplexType;
+/** Configuration info to be passed to the {@link MetadataStore} constructor */
+export interface MetadataStoreConfig {
+    /** The  {@link NamingConvention} associated with this MetadataStore. */
+    namingConvention?: NamingConvention;
+    /** The  {@link LocalQueryComparisonOptions} associated with this MetadataStore. */
+    localQueryComparisonOptions?: LocalQueryComparisonOptions;
+    /** Sets {@link MetadataStore.serializerFn}, the default serializer for every type in the store. */
+    serializerFn?: (prop: EntityProperty, val: any) => any;
+    /** Sets {@link MetadataStore.name}. */
+    name?: string;
+}
+/** The argument passed to subscribers of the {@link MetadataStore.metadataFetched} event. */
+export interface MetadataFetchedEventArgs {
+    /** The MetadataStore into which the metadata was fetched. */
+    metadataStore: MetadataStore;
+    /** The {@link DataService} the metadata was fetched from. */
+    dataService: DataService | string;
+    /** The metadata as the server returned it, parsed from JSON. It has already been imported into
+    the store when the event fires. */
+    rawMetadata: any;
+}
+/**
+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 declare class MetadataStore {
+    /** The version of any MetadataStores created by this class */
+    static metadataVersion: string;
+    /** 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: string;
+    /** 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: DataService[];
+    /** The  {@link NamingConvention} associated with this MetadataStore. __Read Only__ */
+    namingConvention: NamingConvention;
+    /** The  {@link LocalQueryComparisonOptions} associated with this MetadataStore. __Read Only__ */
+    localQueryComparisonOptions: 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?: (prop: EntityProperty, val: any) => any;
+    /**
+    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: BreezeEvent<MetadataFetchedEventArgs>;
+    /**
+    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?: MetadataStoreConfig);
+    /** __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. */
+    static normalizeTypeName: any;
+    /**
+    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: MetadataStoreConfig): void;
+    /**
+    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: DataService, shouldOverwrite?: boolean): void;
+    /**
+    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: StructuralType | EntityTypeConfig | ComplexTypeConfig): void;
+    /**
+    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(): string;
+    /**
+    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: string | Object, allowMerge?: boolean): 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: string): MetadataStore;
+    /**
+    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: string): boolean;
+    /**
+    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: string): DataService;
+    fetchMetadata(dataService: string | DataService): Promise<any>;
+    /** @deprecated Await the returned promise instead of passing callbacks. */
+    fetchMetadata(dataService: string | DataService, callback?: (schema: any) => void, errorCallback?: ErrorCallback): Promise<any>;
+    /**
+    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: any, interceptor: any): void;
+    /**
+    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: string, aCtor?: any, initFn?: Function | string, noTrackingFn?: Function): void;
+    /**
+    Returns whether this MetadataStore contains any metadata yet.
+    ```ts
+    // assume em1 is a preexisting EntityManager;
+    if (em1.metadataStore.isEmpty()) {
+        // do something interesting
+    }
+    ```
+    */
+    isEmpty(): boolean;
+    getAsEntityType(type: string | (new () => Entity), okIfNotFound?: false): EntityType;
+    getAsEntityType(type: string | (new () => Entity), okIfNotFound: boolean): EntityType | null;
+    /**
+    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: string, okIfNotFound?: boolean): ComplexType | null;
+    /**
+    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: string, okIfNotFound?: boolean): StructuralType | null;
+    /**
+    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: string, okIfNotFound?: boolean): StructuralType | null;
+    /**
+    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(): StructuralType[];
+    /**
+    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(): NavigationProperty[][];
+    /**
+    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: string): string;
+    /**
+    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: string, entityTypeOrName: EntityType | string): void;
+    /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */
+    static parseTypeName(entityTypeName: string): {
+        /** The unqualified name, such as `"Customer"`. */
+        shortTypeName: string;
+        /** The namespace, such as `"Northwind.Models"`; undefined if there is none. */
+        namespace: string | undefined;
+        /** The qualified name, such as `"Customer:#Northwind.Models"`. */
+        typeName: string;
+    };
+    /** __Dev Only__ - for use when creating a new MetadataParserAdapter  */
+    static makeTypeHash(shortName: string, ns?: string): {
+        /** The unqualified name, such as `"Customer"`. */
+        shortTypeName: string;
+        /** The namespace, such as `"Northwind.Models"`; undefined if there is none. */
+        namespace: string | undefined;
+        /** The qualified name, such as `"Customer:#Northwind.Models"`. */
+        typeName: string;
+    };
+}
+/** Configuration info to be passed to the {@link EntityType} constructor */
+export interface EntityTypeConfig {
+    /** The unqualified name of the type, such as `"Customer"`. Required, although the interface marks it optional. */
+    shortName?: string;
+    /** The namespace of the type. Defaults to `""`. The type's {@link EntityType.name} is `shortName:#namespace`. */
+    namespace?: string;
+    /** The name, short or qualified, of the base EntityType this type inherits from. The base type must
+    already be in the {@link MetadataStore} when this type is added to it. */
+    baseTypeName?: string;
+    /** Whether the type is abstract, i.e. only its subtypes have instances. An abstract type may be added to
+    a MetadataStore without key properties. Defaults to `false`. */
+    isAbstract?: boolean;
+    /** How keys of new entities are generated. Defaults to {@link AutoGeneratedKeyType.None}, in which case a
+    subtype takes its base type's setting. */
+    autoGeneratedKeyType?: AutoGeneratedKeyType;
+    /** The resource name used to query this type when no other is given; see
+    {@link EntityType.defaultResourceName}. If omitted, a subtype takes its base type's. */
+    defaultResourceName?: string;
+    /** The type's data properties: an object whose keys are property names and whose values are
+    {@link DataPropertyConfig} objects, or an array of {@link DataProperty} instances or of
+    DataPropertyConfig objects that each include a `name`. */
+    dataProperties?: DataProperty[] | DataPropertyConfig[] | Object;
+    /** The type's navigation properties: an object whose keys are property names and whose values are
+    {@link NavigationPropertyConfig} objects, or an array of {@link NavigationProperty} instances or of
+    NavigationPropertyConfig objects that each include a `name`. */
+    navigationProperties?: NavigationProperty[] | NavigationPropertyConfig[] | Object;
+    /** Sets {@link EntityType.serializerFn}. */
+    serializerFn?: (prop: EntityProperty, val: any) => any;
+    /** Sets {@link EntityType.custom}. */
+    custom?: any;
+}
+/** Configuration info to be passed to the {@link EntityType.setProperties} method */
+export interface EntityTypeSetConfig {
+    /** Sets {@link EntityType.autoGeneratedKeyType}. */
+    autoGeneratedKeyType?: AutoGeneratedKeyType;
+    /** Sets {@link EntityType.defaultResourceName}. */
+    defaultResourceName?: string;
+    /** Sets {@link EntityType.serializerFn}. */
+    serializerFn?: (prop: EntityProperty, val: any) => any;
+    /** Sets {@link EntityType.custom}. */
+    custom?: any;
+}
+/** Container for all of the metadata about a specific type of Entity.
+*/
+export declare class EntityType {
+    /** Always false for an EntityType. */
+    isComplexType: boolean;
+    /** The {@link MetadataStore} that contains this EntityType. __Read Only__ */
+    metadataStore: MetadataStore;
+    /** The DataProperties (see {@link DataProperty} associated with this EntityType. __Read Only__  */
+    dataProperties: DataProperty[];
+    /**  The NavigationProperties (see {@link NavigationProperty} associated with this EntityType. __Read Only__  */
+    navigationProperties: NavigationProperty[];
+    /**
+    The DataProperties associated with this EntityType that make up it's {@link EntityKey}. __Read Only__ */
+    keyProperties: DataProperty[];
+    /** The DataProperties associated with this EntityType that are foreign key properties. __Read Only__ */
+    foreignKeyProperties: DataProperty[];
+    /** 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: DataProperty[];
+    /**  The DataProperties associated with this EntityType that are concurrency properties. __Read Only__ */
+    concurrencyProperties: DataProperty[];
+    /** The DataProperties for this EntityType that contain instances of a {@link ComplexType}. __Read Only__   */
+    complexProperties: DataProperty[];
+    /** The DataProperties associated with this EntityType that are not mapped to any backend datastore. These are effectively free standing
+    properties. __Read Only__ */
+    unmappedProperties: DataProperty[];
+    /** The fully qualified name of this EntityType. __Read Only__  */
+    name: string;
+    /** The short, unqualified, name for this EntityType. __Read Only__  */
+    shortName: string;
+    /** The namespace for this EntityType. __Read Only__  */
+    namespace: string;
+    /** The name of this EntityType's base EntityType  (if any) */
+    baseTypeName?: string;
+    /** The base EntityType (if any) for this EntityType. __Read Only__   */
+    baseEntityType: EntityType;
+    /** The EntityTypes that derive directly from this one. See {@link EntityType.getSelfAndSubtypes} for
+    the whole hierarchy. __Read Only__ */
+    subtypes: EntityType[];
+    /**  Whether this EntityType is abstract. __Read Only__ */
+    isAbstract: boolean;
+    /**  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: boolean;
+    /** 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: boolean;
+    /** The {@link AutoGeneratedKeyType} for this EntityType. __Read Only__ */
+    autoGeneratedKeyType: 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: string;
+    /** A function that is used to customize the serialization of any EntityProperties of this type. */
+    serializerFn?: (prop: EntityProperty, val: any) => any;
+    /**  A free form object that can be used to define any custom metadata for this EntityType. __Read Only__  */
+    custom?: any;
+    /** The entity level validators associated with this EntityType. Validators can be added and
+    removed from this collection. __Read Only__.   */
+    validators: Validator[];
+    /** 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: any[];
+    /** 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?: Function | string;
+    /** 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?: Function;
+    /**
+    @deprecated Use {@link EntityType.getCtor} instead.
+    */
+    getEntityCtor: (forceRefresh?: boolean) => {
+        new (): StructuralObject;
+    };
+    /** 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: MetadataStore | EntityTypeConfig);
+    /**
+    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: EntityTypeSetConfig): void;
+    /**
+    Returns whether this type is a subtype of a specified type.
+    */
+    isSubtypeOf(entityType: EntityType): boolean;
+    /**
+    Returns an array containing this type and any/all subtypes of this type down thru the hierarchy.
+    */
+    getSelfAndSubtypes(): this[];
+    /**
+    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(): Validator[];
+    /**
+    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: EntityProperty): void;
+    /**
+    Creates a new entity of this type, detached: add it to a manager with {@link EntityManager.addEntity},
+    or use {@link EntityManager.createEntity}, which does both.
+    ```ts
+    // assume em1 is an EntityManager containing a number of existing entities.
+    const custType = em1.metadataStore.getAsEntityType("Customer");
+    const cust1 = custType.createEntity<Customer>({ companyName: "Acme" });   // Customer
+    em1.addEntity(cust1);
+    ```
+  
+    `T` is the type you expect back. Nothing checks it - an EntityType knows its metadata, not your
+    class - and it defaults to `any`.
+    ```ts
+    const order = custType.createEntity<Order>();   // compiles, but creates a Customer
+    ```
+    @param initialValues - Property values to set immediately after creation.
+    @returns The new entity.
+    */
+    createEntity<T = any>(initialValues?: any): T;
+    /**
+    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?: boolean): {
+        new (): StructuralObject;
+    };
+    /**
+    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: Validator, property?: EntityProperty | string): void;
+    /**
+    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(): EntityProperty[];
+    /**
+    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(): any[];
+    /**
+    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: string): DataProperty;
+    /**
+    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: string): NavigationProperty;
+    /**
+    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: string, throwIfNotFound?: boolean): EntityProperty | 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: string, delimiter?: string): string;
+    /** 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: any, rawValueFn: Function): EntityKey;
+    /**
+    Returns a string representation of this EntityType.
+    */
+    toString(): string;
+    /**
+    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(): Object;
+}
+/** Configuration info to be passed to the {@link ComplexType} constructor, or to
+{@link MetadataStore.addEntityType} to create a ComplexType there. */
+export interface ComplexTypeConfig {
+    /** The unqualified name of the type, such as `"Location"`. Required, although the interface marks it optional. */
+    shortName?: string;
+    /** The namespace of the type. Defaults to `""`. The type's {@link ComplexType.name} is `shortName:#namespace`. */
+    namespace?: string;
+    /** The type's data properties: an object whose keys are property names and whose values are
+    {@link DataPropertyConfig} objects, or an array of {@link DataProperty} instances or of
+    DataPropertyConfig objects that each include a `name`. */
+    dataProperties?: DataProperty[] | DataPropertyConfig[] | Object;
+    /** Set to `true` when passing this config to {@link MetadataStore.addEntityType}, which otherwise creates
+    an EntityType. The ComplexType constructor does not need it. */
+    isComplexType?: boolean;
+    /** Sets {@link ComplexType.custom}. */
+    custom?: any;
+}
+/**  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 declare class ComplexType {
+    /** For polymorphic purpose only - always true here */
+    isComplexType: boolean;
+    /** The {@link MetadataStore} containing this ComplexType. */
+    metadataStore: MetadataStore;
+    /**  The fully qualifed name of this ComplexType. __Read Only__  */
+    name: string;
+    /**  The short, unqualified, name for this ComplexType. __Read Only__ */
+    shortName: string;
+    /** The namespace for this ComplexType. __Read Only__ */
+    namespace: string;
+    /** The DataProperties (see {@link DataProperty} associated with this ComplexType. __Read Only__ */
+    dataProperties: DataProperty[];
+    /** The DataProperties for this ComplexType that contain instances of a {@link ComplexType}. __Read Only__ */
+    complexProperties: DataProperty[];
+    /**
+    The entity level validators associated with this ComplexType. Validators can be added and
+    removed from this collection. __Read Only__  */
+    validators: Validator[];
+    /** For polymorphic purpose only - always empty here */
+    concurrencyProperties: DataProperty[];
+    /** The DataProperties associated with this ComplexType that are not mapped to any backend datastore. These are effectively free standing
+    properties. __Read Only__   */
+    unmappedProperties: DataProperty[];
+    /** Always empty: a ComplexType has no navigation properties. Present so that code can treat an
+    EntityType and a ComplexType alike. __Read Only__ */
+    navigationProperties: DataProperty[];
+    /** Always empty: a ComplexType has no key. Present so that code can treat an EntityType and a
+    ComplexType alike. __Read Only__ */
+    keyProperties: DataProperty[];
+    /** Not used by breeze-client 3, and never set on a ComplexType. See {@link EntityType.warnings}. */
+    warnings: any[];
+    /** 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?: (prop: EntityProperty, val: any) => any;
+    /** A free form object that can be used to define any custom metadata for this ComplexType. */
+    custom?: any;
+    /** See {@link EntityType.getCtor} */
+    getCtor: (forceRefresh?: boolean) => {
+        new (): StructuralObject;
+    };
+    /** 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
+    ```
+    */
+    createInstance: <T = any>(initialValues?: any) => T;
+    /** See [EntityType.addValidator] */
+    addValidator: (validator: Validator, property?: EntityProperty | string) => void;
+    /** Returns the {@link DataProperty} with the specified name, or null. Also accepts a `.` delimited
+    path through nested complex properties. See {@link EntityType.getProperty}. */
+    getProperty: (propertyPath: string, throwIfNotFound?: boolean) => EntityProperty | null;
+    /** 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: (propertyPath: string, useServerName: boolean | null, throwIfNotFound?: boolean) => EntityProperty[] | null;
+    /** Returns the names of all of this type's data properties. */
+    getPropertyNames: () => any[];
+    /** Creates a ComplexType from a {@link ComplexTypeConfig}. Add it to a {@link MetadataStore}
+    with {@link MetadataStore.addEntityType} before using it. */
+    constructor(config: ComplexTypeConfig);
+    /**
+    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: {
+        custom?: any;
+    }): void;
+    /** 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(): Validator[];
+    /** 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: DataProperty): void;
+    /** Returns all of the properties of this ComplexType: its {@link ComplexType.dataProperties} array
+    itself, not a copy. */
+    getProperties(): EntityProperty[];
+    /** 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(): Object;
+}
+/** Configuration info to be passed to the {@link DataProperty} constructor. Either `name` or
+`nameOnServer` is required. */
+export interface DataPropertyConfig {
+    /** The client-side name of the property. If omitted, it is derived from `nameOnServer` by the
+    store's {@link NamingConvention} when the property's type is added to a {@link MetadataStore}. */
+    name?: string;
+    /** The name of the property on the server. If omitted, it is derived from `name` by the store's
+    {@link NamingConvention}. */
+    nameOnServer?: string;
+    /** The {@link DataType} of the property, or its name. Defaults to {@link DataType.String}. For a
+    property that holds a complex object, set `complexTypeName` instead. */
+    dataType?: DataType | string | ComplexType;
+    /** The name, short or qualified, of the {@link ComplexType} this property holds. Setting it makes the
+    property a complex property; it is linked to the ComplexType once both are in the same MetadataStore. */
+    complexTypeName?: string;
+    /** Whether the property may be null. Defaults to `true`. Breeze does not create a `required`
+    validator from it; that comes with the server's metadata. */
+    isNullable?: boolean;
+    /** Whether the property holds a single value. Defaults to `true`; set it to `false` for a property
+    that holds an array of values or complex objects. */
+    isScalar?: boolean;
+    /** The value a new entity gets for this property. Defaults to `null` for a nullable property and to
+    the {@link DataType}'s default value otherwise. A numeric default given as a string is parsed. */
+    defaultValue?: any;
+    /** Whether the property is part of its EntityType's key. Defaults to `false`. */
+    isPartOfKey?: boolean;
+    /** Whether the property exists only on the client, with no counterpart on the server. Defaults to
+    `false`. Breeze marks the properties it discovers on a registered constructor as unmapped itself. */
+    isUnmapped?: boolean;
+    /** Whether the property can be written. Defaults to `true`. Breeze does not set a property that is
+    not settable when it populates an entity from query results. */
+    isSettable?: boolean;
+    /** How the property takes part in optimistic concurrency checking; see
+    {@link DataProperty.concurrencyMode}. Any value other than `"None"` makes it a concurrency property. */
+    concurrencyMode?: string;
+    /** The maximum length of a string value. Breeze does not create a `maxLength` validator from it;
+    that comes with the server's metadata. */
+    maxLength?: number;
+    /** The {@link Validator}s for this property. Defaults to an empty array. */
+    validators?: Validator[];
+    /** The name used for this property in validation messages. Defaults to the property name. */
+    displayName?: string;
+    /** The full name of the server-side enum type, for a property whose values are enum members. */
+    enumType?: string;
+    /** The server's name for the property's type, when the client has no matching {@link DataType} and
+    `dataType` is {@link DataType.Undefined}. */
+    rawTypeName?: string;
+    /** Sets {@link DataProperty.custom}. */
+    custom?: any;
+}
+/**
+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 declare class DataProperty {
+    /** Is this a DataProperty? - always true here. Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isDataProperty: boolean;
+    /** Is this a NavigationProperty? - always false here.  Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isNavigationProperty: boolean;
+    /** The name of this property. __Read Only__  */
+    name: string;
+    /** The name of this property on the server. __Read Only__ */
+    nameOnServer: string;
+    /** The {@link DataType} of this property. __Read Only__ */
+    dataType: DataType | ComplexType;
+    /** The name of the {@link ComplexType} associated with this property; may be null. __Read Only__ */
+    complexTypeName: string;
+    /** The {@link ComplexType} associated with this property; may be undefined. __Read Only__ */
+    complexType?: ComplexType;
+    /**  Whether the contents of this property is an instance of a {@link ComplexType}. __Read Only__ */
+    isComplexProperty: boolean;
+    /** Whether this property is nullable. __Read Only__ */
+    isNullable: boolean;
+    /**  Whether this property is scalar (i.e., returns a single value as opposed to an array). __Read Only__ */
+    isScalar: boolean;
+    /** The default value for this property. __Read Only__ */
+    defaultValue: any;
+    /**  Whether this property is a 'key' property. __Read Only__ */
+    isPartOfKey: boolean;
+    /** Whether this property is an 'unmapped' property. __Read Only__ */
+    isUnmapped: boolean;
+    /** Whether this property is 'settable'. __Read Only__ */
+    isSettable: boolean;
+    /** How this property takes part in optimistic concurrency checking, as the server reported it.
+    Any value other than `"None"` puts the property into {@link EntityType.concurrencyProperties}, whose
+    values Breeze sends with a save so the server can detect that someone else changed the row first.
+    A Breeze .NET server reports `"Fixed"` for a rowversion or `[ConcurrencyCheck]` property. __Read Only__ */
+    concurrencyMode: string;
+    /**  The maximum length for the value of this property. Only meaningful for strings. __Read Only__ */
+    maxLength?: number;
+    /** The {@link Validator} instances that are associated with this property. Validators can be added and
+    removed from this collection. __Read Only__ */
+    validators: Validator[];
+    /** The display name of this property. __Read Only__ */
+    displayName: string;
+    /** The full name of the enum type */
+    enumType?: string;
+    /** The raw type name of this property. will only be defined for properties with a DataType of 'Undefined' */
+    rawTypeName?: string;
+    /**  A free form object that can be used to define any custom metadata for this DataProperty. __Read Only__ */
+    custom?: any;
+    /** For a foreign key in a *unidirectional* relationship, the navigation property on the other type
+    that points back at this one. It is set only when the type holding the foreign key has no navigation
+    property of its own for it: `Territory.regionId` has no `Territory.region`, so its
+    `inverseNavigationProperty` is `Region.territories`, and setting the foreign key still maintains that
+    collection. Where both sides do have a navigation property, {@link DataProperty.relatedNavigationProperty}
+    is set instead. __Read Only__ */
+    inverseNavigationProperty?: NavigationProperty;
+    /**
+    The navigation property related to this property.  Will only be set if this is a foreign key property. __Read Only__ */
+    relatedNavigationProperty?: NavigationProperty;
+    /** The parent type that this property belongs to - will be either a {@link EntityType} or a {@link ComplexType}. __Read Only__ */
+    parentType: StructuralType;
+    /** Property on the base type that this property is inherited from. Will be null if the property is not on the base type. __Read Only__ */
+    baseProperty?: DataProperty;
+    /** 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: DataPropertyConfig | DataProperty);
+    /**
+    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: Object & Record<string, any>, dp: DataProperty): any;
+    /**
+    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: Object & Record<string, any>, dp: DataProperty): any;
+    /**
+    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: string): any;
+    /** 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(): string;
+    /**
+    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: {
+        displayName?: string;
+        custom?: Object;
+    }): void;
+    /** 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(): Validator[];
+    /** 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(): Object;
+    /** 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: any): DataProperty;
+}
+/** Configuration info to be passed to the {@link NavigationProperty} constructor. `entityTypeName`
+and either `name` or `nameOnServer` are required. */
+export interface NavigationPropertyConfig {
+    /** The client-side name of the property. If omitted, it is derived from `nameOnServer` by the
+    store's {@link NamingConvention}. */
+    name?: string;
+    /** The name of the property on the server. If omitted, it is derived from `name` by the store's
+    {@link NamingConvention}. */
+    nameOnServer?: string;
+    /** The name of the {@link EntityType} the property returns. Required. A name without a namespace
+    (no `:#`) is taken to be in the namespace of the type the property is added to. */
+    entityTypeName?: string;
+    /** Whether the property returns a single entity. Defaults to `true`; set it to `false` for a
+    property that returns an array of entities. */
+    isScalar?: boolean;
+    /** The name of the relationship. Two navigation properties, one on each type, with the same
+    association name are each other's {@link NavigationProperty.inverse}. */
+    associationName?: string;
+    /** The names of the foreign key DataProperties, on the type that holds this property, that refer to
+    the entity it returns. Defaults to an empty array. Set on the dependent side of a relationship,
+    e.g. `["customerId"]` for `Order.customer`. */
+    foreignKeyNames?: string[];
+    /** The server-side names of the `foreignKeyNames`; either list may be given and the other is
+    derived. Defaults to an empty array. */
+    foreignKeyNamesOnServer?: string[];
+    /** The names of the foreign key DataProperties, on the type the property returns, that refer back to
+    the type that holds it. Defaults to an empty array. Set on the principal side of a relationship,
+    e.g. `["customerId"]` for `Customer.orders`. */
+    invForeignKeyNames?: string[];
+    /** The server-side names of the `invForeignKeyNames`; either list may be given and the other is
+    derived. Defaults to an empty array. */
+    invForeignKeyNamesOnServer?: string[];
+    /** The {@link Validator}s for this property. Defaults to an empty array. */
+    validators?: Validator[];
+    /** The name used for this property in validation messages. Defaults to the property name. */
+    displayName?: string;
+    /** Sets {@link NavigationProperty.custom}. */
+    custom?: any;
+}
+/**   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 declare class NavigationProperty {
+    /** Is this a DataProperty? - always false here
+    Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isDataProperty: boolean;
+    /** Is this a NavigationProperty? - always true here
+    Allows polymorphic treatment of DataProperties and NavigationProperties. __Read Only__ */
+    isNavigationProperty: boolean;
+    /** 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: () => string;
+    /** Returns the validators that apply to this property, including those inherited from base types.
+    See {@link DataProperty.getAllValidators}. */
+    getAllValidators: () => Validator[];
+    /** 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: (propName: string) => any;
+    /** The {@link EntityType} returned by this property. __Read Only__ */
+    entityType: EntityType;
+    /** The name of the {@link EntityType} returned by this property. __Read Only__ */
+    entityTypeName: string;
+    /** The {@link EntityType} that this property belongs to. ( same as entityType). __Read Only__ */
+    parentType: EntityType;
+    /** The {@link EntityType} that this property belongs to. ( same as entityType). __Read Only__ */
+    parentEntityType: EntityType;
+    /** Property on the base type that this property is inherited from. Will be null if the property is not on the base type. __Read Only__ */
+    baseProperty?: NavigationProperty;
+    /** 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__ */
+    private _inverse?;
+    /** The name of this property. __Read Only__ */
+    name: string;
+    /** The name of this property on the server. __Read Only__ */
+    nameOnServer: string;
+    /**
+    Whether this property returns a single entity as opposed to  an array of entities. __Read Only__ */
+    isScalar: boolean;
+    /** The name of the association to which that this property belongs.  This associationName will be shared with this
+    properties 'inverse'. __Read Only__ */
+    associationName: string;
+    /** The names of the foreign key DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated
+    with a Navigation property except in the case of entities with multipart keys. __Read Only__ */
+    foreignKeyNames: string[];
+    /** The server side names of the foreign key DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated
+    with a Navigation property except in the case of entities with multipart keys. __Read Only__ */
+    foreignKeyNamesOnServer: string[];
+    /** The names of the foreign key DataProperties at the other end of the relationship. __Read Only__ */
+    invForeignKeyNames: string[];
+    /** The server side names of the foreign key DataProperties at the other end of the relationship. __Read Only__ */
+    invForeignKeyNamesOnServer: string[];
+    /** The 'foreign key' DataProperties associated with this NavigationProperty. There will usually only be a single DataProperty associated
+    with a Navigation property except in the case of entities with multipart keys. __Read Only__ */
+    relatedDataProperties: DataProperty[];
+    /** The {@link Validator} instances that are associated with this property. Validators can be added and
+    removed from this collection. __Read Only__ */
+    validators: Validator[];
+    /** The display name of this property. __Read Only__ */
+    displayName: string;
+    /** Always undefined: a NavigationProperty cannot be unmapped. Declared so that `isUnmapped` can be
+    read from any {@link EntityProperty}. __Read Only__ */
+    isUnmapped: boolean;
+    /** A free form object that can be used to define any custom metadata for this NavigationProperty.   */
+    custom: any;
+    /** 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: NavigationPropertyConfig);
+    /**
+    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
+    */
+    setProperties(config: {
+        displayName?: string;
+        foreignKeyNames?: string[];
+        invForeignKeyNames?: string[];
+        inverse?: NavigationProperty | string;
+        custom?: any;
+    }): void;
+    /** 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(): NavigationProperty | undefined;
+    /**
+    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: NavigationProperty | string): void;
+    /** 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(): Object;
+    /** 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: any): NavigationProperty;
+}
+/**
+AutoGeneratedKeyType is an 'Enum' containing all of the valid states for an automatically generated key.
+*/
+export declare 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: 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: 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: AutoGeneratedKeyType;
+}
+export declare function qualifyTypeName(shortName: string, ns?: string): string;
+/**
+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 declare function entityTypeForCtor(entityCtor: Function): EntityType;