breeze-client 2.2.1 → 3.0.0

package/{src → entity}/entity-action.d.ts

@@ -1,42 +1,36 @@
-import { BreezeEnum } from './enum';
-/** EntityAction is an 'Enum' containing all of the valid actions that can occur to an 'Entity'.
- 
-*/
-export declare class EntityAction extends BreezeEnum {
-    /** Entity was attached via an AttachEntity call. */
-    static Attach: EntityAction;
-    /**  Entity was attached as a result of a query. */
-    static AttachOnQuery: EntityAction;
-    /**  Entity was attached as a result of an import. */
-    static AttachOnImport: EntityAction;
-    /** Entity was detached */
-    static Detach: EntityAction;
-    /** Properties on the entity were merged as a result of a query. */
-    static MergeOnQuery: EntityAction;
-    /** Properties on the entity were merged as a result of an import. */
-    static MergeOnImport: EntityAction;
-    /** Properties on the entity were merged as a result of a save */
-    static MergeOnSave: EntityAction;
-    /** A property on the entity was changed. */
-    static PropertyChange: EntityAction;
-    /** The EntityState of the entity was changed. */
-    static EntityStateChange: EntityAction;
-    /** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */
-    static AcceptChanges: EntityAction;
-    /** RejectChanges was called on the entity. */
-    static RejectChanges: EntityAction;
-    /** The EntityManager was cleared.  All entities detached. */
-    static Clear: EntityAction;
-    /** @hidden @internal */
-    _isAttach?: boolean;
-    /** @hidden @internal */
-    _isDetach?: boolean;
-    /** @hidden @internal */
-    _isModification: boolean;
-    /** Is this an 'attach' operation? ( Attach, AttachOnQuery or AttachOnImport) */
-    isAttach(): boolean;
-    /** Is this a 'detach' operation? ( Detach, Clear) */
-    isDetach(): boolean;
-    /** Is this a 'modification' operation? ( PropertyChange, MergeOnQuery, MergeOnSave, MergeOnImport, RejectChanges) */
-    isModification(): boolean;
-}
+import { BreezeEnum } from '../core/enum.js';
+/** EntityAction is an 'Enum' containing all of the valid actions that can occur to an 'Entity'.
+ 
+*/
+export declare class EntityAction extends BreezeEnum {
+    /** Entity was attached via an AttachEntity call. */
+    static Attach: EntityAction;
+    /**  Entity was attached as a result of a query. */
+    static AttachOnQuery: EntityAction;
+    /**  Entity was attached as a result of an import. */
+    static AttachOnImport: EntityAction;
+    /** Entity was detached */
+    static Detach: EntityAction;
+    /** Properties on the entity were merged as a result of a query. */
+    static MergeOnQuery: EntityAction;
+    /** Properties on the entity were merged as a result of an import. */
+    static MergeOnImport: EntityAction;
+    /** Properties on the entity were merged as a result of a save */
+    static MergeOnSave: EntityAction;
+    /** A property on the entity was changed. */
+    static PropertyChange: EntityAction;
+    /** The EntityState of the entity was changed. */
+    static EntityStateChange: EntityAction;
+    /** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */
+    static AcceptChanges: EntityAction;
+    /** RejectChanges was called on the entity. */
+    static RejectChanges: EntityAction;
+    /** The EntityManager was cleared.  All entities detached. */
+    static Clear: EntityAction;
+    /** Is this an 'attach' operation? ( Attach, AttachOnQuery or AttachOnImport) */
+    isAttach(): boolean;
+    /** Is this a 'detach' operation? ( Detach, Clear) */
+    isDetach(): boolean;
+    /** Is this a 'modification' operation? ( PropertyChange, MergeOnQuery, MergeOnSave, MergeOnImport, RejectChanges) */
+    isModification(): boolean;
+}

package/entity/entity-action.js

@@ -0,0 +1,45 @@
+import { BreezeEnum } from '../core/enum.js';
+/** EntityAction is an 'Enum' containing all of the valid actions that can occur to an 'Entity'.
+ 
+*/
+export class EntityAction extends BreezeEnum {
+    /** Entity was attached via an AttachEntity call. */
+    static Attach = new EntityAction({ _isAttach: true });
+    /**  Entity was attached as a result of a query. */
+    static AttachOnQuery = new EntityAction({ _isAttach: true });
+    /**  Entity was attached as a result of an import. */
+    static AttachOnImport = new EntityAction({ _isAttach: true });
+    /** Entity was detached */
+    static Detach = new EntityAction({ _isDetach: true });
+    /** Properties on the entity were merged as a result of a query. */
+    static MergeOnQuery = new EntityAction({ _isModification: true });
+    /** Properties on the entity were merged as a result of an import. */
+    static MergeOnImport = new EntityAction({ _isModification: true });
+    /** Properties on the entity were merged as a result of a save */
+    static MergeOnSave = new EntityAction({ _isModification: true });
+    /** A property on the entity was changed. */
+    static PropertyChange = new EntityAction({ _isModification: true });
+    /** The EntityState of the entity was changed. */
+    static EntityStateChange = new EntityAction();
+    /** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */
+    static AcceptChanges = new EntityAction();
+    /** RejectChanges was called on the entity. */
+    static RejectChanges = new EntityAction({ _isModification: true });
+    /** The EntityManager was cleared.  All entities detached. */
+    static Clear = new EntityAction({ _isDetach: true });
+    /** Is this an 'attach' operation? ( Attach, AttachOnQuery or AttachOnImport) */
+    isAttach() {
+        return !!this._isAttach;
+    }
+    /** Is this a 'detach' operation? ( Detach, Clear) */
+    isDetach() {
+        return !!this._isDetach;
+    }
+    /** Is this a 'modification' operation? ( PropertyChange, MergeOnQuery, MergeOnSave, MergeOnImport, RejectChanges) */
+    isModification() {
+        return !!this._isModification;
+    }
+}
+EntityAction.prototype._$typeName = "EntityAction";
+EntityAction.resolveSymbols();
+//# sourceMappingURL=entity-action.js.map

package/entity/entity-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-action.js","sourceRoot":"","sources":["../../src/entity/entity-action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAE5C;;EAEE;AAEF,MAAM,OAAO,YAAa,SAAQ,UAAU;IAE1C,oDAAoD;IACpD,MAAM,CAAC,MAAM,GAAG,IAAI,YAAY,CAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvD,mDAAmD;IACnD,MAAM,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;IAC5D,qDAAqD;IACrD,MAAM,CAAC,cAAc,GAAG,IAAI,YAAY,CAAC,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;IAE7D,0BAA0B;IAC1B,MAAM,CAAC,MAAM,GAAG,IAAI,YAAY,CAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEvD,mEAAmE;IACnE,MAAM,CAAC,YAAY,GAAG,IAAI,YAAY,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IAClE,qEAAqE;IACrE,MAAM,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACnE,iEAAiE;IACjE,MAAM,CAAC,WAAW,GAAG,IAAI,YAAY,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IAEjE,4CAA4C;IAC5C,MAAM,CAAC,cAAc,GAAG,IAAI,YAAY,CAAC,EAAE,eAAe,EAAE,IAAI,EAAC,CAAC,CAAC;IAEnE,iDAAiD;IACjD,MAAM,CAAC,iBAAiB,GAAG,IAAI,YAAY,EAAE,CAAC;IAE9C,wFAAwF;IACxF,MAAM,CAAC,aAAa,GAAG,IAAI,YAAY,EAAE,CAAC;IAC1C,8CAA8C;IAC9C,MAAM,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,EAAE,eAAe,EAAE,IAAI,EAAC,CAAC,CAAC;IAElE,6DAA6D;IAC7D,MAAM,CAAC,KAAK,GAAG,IAAI,YAAY,CAAC,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC;IAQpD,gFAAgF;IAChF,QAAQ;QACN,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IACD,qDAAqD;IACrD,QAAQ;QACN,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IACD,qHAAqH;IACrH,cAAc;QACZ,OAAO,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;;AAEH,YAAY,CAAC,SAAS,CAAC,UAAU,GAAG,cAAc,CAAC;AACnD,YAAY,CAAC,cAAc,EAAE,CAAC","sourcesContent":["import { BreezeEnum} from '../core/enum.js';\r\n\r\n/** EntityAction is an 'Enum' containing all of the valid actions that can occur to an 'Entity'. \r\n \r\n*/\r\n\r\nexport class EntityAction extends BreezeEnum {\r\n\r\n  /** Entity was attached via an AttachEntity call. */\r\n  static Attach = new EntityAction( { _isAttach: true });\r\n  /**  Entity was attached as a result of a query. */\r\n  static AttachOnQuery = new EntityAction({ _isAttach: true});\r\n  /**  Entity was attached as a result of an import. */\r\n  static AttachOnImport = new EntityAction({ _isAttach: true});\r\n\r\n  /** Entity was detached */\r\n  static Detach = new EntityAction( { _isDetach: true });\r\n\r\n  /** Properties on the entity were merged as a result of a query. */\r\n  static MergeOnQuery = new EntityAction({ _isModification: true });\r\n  /** Properties on the entity were merged as a result of an import. */\r\n  static MergeOnImport = new EntityAction({ _isModification: true });\r\n  /** Properties on the entity were merged as a result of a save */\r\n  static MergeOnSave = new EntityAction({ _isModification: true });\r\n\r\n  /** A property on the entity was changed. */\r\n  static PropertyChange = new EntityAction({ _isModification: true});\r\n\r\n  /** The EntityState of the entity was changed. */\r\n  static EntityStateChange = new EntityAction();\r\n\r\n  /** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */\r\n  static AcceptChanges = new EntityAction();\r\n  /** RejectChanges was called on the entity. */\r\n  static RejectChanges = new EntityAction({ _isModification: true});\r\n\r\n  /** The EntityManager was cleared.  All entities detached. */\r\n  static Clear = new EntityAction({ _isDetach: true});\r\n\r\n  /** @hidden @internal */\r\n  declare _isAttach?: boolean;\r\n  /** @hidden @internal */\r\n  declare _isDetach?: boolean;\r\n  /** @hidden @internal */\r\n  declare _isModification: boolean;\r\n  /** Is this an 'attach' operation? ( Attach, AttachOnQuery or AttachOnImport) */\r\n  isAttach() {\r\n    return !!this._isAttach;\r\n  }\r\n  /** Is this a 'detach' operation? ( Detach, Clear) */\r\n  isDetach() {\r\n    return !!this._isDetach;\r\n  }\r\n  /** Is this a 'modification' operation? ( PropertyChange, MergeOnQuery, MergeOnSave, MergeOnImport, RejectChanges) */\r\n  isModification() {\r\n    return !!this._isModification;\r\n  }\r\n}\r\nEntityAction.prototype._$typeName = \"EntityAction\";\r\nEntityAction.resolveSymbols();\r\n\r\n\r\n\r\n"]}

package/entity/entity-aspect.d.ts

@@ -0,0 +1,457 @@
+import { BreezeEvent } from '../core/event.js';
+import { EntityState } from './entity-state.js';
+import { EntityType, ComplexType, DataProperty, NavigationProperty, EntityProperty } from '../metadata/entity-metadata.js';
+import { EntityKey } from './entity-key.js';
+import { EntityManager, QueryResult, QueryErrorCallback, QuerySuccessCallback, ValidationErrorsChangedEventArgs } from '../manager/entity-manager.js';
+import { Validator, ValidationError } from '../validation/validate.js';
+import type { DataKeys, OriginalValues } from '../query/property-path.js';
+/** An instance of an {@link EntityType}: an object with a key, tracked by an {@link EntityManager}
+once attached. Breeze gives every entity these members, whether its class declares them or not. */
+export interface Entity {
+    /** The {@link EntityAspect} that holds this entity's Breeze state: its {@link EntityState}, key,
+    original values, validation errors and manager. */
+    entityAspect: EntityAspect;
+    /** The {@link EntityType} that describes this entity. */
+    entityType: EntityType;
+    /** Get the property with the given name */
+    getProperty(prop: string): any;
+    /** Set the property with the given name, exactly as assigning it would.
+  
+    With the backing-store model library it returns the object itself, so calls can be chained.
+    The return type is `any` rather than `this` so that a class declaring `setProperty` as returning
+    `void` still implements this interface.
+  
+    A name that is not a property of the type is not an error: like an assignment, it creates an
+    ordinary property, which Breeze does not track. */
+    setProperty(prop: any, value: any): any;
+}
+/** An instance of a {@link ComplexType}: a value with no key of its own, held in a complex property
+of an entity or of another complex object. */
+export interface ComplexObject {
+    /** The {@link ComplexAspect} that holds this object's parent, parent property and original values. */
+    complexAspect: ComplexAspect;
+    /** The {@link ComplexType} that describes this object. */
+    complexType: ComplexType;
+    /** Get the property with the given name */
+    getProperty(prop: string): any;
+    /** Set the property with the given name, exactly as assigning it would. Returns the object
+    itself with the backing-store model library - see {@link Entity.setProperty}. */
+    setProperty(prop: any, value: any): any;
+}
+/** An entity or a complex object - either kind of object Breeze tracks the properties of. Used where
+either is accepted, such as {@link ComplexAspect.parent}. */
+export type StructuralObject = Entity | ComplexObject;
+/**
+ * The type of the results of a query built from entities you already have, such as
+ * {@link EntityQuery.fromEntities} or {@link RelationArray.load}: the entities' own class when it
+ * is known - `QueriedAs<Customer>` is `Customer` - and `any` when all that is known is
+ * {@link Entity}, so that `results[0].companyName` compiles without a cast.
+ */
+export type QueriedAs<U> = Entity extends U ? any : U;
+/** The argument to an entity's {@link EntityAspect.propertyChanged} event. It is also the `args` of
+an {@link EntityChangedEventArgs} for {@link EntityAction.PropertyChange}. */
+export interface PropertyChangedEventArgs {
+    /** The entity that changed. For a property of a complex object, the entity that holds it. */
+    entity: Entity;
+    /** The name of the property that changed. For a property of a complex object it is a path from
+    the entity, such as `"location.city"`, with no index for an element of a complex array.
+  
+    `null` when any number of properties may have changed at once - when a query or save merges
+    values into the entity, or its changes are rejected. The other members are then not set. */
+    propertyName: string | null;
+    /** The object whose property was set: the entity itself, or the complex object that owns the
+    property. */
+    parent?: StructuralObject;
+    /** The {@link DataProperty} or {@link NavigationProperty} that changed. It belongs to the type of
+    `parent`, which is not the entity's type when `parent` is a complex object. */
+    property?: EntityProperty;
+    /** The value before the change. */
+    oldValue?: any;
+    /** The value after the change, converted to the property's data type where Breeze can. */
+    newValue?: any;
+}
+/**
+An EntityAspect instance is associated with every attached entity and is accessed via the entity's 'entityAspect' property.
+
+The EntityAspect itself provides properties to determine and modify the EntityState of the entity and has methods
+that provide a variety of services including validation and change tracking.
+
+An EntityAspect will almost never need to be constructed directly. You will usually get an EntityAspect by accessing
+an entities 'entityAspect' property.  This property will be automatically attached when an entity is created via either
+a query, import or {@link EntityManager.createEntity} call.
+```ts
+// assume order is an order entity attached to an EntityManager.
+var aspect = order.entityAspect;
+var currentState = aspect.entityState;
+```
+
+*/
+export declare class EntityAspect {
+    /** The Entity that this aspect is associated with. __Read Only__  */
+    entity?: Entity;
+    /** The {@link EntityManager} that contains this entity. __Read Only__ */
+    entityManager?: EntityManager;
+    /** The {@link EntityState} of this entity. __Read Only__ */
+    get entityState(): EntityState;
+    set entityState(entityState: EntityState);
+    /**   Whether this entity is in the process of being saved. __Read Only__ */
+    isBeingSaved: boolean;
+    /** The 'original values' of this entity where they are different from the 'current values'.
+    This is a map where the key is a property name and the value is the 'original value' of the property. */
+    originalValues: Record<string, any>;
+    /**  Whether this entity has any validation errors. __Read Only__ */
+    hasValidationErrors: boolean;
+    /** Whether this entity has a temporary {@link EntityKey}. */
+    hasTempKey?: boolean;
+    /** Whether this entity was created by being loaded from the database */
+    wasLoaded?: boolean;
+    /** Extra metadata about this entity such as the entity's etag.
+    You may extend this object with your own metadata information.
+    Breeze (de)serializes this object when importing/exporting the entity. */
+    extraMetadata?: any;
+    /**
+    A {@link BreezeEvent} that fires whenever any of the validation errors on this entity change.
+    Note that this might be the removal of an error when some data on the entity is fixed.
+    @eventArgs -
+      - entity - The entity on which the validation errors are being added or removed.
+      - added - An array containing any newly added {@link ValidationError}s
+      - removed - An array containing any newly removed {@link ValidationError}s. This is those
+        errors that have been 'fixed'.
+  
+  ```ts
+  // assume order is an order entity attached to an EntityManager.
+  order.entityAspect.validationErrorsChanged.subscribe(
+  function (validationChangeArgs) {
+      // this code will be executed anytime a property value changes on the 'order' entity.
+      var entity == validationChangeArgs.entity; // Note: entity === order
+      var errorsAdded = validationChangeArgs.added;
+      var errorsCleared = validationChangeArgs.removed;
+  });
+  ```
+    @event
+    */
+    validationErrorsChanged: BreezeEvent<ValidationErrorsChangedEventArgs>;
+    /**
+    A {@link BreezeEvent} that fires whenever a value of one of this entity's properties change.
+    @eventArgs -
+      - entity - The entity whose property has changed.
+      - property - The {@link DataProperty} that changed.
+      - propertyName - The name of the property that changed. This value will be 'null' for operations that replace the entire entity.  This includes
+        queries, imports and saves that require a merge. The remaining parameters will not exist in this case either. This will actually be a "property path"
+        for any properties of a complex type.
+      - oldValue - The old value of this property before the change.
+      - newValue - The new value of this property after the change.
+      - parent - The immediate parent object for the changed property.  This will be a ComplexType instance as opposed to an Entity
+        for any complex type or nested complex type properties.
+  
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.propertyChanged.subscribe(
+    function (propertyChangedArgs) {
+        // this code will be executed anytime a property value changes on the 'order' entity.
+        var entity = propertyChangedArgs.entity; // Note: entity === order
+        var propertyNameChanged = propertyChangedArgs.propertyName;
+        var oldValue = propertyChangedArgs.oldValue;
+        var newValue = propertyChangedArgs.newValue;
+    });
+    ```
+    @event
+    */
+    propertyChanged: BreezeEvent<PropertyChangedEventArgs>;
+    /** Whether an async validator is still running for this entity - see
+    {@link EntityAspect.validateEntityAsync}. __Read Only__ */
+    get isValidating(): boolean;
+    /** @hidden */
+    static isEntity(obj: StructuralObject): obj is Entity;
+    /**
+    Returns the value of a specified 'property path' for a specified entity.
+  
+    The propertyPath can be either a string delimited with '.' or a string array.
+    */
+    static getPropertyPathValue(obj: Entity, propertyPath: string | string[]): any;
+    /**
+    Returns the {@link EntityKey} for this Entity.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    var entityKey = order.entityAspect.getKey();
+    ```
+    @param forceRefresh - (boolean=false) Forces the recalculation of the key.  This should normally be unnecessary.
+    @returns The {@link EntityKey} associated with this Entity.
+    */
+    getKey(forceRefresh?: boolean): EntityKey;
+    /**
+    Returns the entity to an {@link EntityState} of 'Unchanged' by committing all changes made since the entity was last queried
+    had 'acceptChanges' called on it.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.acceptChanges();
+    // The 'order' entity will now be in an 'Unchanged' state with any changes committed.
+    ```
+    */
+    acceptChanges(): void;
+    /**
+    Returns the entity to an {@link EntityState} of 'Unchanged' by rejecting all changes made to it since the entity was last queried
+    had 'rejectChanges' called on it.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.rejectChanges();
+    // The 'order' entity will now be in an 'Unchanged' state with any changes rejected.
+    ```
+    */
+    rejectChanges(): void;
+    /**
+    Sets the entity to an EntityState of 'Added'.  This is NOT the equivalent of calling {@link EntityManager.addEntity}
+    because no key generation will occur for autogenerated keys as a result of this operation. As a result this operation can be problematic
+    unless you are certain that the entity being marked 'Added' does not already exist in the database and does not have an autogenerated key.
+    The same operation can be performed by calling {@link EntityAspect.setEntityState}.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setAdded();
+    // The 'order' entity will now be in an 'Added' state.
+    ```
+    */
+    setAdded(): boolean;
+    /**
+    Sets the entity to an EntityState of 'Unchanged'.  This is also the equivalent of calling {@link EntityAspect.acceptChanges}.
+    The same operation can be performed by calling {@link EntityAspect.setEntityState}.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setUnchanged();
+    // The 'order' entity will now be in an 'Unchanged' state with any changes committed.
+    ```
+    */
+    setUnchanged: () => any;
+    /**
+    Sets the entity to an EntityState of 'Modified'.  This can also be achieved by changing the value of any property on an 'Unchanged' entity.
+    The same operation can be performed by calling {@link EntityAspect.setEntityState}.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setModified();
+    // The 'order' entity will now be in a 'Modified' state.
+    ```
+    */
+    setModified: () => any;
+    /**
+    Sets the entity to an EntityState of 'Deleted'.  This both marks the entity as being scheduled for deletion during the next 'Save' call
+    but also removes the entity from all of its related entities.  If the current entityState is 'Added', then `setDeleted()` will mark it 'Detached'
+    The same operation can be performed by calling {@link EntityAspect.setEntityState}.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setDeleted();
+    // The 'order' entity will now be in a 'Deleted' state and it will no longer have any 'related' entities.
+    ```
+    */
+    setDeleted: () => any;
+    /**
+    Sets the entity to an EntityState of 'Detached'.  This removes the entity from all of its related entities, but does NOT change the EntityState of any existing entities.
+    The same operation can be performed by calling {@link EntityAspect.setEntityState}.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setDetached();
+    // The 'order' entity will now be in a 'Detached' state and it will no longer have any 'related' entities.
+    ```
+    */
+    setDetached: () => any;
+    /**
+    Sets the entity to the specified EntityState. See also 'setUnchanged', 'setModified', 'setDetached', etc.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    order.entityAspect.setEntityState(EntityState.Unchanged);
+    // The 'order' entity will now be in a 'Unchanged' state.
+    ```
+    */
+    setEntityState(entityState: EntityState): boolean;
+    loadNavigationProperty(navigationProperty: string): Promise<QueryResult>;
+    loadNavigationProperty(navigationProperty: NavigationProperty): Promise<QueryResult>;
+    /** @deprecated Await the returned promise instead of passing callbacks. */
+    loadNavigationProperty(navigationProperty: string, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;
+    /** @deprecated Await the returned promise instead of passing callbacks. */
+    loadNavigationProperty(navigationProperty: NavigationProperty, callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult>;
+    /**
+    Marks this navigationProperty on this entity as already having been loaded.
+    ```ts
+    emp.entityAspect.markNavigationPropertyAsLoaded("Orders");
+    ```
+    @param navigationProperty - The NavigationProperty or name of NavigationProperty to 'load'.
+    */
+    markNavigationPropertyAsLoaded(navigationProperty: NavigationProperty | string): void;
+    isNavigationPropertyLoaded(navigationProperty: string): boolean;
+    isNavigationPropertyLoaded(navigationProperty: NavigationProperty): boolean;
+    /**
+    Performs validation on the entity, any errors encountered during the validation are available via the
+    {@link EntityAspect.getValidationErrors} method. Validating an entity means executing
+    all of the validators on both the entity itself as well as those on each of its properties.
+    ```ts
+    // assume order is an order entity attached to an EntityManager.
+    var isOk = order.entityAspect.validateEntity();
+    // isOk will be 'true' if there are no errors on the entity.
+    if (!isOk) {
+        var errors = order.entityAspect.getValidationErrors();
+    }
+    ```
+    @returns Whether the entity can be saved: every validator passes, and no error added with
+    {@link EntityAspect.addValidationError} remains. Errors from the server are not counted - a save
+    clears them before validating, and the server checks again. This is the check `saveChanges`
+    makes, so the two always agree.
+    */
+    validateEntity(): boolean;
+    validateProperty(property: string, context?: any): boolean;
+    validateProperty(property: DataProperty, context?: any): boolean;
+    validateProperty(property: NavigationProperty, context?: any): boolean;
+    /**
+    Validates the entity as {@link EntityAspect.validateEntity} does, and also runs its async
+    validators - see {@link Validator.isAsync} - resolving when they have all answered. This is the
+    check `saveChanges` makes when any of the entities it saves has an async validator.
+    ```ts
+    if (!await order.entityAspect.validateEntityAsync()) {
+      const errors = order.entityAspect.getValidationErrors();
+    }
+    ```
+    While it runs, {@link EntityAspect.isValidating} is true. If a property changes while one of its
+    checks runs, the check is run again on the new value.
+    @returns Whether the entity can be saved, as {@link EntityAspect.validateEntity} answers, once the
+    async validators' answers are in.
+    */
+    validateEntityAsync(): Promise<boolean>;
+    /**
+    Validates one property as {@link EntityAspect.validateProperty} does, and also runs its async
+    validators, resolving when they have all answered.
+    ```ts
+    const isOk = await customer.entityAspect.validatePropertyAsync("companyName");
+    ```
+    @param property - The property, by {@link DataProperty}, {@link NavigationProperty}, name, or path
+    to a property of a complex object.
+    @param context - Additional context for each {@link Validator}.
+    @returns Whether the property can be saved, once the async validators' answers are in.
+    */
+    validatePropertyAsync(property: EntityProperty | string, context?: any): Promise<boolean>;
+    getValidationErrors(): ValidationError[];
+    getValidationErrors(property: string): ValidationError[];
+    getValidationErrors(property: EntityProperty): ValidationError[];
+    /**
+    The value a property had before the entity's pending changes: its original value if it has been
+    edited since the entity was last saved or accepted, and its current value if not. So it answers
+    "what was this?" without first asking whether it changed.
+    ```ts
+    order.freight = 99;
+    order.entityAspect.getOriginalValue('freight');    // the freight before the edit
+    order.entityAspect.getOriginalValue('shipCity');   // unchanged, so its current value
+    ```
+    Also takes a path into a complex property, such as `'location.city'`.
+    @param propertyName - A data property of this entity, or a path to one in a complex property.
+    */
+    getOriginalValue(propertyName: string): any;
+    /**
+    The data properties whose value now differs from the one the entity was last saved or accepted
+    with - as paths, such as `'location.city'`, for those of a complex property, and by name for an
+    array property whose contents changed. A property edited and then set back is not included,
+    although it stays in {@link EntityAspect.originalValues}. Dates are compared by time.
+    ```ts
+    order.freight = 99;
+    order.shipCity = order.shipCity;              // set, but to the same value
+    order.entityAspect.getChangedProperties();    // ['freight']
+    ```
+    Always empty for an `Added` entity, which has no original values to differ from.
+    */
+    getChangedProperties(): string[];
+    /**
+    Adds a validation error.
+  
+    An error added here stops the entity being saved - `validateEntity` returns false and
+    `saveChanges` rejects - until it is removed with {@link EntityAspect.removeValidationError} or
+    {@link EntityAspect.clearValidationErrors}. Editing the property does not remove it: Breeze
+    cannot re-check a rule it did not run. Give the error a key, and a failed save names it by that
+    key in `errorName`.
+    */
+    addValidationError(validationError: ValidationError): void;
+    removeValidationError(validationError: ValidationError): void;
+    removeValidationError(validationKey: string): void;
+    removeValidationError(validator: Validator): void;
+    /**
+    Removes all of the validation errors for a specified entity
+    */
+    clearValidationErrors(): void;
+    /**
+    Returns an {@link EntityKey} for the entity pointed to by the specified scalar NavigationProperty.
+    This only returns an EntityKey if the current entity is a 'child' entity along the specified NavigationProperty.
+    i.e. has a single parent.
+  
+    @param navigationProperty - The {@link NavigationProperty} ( pointing to a parent).
+    @returns Either a parent EntityKey if this is a 'child' entity or null;
+    */
+    getParentKey(navigationProperty: NavigationProperty): EntityKey | null;
+    /**
+    Returns the value of a specified DataProperty or NavigationProperty or 'property path'.
+    */
+    getPropertyValue(property: string | DataProperty | NavigationProperty): any;
+}
+/**
+An ComplexAspect instance is associated with every complex object instance and is accessed via the complex object's 'complexAspect' property.
+
+The ComplexAspect itself provides properties to determine the parent object, parent property and original values for the complex object.
+
+A ComplexAspect will almost never need to be constructed directly. You will usually get an ComplexAspect by accessing
+an entities 'complexAspect' property.  This property will be automatically attached when an complex object is created as part of an
+entity via either a query, import or EntityManager.createEntity call.
+```ts
+// assume address is a complex property on the 'Customer' type
+var aspect = aCustomer.address.complexAspect;
+// aCustomer === aspect.parent;
+```
+*/
+export declare class ComplexAspect {
+    /** The complex object that this aspect is associated with. __Read Only__ */
+    complexObject: ComplexObject;
+    /** The 'original values' of this complex object where they are different from the 'current values'.
+    This is a map where the key is a property name and the value is the 'original value' of the property.
+    __Read Only__ */
+    originalValues: Record<string, any>;
+    /** The parent object that to which this aspect belongs; this will either be an entity or another complex object. __Read Only__ */
+    parent?: StructuralObject;
+    /** The {@link DataProperty} on the 'parent' that contains this complex object. __Read Only__ */
+    parentProperty?: DataProperty;
+    /** Unlike {@link EntityAspect.extraMetadata}, Breeze does not fill this in and does not export it.
+    An application may use it to hold its own data about the complex object. */
+    extraMetadata?: any;
+    /** You will rarely, if ever, create a ComplexAspect directly. */
+    constructor(complexObject: ComplexObject, parent: StructuralObject, parentProperty: DataProperty);
+    /**
+    Returns the EntityAspect for the top level entity that contains this complex object.
+    */
+    getEntityAspect(): any;
+}
+/**
+An {@link EntityAspect} that knows its entity's class, `T`: the type a generated entity class gives
+its `entityAspect`, as `EntityAspectOf<this>`. It is the same object; only the types are narrower -
+property names are checked, and values have their properties' types:
+```ts
+order.freight = 99;
+order.entityAspect.originalValues.freight;          // number | undefined
+order.entityAspect.getOriginalValue('freight');     // number
+order.entityAspect.getOriginalValue('frieght');     // error: not a property of Order
+order.entityAspect.getChangedProperties();          // ('freight' | 'shipCity' | …)[]
+```
+An interface extending the class, rather than a type parameter on it, so that it is an
+`EntityAspect` by declaration: a generic `EntityAspect<T>` whose members read `keyof T` would not be
+one, and every generated class needs its aspect to be. And typed only by `T`'s own data properties:
+to reach through a navigation property, the types would have to ask whether the entity at the other
+end is an `Entity` - which asks about its aspect, and so about this one.
+*/
+export interface EntityAspectOf<T> extends EntityAspect {
+    /** {@link EntityAspect.originalValues}, keyed and typed by `T`'s data properties. */
+    originalValues: OriginalValues<T>;
+    /** {@link EntityAspect.getOriginalValue}, with the name checked against `T` and the value typed. */
+    getOriginalValue<K extends DataKeys<T>>(propertyName: K): T[K];
+    /** {@link EntityAspect.getOriginalValue} for a path into a complex property, such as `'location.city'`: untyped. */
+    getOriginalValue(propertyPath: `${string}.${string}`): any;
+    /** {@link EntityAspect.getChangedProperties}: `T`'s data properties, and paths into its complex ones. */
+    getChangedProperties(): (DataKeys<T> | `${string}.${string}`)[];
+}
+/**
+A {@link ComplexAspect} that knows its complex object's class, `T`: the type a generated complex type
+class gives its `complexAspect`, as `ComplexAspectOf<this>`. See {@link EntityAspectOf}.
+*/
+export interface ComplexAspectOf<T> extends ComplexAspect {
+    /** {@link ComplexAspect.originalValues}, keyed and typed by `T`'s data properties. */
+    originalValues: OriginalValues<T>;
+}