breeze-client 2.2.2 → 3.0.0

package/src/entity-manager.d.ts

@@ -1,680 +0,0 @@
-import { DataServiceAdapter } from './interface-registry';
-import { Callback, ErrorCallback } from './core';
-import { BreezeEvent } from './event';
-import { Entity, StructuralObject, PropertyChangedEventArgs } from './entity-aspect';
-import { MetadataStore, EntityType, DataProperty } from './entity-metadata';
-import { EntityKey } from './entity-key';
-import { EntityAction } from './entity-action';
-import { EntityState } from './entity-state';
-import { DataService } from './data-service';
-import { ValidationError } from './validate';
-import { ValidationOptions } from './validation-options';
-import { QueryOptions, MergeStrategy } from './query-options';
-import { SaveOptions } from './save-options';
-import { KeyGenerator } from './key-generator';
-import { EntityGroup } from './entity-group';
-import { EntityQuery } from './entity-query';
-import { UnattachedChildrenMap } from './unattached-children-map';
-export interface HttpResponse {
-    config: any;
-    data: any;
-    error?: any;
-    saveContext?: any;
-    status: number;
-    getHeaders(headerName: string): string;
-}
-export interface ImportResult {
-    entities: Entity[];
-    tempKeyMapping: ITempKeyMap;
-}
-/** Base shape of any errors returned from the server. */
-export interface ServerError extends Error {
-    httpResponse: HttpResponse;
-    status: number;
-    message: string;
-    statusText?: string;
-    body?: any;
-    url?: string;
-}
-/** Shape of a save error returned from the server.
-For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation.
-@adapter (see [[IDataServiceAdapter]])
-@hidden @internal
-*/
-export interface SaveErrorFromServer extends ServerError {
-    entityErrors: EntityErrorFromServer[];
-}
-/** Shape of a save error when returned to the client. */
-export interface SaveError extends ServerError {
-    entityErrors: EntityError[];
-}
-/**
-For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation.
-@adapter (see [[IDataServiceAdapter]])
-@hidden @internal
-*/
-export interface EntityErrorFromServer {
-    entityTypeName: string;
-    keyValues: any[];
-    errorName: string;
-    errorMessage: string;
-    propertyName: string;
-    custom?: any;
-}
-/** Shape of an error on a specific entity.  Part of a [[ISaveError]] */
-export interface EntityError {
-    entity: Entity;
-    errorName: string;
-    errorMessage: string;
-    propertyName: string;
-    isServerError: boolean;
-    custom?: any;
-}
-/** The shape of the Promise returned by an [[EntityManager.executeQuery]] call. */
-export interface QueryResult {
-    /** Top level entities returned.  Excludes entities that are Deleted. */
-    results: any[];
-    /** Query that was executed */
-    query: EntityQuery | string;
-    /** EntityManager that executed the query */
-    entityManager?: EntityManager;
-    /** Total number of results available on the server */
-    inlineCount?: number;
-    /** All entities returned by the query.  Differs from `results` when an expand is used.  Includes entities that are Deleted. */
-    retrievedEntities?: Entity[];
-    /** Raw response from the server */
-    httpResponse?: HttpResponse;
-}
-export interface QuerySuccessCallback {
-    (data: QueryResult): void;
-}
-export interface QueryErrorCallback {
-    (error: {
-        query: EntityQuery;
-        httpResponse: HttpResponse;
-        entityManager: EntityManager;
-        message?: string;
-        stack?: string;
-    }): void;
-}
-/** Key mapping information returned as part of an [[ISaveResult]]. */
-export interface KeyMapping {
-    entityTypeName: string;
-    tempValue: any;
-    realValue: any;
-}
-interface ITempKeyMap {
-    [index: string]: EntityKey;
-}
-/** Configuration info to be passed to the [[EntityManager.importEntities]] method */
-export interface ImportConfig {
-    /** If true, merge Added entities (with temp keys) as well.  This can be dangerous. */
-    mergeAdds?: boolean;
-    mergeStrategy?: MergeStrategy;
-    metadataVersionFn?: (arg: {
-        metadataVersion: any;
-        metadataStoreName: any;
-    }) => void;
-}
-/** The shape of the Promise returned by an [[EntityManager.saveChanges]] call. */
-export interface SaveResult {
-    entities: Entity[];
-    keyMappings: KeyMapping[];
-    deletedKeys?: {
-        entityTypeName: string;
-        keyValues: any[];
-    }[];
-    httpResponse?: HttpResponse;
-}
-/** For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation.
-@adapter (see [[IDataServiceAdapter]])
-@hidden
-*/
-export interface SaveContext {
-    entityManager: EntityManager;
-    dataService: DataService;
-    processSavedEntities: (saveResult: SaveResult) => Entity[];
-    resourceName: string;
-    adapter?: DataServiceAdapter;
-    routePrefix?: string;
-}
-/** For use by breeze plugin authors only. The class is for use in building a [[IDataServiceAdapter]] implementation.
-@adapter (see [[IDataServiceAdapter]])
-@hidden
-*/
-export interface SaveBundle {
-    entities: Entity[];
-    saveOptions: SaveOptions;
-}
-/** Configuration info to be passed to the [[EntityManager]] constructor */
-export interface EntityManagerConfig {
-    /** The service name associated with this EntityManager.  **/
-    serviceName?: string;
-    /** The DataService associated with this EntityManager. **/
-    dataService?: DataService;
-    /** The [[QueryOptions]] associated with this EntityManager.  **/
-    queryOptions?: QueryOptions;
-    /** The [[SaveOptions]] associated with this EntityManager. **/
-    saveOptions?: SaveOptions;
-    /** The [[ValidationOptions]] associated with this EntityManager.  **/
-    validationOptions?: ValidationOptions;
-    /** The [[KeyGenerator]] associated with this EntityManager. **/
-    keyGenerator?: KeyGenerator;
-    /** The [[KeyGenerator]] constructor associated with this EntityManager. **/
-    keyGeneratorCtor?: {
-        new (): KeyGenerator;
-    };
-    /** The [[MetadataStore]] associated with this EntityManager. **/
-    metadataStore?: MetadataStore;
-}
-/** The shape returned by callbacks registered with [[EntityManager.entityChanged]] event */
-export interface EntityChangedEventArgs {
-    entityAction: EntityAction;
-    entity?: Entity;
-    args?: PropertyChangedEventArgs;
-}
-export interface ValidationErrorsChangedEventArgs {
-    entity: Entity;
-    added: ValidationError[];
-    removed: ValidationError[];
-}
-export interface HasChangesChangedEventArgs {
-    entityManager: EntityManager;
-    hasChanges: boolean;
-}
-/**
-Instances of the EntityManager contain and manage collections of entities, either retrieved from a backend datastore or created on the client.
-**/
-export declare class EntityManager {
-    /** @hidden @internal */
-    _$typeName: string;
-    /** The service name associated with this EntityManager. __Read Only__ **/
-    serviceName: string;
-    /** The DataService associated with this EntityManager. __Read Only__ **/
-    dataService: DataService;
-    /** The [[QueryOptions]] associated with this EntityManager. __Read Only__ **/
-    queryOptions: QueryOptions;
-    /** The [[SaveOptions]] associated with this EntityManager. __Read Only__ **/
-    saveOptions: SaveOptions;
-    /** The [[ValidationOptions]] associated with this EntityManager. __Read Only__ **/
-    validationOptions: ValidationOptions;
-    /** The [[KeyGenerator]] associated with this EntityManager. __Read Only__ **/
-    keyGenerator: KeyGenerator;
-    /** The [[KeyGenerator]] constructor associated with this EntityManager. __Read Only__ **/
-    keyGeneratorCtor: {
-        new (): KeyGenerator;
-    };
-    /** The [[MetadataStore]] associated with this EntityManager. __Read Only__ **/
-    metadataStore: MetadataStore;
-    isLoading: boolean;
-    isRejectingChanges: boolean;
-    /**
-    A [[BreezeEvent]] that fires whenever a change to any entity in this EntityManager occurs. __Read Only__
-  
-    @eventArgs -
-    - entityAction - The [[EntityAction]] that occured.
-    - entity - The entity that changed.  If this is null, then all entities in the entityManager were affected.
-    - args - Additional information about this event. This will differ based on the entityAction.
-  
-    >      let em = new EntityManager( {serviceName: "breeze/NorthwindIBModel" });
-    >      em.entityChanged.subscribe(function(changeArgs) {
-    >          // This code will be executed any time any entity within the entityManager
-    >          // is added, modified, deleted or detached for any reason.
-    >          let action = changeArgs.entityAction;
-    >          let entity = changeArgs.entity;
-    >          // .. do something to this entity when it is changed.
-    >      });
-    >  });
-    @event
-    **/
-    entityChanged: BreezeEvent<EntityChangedEventArgs>;
-    /**
-    An [[BreezeEvent]] that fires whenever validationErrors change for any entity in this EntityManager. __Read Only__
-    @eventArgs -
-      - entity - The entity on which the validation errors have been added or removed.
-      - added - An array containing any newly added [[ValidationError]]s
-      - removed - An array containing any newly removed [[ValidationError]]s. This is those errors that have been 'fixed'
-  
-    >      let em = new EntityManager( {serviceName: "breeze/NorthwindIBModel" });
-    >      em.validationErrorsChanged.subscribe(function(changeArgs) {
-    >              // This code will be executed any time any entity within the entityManager experiences a change to its validationErrors collection.
-    >              function (validationChangeArgs) {
-    >                  let entity == validationChangeArgs.entity;
-    >                  let errorsAdded = validationChangeArgs.added;
-    >                  let errorsCleared = validationChangeArgs.removed;
-    >                  // ... do something interesting with the order.
-    >              });
-    >          });
-    >      });
-    @event
-    **/
-    validationErrorsChanged: BreezeEvent<ValidationErrorsChangedEventArgs>;
-    /**
-    A [[BreezeEvent]] that fires whenever an EntityManager transitions to or from having changes. __Read Only__
-    @eventArgs -
-      - entityManager - The EntityManager whose 'hasChanges' status has changed.
-      - hasChanges - Whether or not this EntityManager has changes.
-  
-    >      let em = new EntityManager( {serviceName: "breeze/NorthwindIBModel" });
-    >      em.hasChangesChanged.subscribe(function(args) {
-    >              let hasChangesChanged = args.hasChanges;
-    >              let entityManager = args.entityManager;
-    >          });
-    >      });
-    @event
-    **/
-    hasChangesChanged: BreezeEvent<HasChangesChangedEventArgs>;
-    /** @hidden @internal */
-    _pendingPubs?: any[];
-    /** @hidden @internal */
-    _hasChangesAction?: (() => boolean);
-    /** @hidden @internal */
-    _hasChanges: boolean;
-    /** @hidden @internal */
-    _entityGroupMap: {
-        [index: string]: EntityGroup;
-    };
-    /** @hidden @internal */
-    _unattachedChildrenMap: UnattachedChildrenMap;
-    /** @hidden @internal */
-    _inKeyFixup: boolean;
-    helper: {
-        unwrapInstance: typeof unwrapInstance;
-        unwrapOriginalValues: typeof unwrapOriginalValues;
-        unwrapChangedValues: typeof unwrapChangedValues;
-    };
-    /**
-    EntityManager constructor.
-  
-    At its most basic an EntityManager can be constructed with just a service name
-    >     let entityManager = new EntityManager( "breeze/NorthwindIBModel");
-  
-    This is the same as calling it with the following configuration object
-    >     let entityManager = new EntityManager( {serviceName: "breeze/NorthwindIBModel" });
-  
-    Usually however, configuration objects will contain more than just the 'serviceName';
-    >     let metadataStore = new MetadataStore();
-    >     let entityManager = new EntityManager( {
-    >       serviceName: "breeze/NorthwindIBModel",
-    >       metadataStore: metadataStore
-    >     });
-  
-    or
-    >     return new QueryOptions({
-    >         mergeStrategy: obj,
-    >         fetchStrategy: this.fetchStrategy
-    >     });
-    >     let queryOptions = new QueryOptions({
-    >         mergeStrategy: MergeStrategy.OverwriteChanges,
-    >         fetchStrategy: FetchStrategy.FromServer
-    >     });
-    >     let validationOptions = new ValidationOptions({
-    >         validateOnAttach: true,
-    >         validateOnSave: true,
-    >         validateOnQuery: false
-    >     });
-    >     let entityManager = new EntityManager({
-    >         serviceName: "breeze/NorthwindIBModel",
-    >         queryOptions: queryOptions,
-    >         validationOptions: validationOptions
-    >     });
-    @param emConfig - Configuration settings or a service name.
-    **/
-    constructor(emConfig?: EntityManagerConfig | string);
-    /**
-    General purpose property set method.  Any of the properties in the [[EntityManagerConfig]]
-    may be set.
-    >      // assume em1 is a previously created EntityManager
-    >      // where we want to change some of its settings.
-    >      em1.setProperties( {
-    >          serviceName: "breeze/foo"
-    >      });
-    @param config - An object containing the selected properties and values to set.
-    **/
-    setProperties(config: EntityManagerConfig): void;
-    /** @hidden @internal */
-    static _updateWithConfig(em: EntityManager, config: EntityManagerConfig, isCtor: boolean): void;
-    createEntity(typeName: string, initialValues?: Object, entityState?: EntityState, mergeStrategy?: MergeStrategy): Entity;
-    createEntity(entityType: EntityType, initialValues?: Object, entityState?: EntityState, mergeStrategy?: MergeStrategy): Entity;
-    static importEntities(exportedString: string, config?: ImportConfig): EntityManager;
-    static importEntities(exportedData: Object, config?: ImportConfig): EntityManager;
-    /**
-    Calls [[EntityAspect.acceptChanges]] on every changed entity in this EntityManager.
-    **/
-    acceptChanges(): void;
-    /**
-    Exports selected entities, all entities of selected types, or an entire EntityManager cache.
-  
-    This method takes a snapshot of an EntityManager that can be stored offline or held in memory.
-    Use the [[EntityManager.importEntities]] method to restore or merge the snapshot
-    into another EntityManager at some later time.
-    >      // let em1 be an EntityManager containing a number of existing entities.
-    >     // export every entity in em1.
-    >     let bundle = em1.exportEntities();
-    >     // save to the browser's local storage
-    >     window.localStorage.setItem("myEntityManager", bundle);
-    >     // later retrieve the export
-    >     let bundleFromStorage = window.localStorage.getItem("myEntityManager");
-    >     // import the retrieved export bundle into another manager
-    >     let em2 = em1.createEmptyCopy();
-    >     em2.importEntities(bundleFromStorage);
-    >     // em2 now has a complete, faithful copy of the entities that were in em1
-  
-    You can also control exactly which entities are exported.
-    >     // get em1's unsaved changes (an array) and export them.
-    >     let changes = em1.getChanges();
-    >     let bundle = em1.exportEntities(changes);
-    >     // merge these entities into em2 which may contains some of the same entities.
-    >     // do NOT overwrite the entities in em2 if they themselves have unsaved changes.
-    >     em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges} );
-  
-    Metadata are included in an export by default. You may want to exclude the metadata
-    especially if you're exporting just a few entities for local storage.
-    >     let bundle = em1.exportEntities(arrayOfSelectedEntities, {includeMetadata: false});
-    >     window.localStorage.setItem("goodStuff", bundle);
-  
-    You may still express this option as a boolean value although this older syntax is deprecated.
-    >     // Exclude the metadata (deprecated syntax)
-    >     let bundle = em1.exportEntities(arrayOfSelectedEntities, false);
-  
-    You can export all entities of one or more specified EntityTypes.
-    >     // Export all Customer and Employee entities (and also exclude metadata)
-    >     let bundle = em1.exportEntities(['Customer', 'Employee'], {includeMetadata: false});
-  
-    All of the above examples return an export bundle as a string which is the default format.
-    You can export the bundle as JSON if you prefer by setting the `asString` option to false.
-    >     // Export all Customer and Employee entities as JSON and exclude the metadata
-    >     let bundle = em1.exportEntities(['Customer', 'Employee'],
-    >                                     {asString: false, includeMetadata: false});
-    >     // store JSON bundle somewhere ... perhaps indexDb ... and later import as we do here.
-    >     em2.importEntities(bundle);
-    @param entities - The entities to export or the EntityType(s) of the entities to export;
-      all entities are exported if this parameter is omitted or null.
-    @param exportConfig - Export configuration options or a boolean
-      - asString - (boolean) - If true (default), return export bundle as a string.
-      - includeMetadata - (boolean) - If true (default), include metadata in the export bundle.
-    @return The export bundle either serialized as a string (default) or as a JSON object.
-    The bundle contains the metadata (unless excluded) and the entity data grouped by type.
-    The entity data include property values, change-state, and temporary key mappings (if any).
-  
-    The export bundle internals are deliberately undocumented.  This Breeze-internal representation of entity data is
-    suitable for export, storage, and import. The schema and contents of the bundle may change in future versions of Breeze.
-    Manipulate it at your own risk with appropriate caution.
-    **/
-    exportEntities(entities?: Entity[] | EntityType[] | string[], exportConfig?: {
-        asString?: boolean;
-        includeMetadata?: boolean;
-    } | boolean): string | Object;
-    importEntities(exportedString: string, config?: ImportConfig): ImportResult;
-    importEntities(exportedData: Object, config?: ImportConfig): ImportResult;
-    /**
-    Clears this EntityManager's cache but keeps all other settings. Note that this
-    method is not as fast as creating a new EntityManager via 'new EntityManager'.
-    This is because clear actually detaches all of the entities from the EntityManager.
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     em1.clear();
-    >     // em1 is will now contain no entities, but all other setting will be maintained.
-    **/
-    clear(): void;
-    /**
-    Creates an empty copy of this EntityManager but with the same DataService, MetadataStore, QueryOptions, SaveOptions, ValidationOptions, etc.
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     let em2 = em1.createEmptyCopy();
-    >     // em2 is a new EntityManager with all of em1's settings
-    >     // but no entities.
-    @return A new EntityManager.
-    **/
-    createEmptyCopy(): EntityManager;
-    /**
-    Attaches an entity to this EntityManager with an  [[EntityState]] of 'Added'.
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     let custType = em1.metadataStore.getEntityType("Customer");
-    >     let cust1 = custType.createEntity();
-    >     em1.addEntity(cust1);
-  
-    Note that this is the same as using 'attachEntity' with an [[EntityState]] of 'Added'.
-  
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     let custType = em1.metadataStore.getEntityType("Customer");
-    >     let cust1 = custType.createEntity();
-    >     em1.attachEntity(cust1, EntityState.Added);
-    @param entity - The entity to add.
-    @return The added entity.
-    **/
-    addEntity(entity: Entity): Entity;
-    /**
-    Attaches an entity to this EntityManager with a specified [[EntityState]].
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     let custType = em1.metadataStore.getEntityType("Customer");
-    >     let cust1 = custType.createEntity();
-    >     em1.attachEntity(cust1, EntityState.Added);
-    @param entity - The entity to add.
-    @param entityState - (default=EntityState.Unchanged) The EntityState of the newly attached entity. If omitted this defaults to EntityState.Unchanged.
-    @param mergeStrategy - (default = MergeStrategy.Disallowed) How the specified entity should be merged into the EntityManager if this EntityManager already contains an entity with the same key.
-    @return The attached entity.
-    **/
-    attachEntity(entity: Entity, entityState?: EntityState, mergeStrategy?: MergeStrategy): Entity;
-    /**
-    Detaches an entity from this EntityManager.
-    >     // assume em1 is an EntityManager containing a number of existing entities.
-    >     // assume cust1 is a customer Entity previously attached to em1
-    >     em1.detachEntity(cust1);
-    >     // em1 will now no longer contain cust1 and cust1 will have an
-    >     // entityAspect.entityState of EntityState.Detached
-    @param entity - The entity to detach.
-    @return Whether the entity could be detached. This will return false if the entity is already detached or was never attached.
-    **/
-    detachEntity(entity: Entity): any;
-    /**
-    Fetches the metadata associated with the EntityManager's current 'serviceName'.  This call
-    occurs internally before the first query to any service if the metadata hasn't already been
-    loaded. __Async__
-  
-    Usually you will not actually process the results of a fetchMetadata call directly, but will instead
-    ask for the metadata from the EntityManager after the fetchMetadata call returns.
-    >     let em1 = new EntityManager( "breeze/NorthwindIBModel");
-    >     em1.fetchMetadata()
-    >       .then(function() {
-    >           let metadataStore = em1.metadataStore;
-    >           // do something with the metadata
-    >       }).catch(function(exception) {
-    >           // handle exception here
-    >       });
-    
-    @param callback - Function called on success.
-    @param errorCallback - Function called on failure.
-    @return {Promise}
-      - schema {Object} The raw Schema object from metadata provider - Because this schema will differ depending on the metadata provider
-          it is usually better to access metadata via the 'metadataStore' property of the EntityManager instead of using this 'raw' data.
-    **/
-    fetchMetadata(dataService?: DataService, callback?: Callback, errorCallback?: ErrorCallback): Promise<any>;
-    executeQuery(query: string, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;
-    executeQuery(query: EntityQuery, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;
-    /**
-    Executes the specified query against this EntityManager's local cache.
-  
-    Because this method is executed immediately there is no need for a promise or a callback
-    >     let em = new EntityManager(serviceName);
-    >     let query = new EntityQuery("Orders");
-    >     let orders = em.executeQueryLocally(query);
-  
-    Note that this can also be accomplished using the 'executeQuery' method with
-    a FetchStrategy of FromLocalCache and making use of the Promise or callback
-    >     let em = new EntityManager(serviceName);
-    >     let query = new EntityQuery("Orders").using(FetchStrategy.FromLocalCache);
-    >     em.executeQuery(query).then( function(data) {
-    >         let orders = data.results;
-    >         ... query results processed here
-    >     }).catch( function(err) {
-    >         ... query failure processed here
-    >     });
-    @param query - The [[EntityQuery]] to execute.
-    @return  {Array of Entity}  Array of entities from cache that satisfy the query
-    **/
-    executeQueryLocally(query: EntityQuery): any[];
-    /**
-    Saves either a list of specified entities or all changed entities within this EntityManager. If there are no changes to any of the entities
-    specified then there will be no server side call made but a valid 'empty' saveResult will still be returned. __Async__
-  
-    Often we will be saving all of the entities within an EntityManager that are either added, modified or deleted
-    and we will let the 'saveChanges' call determine which entities these are.
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      // This could include added, modified and deleted entities.
-    >      em.saveChanges().then(function(saveResult) {
-    >          let savedEntities = saveResult.entities;
-    >          let keyMappings = saveResult.keyMappings;
-    >      }).catch(function (e) {
-    >          // e is any exception that was thrown.
-    >      });
-  
-    But we can also control exactly which entities to save and can specify specific SaveOptions
-  
-    >      // assume entitiesToSave is an array of entities to save.
-    >      let saveOptions = new SaveOptions({ allowConcurrentSaves: true });
-    >      em.saveChanges(entitiesToSave, saveOptions).then(function(saveResult) {
-    >          let savedEntities = saveResult.entities;
-    >          let keyMappings = saveResult.keyMappings;
-    >      }).catch(function (e) {
-    >          // e is any exception that was thrown.
-    >      });
-  
-    Callback methods can also be used
-    >      em.saveChanges(entitiesToSave, null,
-    >          function(saveResult) {
-    >              let savedEntities = saveResult.entities;
-    >              let keyMappings = saveResult.keyMappings;
-    >          }, function (e) {
-    >              // e is any exception that was thrown.
-    >          }
-    >      );
-  
-    @param entities - The list of entities to save.
-    Every entity in that list will be sent to the server, whether changed or unchanged,
-    as long as it is attached to this EntityManager.
-    If this parameter is omitted, null or empty (the usual case),
-    every entity with pending changes in this EntityManager will be saved.
-    @param saveOptions - [[SaveOptions]] for the save - will default to
-    [[EntityManager.saveOptions]] if null.
-    @param callback -  Function called on success.
-    @param errorCallback - Function called on failure.
-    @return {Promise} Promise
-    **/
-    saveChanges(entities?: Entity[] | null, saveOptions?: SaveOptions, callback?: Function, errorCallback?: Function): Promise<SaveResult>;
-    /**
-    Run the "saveChanges" pre-save client validation logic.
-    
-    This is NOT a general purpose validation method.
-    It is intended for utilities that must know if saveChanges
-    would reject the save due to client validation errors.
-    
-    It only validates entities if the EntityManager's
-    [[ValidationOptions]].validateOnSave is true.
-    
-    @param entitiesToSave {Array of Entity} The list of entities to save (to validate).
-    @return {Error} Validation error or null if no error
-    **/
-    saveChangesValidateOnClient(entitiesToSave: Entity[]): Error;
-    /** @hidden @internal */
-    _findEntityGroup(entityType: EntityType): EntityGroup;
-    /**
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      let employeeType = em1.metadataStore.getEntityType("Employee");
-    >      let employeeKey = new EntityKey(employeeType, 1);
-    >      let employee = em1.getEntityByKey(employeeKey);
-    >      // employee will either be an entity or null.
-    **/
-    getEntityByKey(entityKey: EntityKey): Entity | null;
-    /**
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      let employee = em1.getEntityByKey("Employee", 1);
-    >      // employee will either be an entity or null.
-    **/
-    getEntityByKey(typeName: string, keyValues: any | any[]): Entity | null;
-    /**
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      let employeeType = em1.metadataStore.getEntityType("Employee");
-    >      let employee = em1.getEntityByKey(employeeType, 1);
-    >      // employee will either be an entity or null.
-    **/
-    getEntityByKey(type: EntityType, keyValues: any | any[]): Entity | null;
-    fetchEntityByKey(typeName: string, keyValues: any | any[], checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;
-    fetchEntityByKey(entityType: EntityType, keyValues: any | any[], checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;
-    fetchEntityByKey(entityKey: EntityKey, checkLocalCacheFirst?: boolean): Promise<IEntityByKeyResult>;
-    /**
-    [Deprecated] - Attempts to locate an entity within this EntityManager by its  [[EntityKey]].
-    >     // assume em1 is an EntityManager containing a number of preexisting entities.
-    >     let employeeType = em1.metadataStore.getEntityType("Employee");
-    >     let employeeKey = new EntityKey(employeeType, 1);
-    >     let employee = em1.findEntityByKey(employeeKey);
-    >     // employee will either be an entity or null.
-    @deprecated    Use getEntityByKey instead
-    @param entityKey - The  [[EntityKey]] of the Entity to be located.
-    @return An Entity or null;
-    **/
-    findEntityByKey(entityKey: EntityKey): Entity;
-    /**
-    Generates a temporary key for the specified entity.  This is used to insure that newly
-    created entities have unique keys and to register that these keys are temporary and
-    need to be automatically replaced with 'real' key values once these entities are saved.
-    
-    The [[EntityManager.keyGeneratorCtor]] property is used internally by this method to actually generate
-    the keys - See the  KeyGenerator interface interface description to see
-    how a custom key generator can be plugged in.
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      let custType = em1.metadataStore.getEntityType("Customer");
-    >      let customer = custType.createEntity();
-    >      let customerId = em.generateTempKeyValue(customer);
-    >      // The 'customer' entity 'CustomerID' property is now set to a newly generated unique id value
-    >      // This property will change again after a successful save of the 'customer' entity.
-    >
-    >      em1.saveChanges().then( function( data) {
-    >          let sameCust1 = data.results[0];
-    >          // cust1 === sameCust1;
-    >          // but cust1.getProperty("CustomerId") != customerId
-    >          // because the server will have generated a new id
-    >          // and the client will have been updated with this
-    >          // new id.
-    >      })
-    @param entity - The Entity to generate a key for.
-    @return The new key value
-    **/
-    generateTempKeyValue(entity: Entity): any;
-    hasChanges(): boolean;
-    hasChanges(entityTypeNames: string | string[]): boolean;
-    hasChanges(entityTypes: EntityType | EntityType[]): boolean;
-    /** @hidden @internal */
-    _hasChangesCore(entityTypes?: EntityType | EntityType[] | string | string[]): boolean;
-    getChanges(): Entity[];
-    getChanges(entityTypeNames: string | string[]): Entity[];
-    getChanges(entityTypes: EntityType | EntityType[]): Entity[];
-    /**
-    Rejects (reverses the effects) all of the additions, modifications and deletes from this EntityManager.
-    Calls [[EntityAspect.rejectChanges]] on every changed entity in this EntityManager.
-    >      // assume em1 is an EntityManager containing a number of preexisting entities.
-    >      let entities = em1.rejectChanges();
-    @return The entities whose changes were rejected. These entities will all have EntityStates of
-    either 'Unchanged' or 'Detached'
-    **/
-    rejectChanges(): Entity[];
-    getEntities(entityTypeNames?: string | string[], entityStates?: EntityState | EntityState[]): Entity[];
-    getEntities(entityTypes?: EntityType | EntityType[], entityStates?: EntityState | EntityState[]): Entity[];
-    /** @hidden @internal */
-    _notifyStateChange(entity: Entity, needsSave: boolean): void;
-    /** @hidden @internal */
-    _setHasChanges(hasChanges?: boolean): void;
-    /** @hidden @internal */
-    _linkRelatedEntities(entity: Entity): void;
-    /** @hidden @internal */
-    _attachEntityCore(entity: Entity, entityState: EntityState, mergeStrategy: MergeStrategy): Entity;
-    /** @hidden @internal */
-    _updateFkVal(fkProp: DataProperty, oldValue: any, newValue: any): void;
-}
-export interface IEntityByKeyResult {
-    entity?: Entity;
-    entityKey: EntityKey;
-    fromCache: boolean;
-}
-declare function unwrapInstance(structObj: StructuralObject, transformFn?: (dp: DataProperty, val: any) => any): any;
-declare function unwrapOriginalValues(target: StructuralObject, metadataStore: MetadataStore, transformFn?: (dp: DataProperty, val: any) => any): Record<string, any>;
-declare function unwrapChangedValues(entity: Entity, metadataStore: MetadataStore, transformFn: (dp: DataProperty, val: any) => any): Record<string, any>;
-export {};