diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts
index 3fe45d8bf..a7720ea32 100644
--- a/breeze/breeze-tests.ts
+++ b/breeze/breeze-tests.ts
@@ -1,8 +1,3 @@
-// Type definitions for Breeze 1.4.1
-// Project: http://www.breezejs.com/
-// Definitions by: IdeaBlade <https://github.com/IdeaBlade/Breeze/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped  
-
 /// <reference path="breeze.d.ts" />
 
 import core = breeze.core;
@@ -28,7 +23,7 @@ function test_dataProperty() {
         maxLength: 20
     });
     var personEntityType: breeze.EntityType;
-    personEntityType.addProperty(lastNameProp);
+    personEntityType.addProperty(lastNameProp);   
 }
 
 function test_dataService() {
@@ -50,9 +45,9 @@ function test_entityAspect() {
     var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate");
     var orderDateProperty = order.entityType.getProperty("OrderDate");
     var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty);
-    order.entityAspect.loadNavigationProperty("Orders").then(function (data) {
+    order.entityAspect.loadNavigationProperty("Orders").then(function (data: breeze.QueryResult) {
         var orders = data.results;
-    }).fail(function (exception) { });
+    }).catch(function (exception) { });
     order.entityAspect.rejectChanges();
     order.entityAspect.setDeleted();
     order.entityAspect.setModified();
@@ -109,7 +104,7 @@ function test_metadataStore() {
     var ms = new breeze.MetadataStore();
     ms.fetchMetadata("breeze/NorthwindIBModel")
         .then(function (rawMetadata) { })
-        .fail(function (exception) { });
+        .catch(function (exception) { });
     var odType = em1.metadataStore.getEntityType("OrderDetail");
     var badType = em1.metadataStore.getEntityType("Foo", false);
     var allTypes = em1.metadataStore.getEntityTypes();
@@ -172,14 +167,14 @@ function test_entityManager() {
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders");
     em.executeQuery(query)
-      .then(function (data) {
+      .then(function (data: breeze.QueryResult) {
           var orders = data.results;
-      }).fail(function (err) {
+      }).catch(function (err) {
       });
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders");
     em.executeQuery(query,
-       function (data) {
+       function (data: breeze.QueryResult) {
            var orders = data.results;
        },
        function (err) {
@@ -187,9 +182,9 @@ function test_entityManager() {
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders").using(em);
     query.execute()
-      .then(function (data) {
+      .then(function (data: breeze.QueryResult) {
           var orders = data.results;
-      }).fail(function (err) {
+      }).catch(function (err) {
       });
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders");
@@ -197,9 +192,9 @@ function test_entityManager() {
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache);
     em.executeQuery(query)
-      .then(function (data) {
+      .then(function (data: breeze.QueryResult) {
           var orders = data.results;
-      }).fail(function (err) {
+      }).catch(function (err) {
       });
     var bundle = em1.exportEntities();
     window.localStorage.setItem("myEntityManager", bundle);
@@ -217,7 +212,7 @@ function test_entityManager() {
        .then(function () {
            var metadataStore = em1.metadataStore;
        })
-       .fail(function (exception) {
+       .catch(function (exception) {
        });
     var employeeType = em1.metadataStore.getEntityType("Employee");
     var employeeKey = new breeze.EntityKey(<breeze.EntityType> employeeType, 1);
@@ -228,7 +223,7 @@ function test_entityManager() {
     var custumer = custType.createEntity();
     var customerId = em.generateTempKeyValue(custumer);
     em1.saveChanges()
-        .then(function (data) {
+        .then(function (data: breeze.SaveResult) {
             var sameCust1 = data.entities[0];
         });
     var changedEntities = em1.getChanges();
@@ -263,22 +258,22 @@ function test_entityManager() {
         metadataStore: em1.metadataStore
     });
     em2.importEntities(bundle);
-    var bundle = em1.exportEntities();
-    em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
-    em.saveChanges().then(function (saveResult) {
+    var bundle2 = em1.exportEntities(null, { asString: true, includeMetadata: true });
+    em2.importEntities(bundle2, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+    em.saveChanges().then(function (saveResult: breeze.SaveResult) {
         var savedEntities = saveResult.entities;
         var keyMappings = saveResult.keyMappings;
-    }).fail(function (e) {
+    }).catch(function (e) {
     });
     var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true });
     var entitiesToSave: breeze.Entity[];
-    em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) {
+    em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult: breeze.SaveResult) {
         var savedEntities = saveResult.entities;
         var keyMappings = saveResult.keyMappings;
-    }).fail(function (e) {
+    }).catch(function (e) {
     });
     em.saveChanges(entitiesToSave, null,
-        function (saveResult) {
+        function (saveResult: breeze.SaveResult) {
             var savedEntities = saveResult.entities;
             var keyMappings = saveResult.keyMappings;
         }, function (e) { }
@@ -307,21 +302,21 @@ function test_entityQuery() {
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders").using(em);
     query.execute()
-        .then(function (data) { })
-        .fail(function (err) { });
+        .then(function (data: breeze.QueryResult) { })
+        .catch(function (err) { });
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders").using(em);
     query.execute(
-       function (data) {
+       function (data: breeze.QueryResult) {
            var orders = data.results;
        },
        function (err) { });
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders");
     em.executeQuery(query)
-      .then(function (data) {
+      .then(function (data: breeze.QueryResult) {
           var orders = data.results;
-      }).fail(function (err) {
+      }).catch(function (err) {
       });
     var query = new breeze.EntityQuery("Orders").using(em);
     var orders = query.executeLocally();
@@ -409,6 +404,8 @@ function test_entityQuery() {
     var query = new breeze.EntityQuery("Customers")
         .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
     var q2 = query.toType("foo").orderBy("foo2");
+
+    var json = query.toJSON();
 }
 
 function test_entityState() {
@@ -487,55 +484,53 @@ function test_entityType() {
 }
 
 //function test_enum() {
-// var prototype = {
-// nextDay: function () {
-// var nextIndex = (this.dayIndex + 1) % 7;
-// return DayOfWeek.getSymbols()[nextIndex];
-// }
-// };
-// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
-// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
-// var symbol = DayOfWeek.Friday;
-// if (DayOfWeek.contains(symbol)) { }
-// var dayOfWeek = DayOfWeek.from("Thursday");
-// var symbols = DayOfWeek.getNames();
-// var symbols = DayOfWeek.getSymbols();
-// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { };
-// DayOfWeek.seal();
-// var name = DayOfWeek.Monday.getName();
-// var name = DayOfWeek.Monday.toString();
+//    var prototype = {
+//        nextDay: function () {
+//            var nextIndex = (this.dayIndex + 1) % 7;
+//            return DayOfWeek.getSymbols()[nextIndex];
+//        }
+//    };
+//    var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+//    DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+//    var symbol = DayOfWeek.Friday;
+//    if (DayOfWeek.contains(symbol)) { }
+//    var dayOfWeek = DayOfWeek.from("Thursday");
+//    var symbols = DayOfWeek.getNames();
+//    var symbols = DayOfWeek.getSymbols();
+//    if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { };
+//    DayOfWeek.seal();
+//    var name = DayOfWeek.Monday.getName();
+//    var name = DayOfWeek.Monday.toString();
 
 
-// var prototype = {
-// nextDay: function () {
-// var nextIndex = (this.dayIndex + 1) % 7;
-// return DayOfWeek.getSymbols()[nextIndex];
-// }
-// };
-// var DayOfWeek = new core.Enum("DayOfWeek", prototype);
-// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
-// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 });
-// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 });
-// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 });
-// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 });
-// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true });
-// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true });
-// DayOfWeek.seal();
-// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday;
-// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday;
-// DayOfWeek.Tuesday.isWeekend === undefined;
-// DayOfWeek.Saturday.isWeekend == true;
-// DayOfWeek instanceof core.Enum;
-// core.Enum.isSymbol(DayOfWeek.Wednesday);
-// DayOfWeek.contains(DayOfWeek.Thursday);
-// DayOfWeek.Tuesday.parentEnum == DayOfWeek;
-// DayOfWeek.getSymbols().length === 7;
-// DayOfWeek.Friday.toString() === "Friday";
+//    var prototype = {
+//        nextDay: function () {
+//            var nextIndex = (this.dayIndex + 1) % 7;
+//            return DayOfWeek.getSymbols()[nextIndex];
+//        }
+//    };
+//    var DayOfWeek = new core.Enum("DayOfWeek", prototype);
+//    DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 });
+//    DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 });
+//    DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 });
+//    DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 });
+//    DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 });
+//    DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true });
+//    DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true });
+//    DayOfWeek.seal();
+//    DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday;
+//    DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday;
+//    DayOfWeek.Tuesday.isWeekend === undefined;
+//    DayOfWeek.Saturday.isWeekend == true;
+//    DayOfWeek instanceof core.Enum;
+//    core.Enum.isSymbol(DayOfWeek.Wednesday);
+//    DayOfWeek.contains(DayOfWeek.Thursday);
+//    DayOfWeek.Tuesday.parentEnum == DayOfWeek;
+//    DayOfWeek.getSymbols().length === 7;
+//    DayOfWeek.Friday.toString() === "Friday";
 //}
-
-interface CustomEntityManager extends breeze.EntityManager
-{
-	customTag: string;
+interface CustomEntityManager extends breeze.EntityManager {
+    customTag: string;
 }
 
 function test_event() {
@@ -699,14 +694,12 @@ function test_validationOptions() {
     var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
 }
 
-interface NumericRange
-{
-	max: number;
+interface NumericRange{
+    max: number;
 	min: number;
 }
 
-interface NumericRangeValidatorFunctionContext extends breeze.ValidatorFunctionContext, NumericRange
-{
+interface NumericRangeValidatorFunctionContext extends breeze.ValidatorFunctionContext, NumericRange {
 }
 
 function test_validator() {
@@ -726,7 +719,7 @@ function test_validator() {
         var re = /^\d{5}([\-]\d{4})?$/;
         return (re.test(value));
     }
-    valFn = function (v: any) {
+    var valFn = function (v: any) {
         if (v.getProperty("Country") === "USA") {
             var postalCode = v.getProperty("PostalCode");
             return isValidZipCode(postalCode);
@@ -739,7 +732,7 @@ function test_validator() {
     var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     custType.validators.push(zipCodeValidator);
     var numericRangeValidator = function (context: NumericRange) {
-        var valFn = function (v: any, ctx: NumericRangeValidatorFunctionContext) {
+        var valFn = function (v, ctx: NumericRangeValidatorFunctionContext) {
             if (v == null) return true;
             if (typeof (v) !== "number") return false;
             if (ctx.min != null && v < ctx.min) return false;
@@ -799,15 +792,17 @@ function test_validator() {
     var errMsg = result.errorMessage;
     var context = result.context;
     var sameValidator = result.validator;
-    valFn = function (v: any) {
+    var valFn = function (v: any) {
         if (v == null) return true;
-        return (v.substr(0,2) === "US");
+        return (v.substr(0,2) ===  "US");
     };
     var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" });
     breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
 
     breeze.Validator.register(countryValidator);
     breeze.Validator.registerFactory(() => countryValidator, "country");
+
+    var urlValidator = breeze.Validator.url({ messageTemplate: 'u got that wrong' });
 }
 
 function test_demo() {
@@ -817,7 +812,7 @@ function test_demo() {
     var query = new breeze.EntityQuery()
         .from("Employees");
 
-    manager.executeQuery(query).then(function (data) { });
+    manager.executeQuery(query).then(function (data: breeze.QueryResult) { });
 }
 
 function test_corefns() {
@@ -888,4 +883,4 @@ function test_config() {
     config.registerType(f1, "myCtor");
     s = config.stringifyPad;
     o = config.typeRegistry;
-}
+}
\ No newline at end of file
diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts
index cf26f9aa1..cc7438e45 100644
--- a/breeze/breeze.d.ts
+++ b/breeze/breeze.d.ts
@@ -1,13 +1,15 @@
 // Type definitions for Breeze 1.4
 // Project: http://www.breezejs.com/
-// Definitions by: Boris Yankov <https://github.com/borisyankov/>, IdeaBlade <https://github.com/IdeaBlade/Breeze/>
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // Updated Jan 14 2011 - Jay Traband ( www.ideablade.com).
-// Updated March 27 2013 - John Lantz (www.ideablade.com).
 // Updated Aug 13 2013 - Steve Schmitt ( www.ideablade.com).
-
-/// <reference path="../q/Q.d.ts" />
+// Updated Sep 26 2013 for Breeze 1.4.3 - Steve Schmitt ( www.ideablade.com).
+// Updated Jul 22 2014 for Breeze 1.4.16 - Steve Schmitt ( www.ideablade.com)
+// Updated Aug 22 2014 for Breeze 1.4.17 and removing Q dependency - Steve Schmitt ( www.ideablade.com)
+// Updated Jan 16 2015 for Breeze 1.4.17 to add support for noimplicitany - Kevin Wilson ( www.kwilson.me.uk )
+// Updated Jan 20 2015 for Breeze 1.5.2 and merging changes from DefinitelyTyped
 
 declare module breeze.core {
 
@@ -23,7 +25,7 @@ declare module breeze.core {
     }
 
     class Enum implements IEnum {
-        constructor (name: string, methodObj?: any);
+        constructor(name: string, methodObj?: any);
 
         addSymbol(propertiesObj?: any): EnumSymbol;
         contains(object: any): boolean;
@@ -31,7 +33,7 @@ declare module breeze.core {
         getNames(): string[];
         getSymbols(): EnumSymbol[];
         static isSymbol(object: any): boolean;
-        seal(): void;
+        resolveSymbols(): void;
     }
 
     class EnumSymbol {
@@ -42,7 +44,7 @@ declare module breeze.core {
     }
 
     class Event {
-        constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
+        constructor(name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
 
         static enable(eventName: string, target: any): void;
         static enable(eventName: string, target: any, isEnabled: boolean): void;
@@ -51,25 +53,26 @@ declare module breeze.core {
         static isEnabled(eventName: string, target: any): boolean;
         publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void;
         publishAsync(data: any, errorCallback?: ErrorCallback): void;
-        subscribe(callback?: (data: any) => void ): number;
+        subscribe(callback?: (data: any) => void): number;
         unsubscribe(unsubKey: number): boolean;
+        clear(): void;
     }
 
-    export function objectForEach(obj: Object, kvfn: (key:string, value:any) => void): void;
+    export function objectForEach(obj: Object, kvfn: (key: string, value: any) => void): void;
 
     export function extend(target: Object, source: Object): Object;
     export function propEq(propertyName: string, value: any): (obj: Object) => boolean;
     export function pluck(propertyName: string): (obj: Object) => any;
-    export function arrayEquals(a1: any[], a2: any[], equalsFn: (e1:any, e2:any) => boolean): boolean;
-    export function arrayFirst(a1: any[], predicate: (e:any) => boolean): any;
+    export function arrayEquals(a1: any[], a2: any[], equalsFn: (e1: any, e2: any) => boolean): boolean;
+    export function arrayFirst(a1: any[], predicate: (e: any) => boolean): any;
     export function arrayIndexOf(a1: any[], predicate: (e: any) => boolean): number;
     export function arrayRemoveItem(array: any[], item: any, shouldRemoveMultiple: boolean): any;
     export function arrayRemoveItem(array: any[], predicate: (e: any) => boolean, shouldRemoveMultiple: boolean): any;
-    export function arrayZip(a1: any[], a2: any[], callback: (e1:any, e2:any) => any): any[];
+    export function arrayZip(a1: any[], a2: any[], callback: (e1: any, e2: any) => any): any[];
 
     export function requireLib(libnames: string, errMessage: string): Object;
     export function using(obj: Object, property: string, tempValue: any, fn: () => any): any;
-    export function memoize(fn:Function): any;
+    export function memoize(fn: (...any: any[]) => any): any;
     export function getUuid(): string;
     export function durationToSeconds(duration: string): number;
 
@@ -147,7 +150,6 @@ declare module breeze {
         concurrencyMode: string;
         dataType: DataTypeSymbol;
         defaultValue: any;
-        fixedLength: boolean;
         isComplexProperty: boolean;
         isDataProperty: boolean;
         isInherited: boolean;
@@ -155,24 +157,26 @@ declare module breeze {
         isNullable: boolean;
         isPartOfKey: boolean;
         isUnmapped: boolean;
-        
+
         maxLength: number;
         name: string;
         nameOnServer: string;
         parentType: IStructuralType;
         relatedNavigationProperty: NavigationProperty;
         validators: Validator[];
-        constructor (config: DataPropertyOptions);
+        constructor(config: DataPropertyOptions);
     }
 
     interface DataPropertyOptions {
         complexTypeName?: string;
         concurrencyMode?: string;
+        custom?: any;
         dataType?: DataTypeSymbol;
         defaultValue?: any;
-        fixedLength?: boolean;
+        displayName?: string;
         isNullable?: boolean;
         isPartOfKey?: boolean;
+        isScalar?: boolean;
         isUnmapped?: boolean;
         maxLength?: number;
         name?: string;
@@ -185,6 +189,7 @@ declare module breeze {
         adapterName: string;
         hasServerMetadata: boolean;
         serviceName: string;
+        uriBuilderName: string;
         jsonResultsAdapter: JsonResultsAdapter;
         useJsonp: boolean;
         constructor(config: DataServiceOptions);
@@ -194,17 +199,18 @@ declare module breeze {
     interface DataServiceOptions {
         serviceName?: string;
         adapterName?: string;
+        uriBuilderName?: string;
         hasServerMetadata?: boolean;
         jsonResultsAdapter?: JsonResultsAdapter;
         useJsonp?: boolean;
     }
 
     class DataServiceAdapter {
-        checkForRecomposition(interfaceInitializedArgs: { interfaceName: string; isDefault: boolean}): void;
+        checkForRecomposition(interfaceInitializedArgs: { interfaceName: string; isDefault: boolean }): void;
         initialize(): void;
-        fetchMetadata(metadataStore: MetadataStore, dataService: DataService): Q.Promise<any>;
-        executeQuery(mappingContext: Object): Q.Promise<any>;
-        saveChanges(saveContext: { resourceName: string }, saveBundle: Object): Q.Promise<SaveResult>;
+        fetchMetadata(metadataStore: MetadataStore, dataService: DataService): breeze.promises.IPromise<any>;
+        executeQuery(mappingContext: { getUrl: () => string; query: EntityQuery; dataService: DataService }): breeze.promises.IPromise<any>;
+        saveChanges(saveContext: { resourceName: string; dataService: DataService }, saveBundle: Object): breeze.promises.IPromise<SaveResult>;
         JsonResultsAdapter: JsonResultsAdapter;
     }
 
@@ -232,9 +238,9 @@ declare module breeze {
     }
 
     class DataTypeSymbol extends breeze.core.EnumSymbol {
-         defaultValue: any;
-         isNumeric: boolean;
-         isDate: boolean;
+        defaultValue: any;
+        isNumeric: boolean;
+        isDate: boolean;
     }
     interface DataType extends breeze.core.IEnum {
         Binary: DataTypeSymbol;
@@ -283,6 +289,7 @@ declare module breeze {
         entityState: EntityStateSymbol;
         isBeingSaved: boolean;
         originalValues: Object;
+        extraMetadata: Object;
 
         propertyChanged: PropertyChangedEvent;
         validationErrorsChanged: ValidationErrorsChangedEvent;
@@ -299,8 +306,9 @@ declare module breeze {
 
         isNavigationPropertyLoaded(navigationProperty: string): boolean;
         isNavigationPropertyLoaded(navigationProperty: NavigationProperty): boolean;
-        loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Q.Promise<QueryResult>;
-        loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Q.Promise<QueryResult>;
+
+        loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): breeze.promises.IPromise<QueryResult>;
+        loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): breeze.promises.IPromise<QueryResult>;
 
         rejectChanges(): void;
 
@@ -309,10 +317,14 @@ declare module breeze {
         removeValidationError(validator: Validator, property: NavigationProperty): void;
         removeValidationError(validationError: ValidationError): void;
 
+        /** Sets the entity to an EntityState of 'Added'.  This is NOT the equivalent of calling {{#crossLink "EntityManager/addEntity"}}{{/crossLink}}
+  because no key generation will occur for autogenerated keys as a result of this operation. */
+        setAdded(): void;
         setDeleted(): void;
         setDetached(): void;
         setModified(): void;
         setUnchanged(): void;
+        setEntityState(entityState: EntityStateSymbol): void;
         validateEntity(): boolean;
 
         validateProperty(property: string, context?: any): boolean;
@@ -322,13 +334,15 @@ declare module breeze {
 
     class PropertyChangedEventArgs {
         entity: Entity;
+        property: IProperty;
         propertyName: string;
         oldValue: any;
         newValue: any;
+        parent: any;
     }
 
     class PropertyChangedEvent extends breeze.core.Event {
-        subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
+        subscribe(callback?: (data: PropertyChangedEventArgs) => void): number;
     }
 
     class ValidationErrorsChangedEventArgs {
@@ -338,12 +352,12 @@ declare module breeze {
     }
 
     class ValidationErrorsChangedEvent extends breeze.core.Event {
-        subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
+        subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void): number;
     }
 
     class EntityKey {
-        constructor (entityType: EntityType, keyValue: any);
-        constructor (entityType: EntityType, keyValues: any[]);
+        constructor(entityType: EntityType, keyValue: any);
+        constructor(entityType: EntityType, keyValues: any[]);
 
         equals(entityKey: EntityKey): boolean;
         static equals(k1: EntityKey, k2: EntityKey): boolean;
@@ -356,6 +370,10 @@ declare module breeze {
         entityKey: EntityKey;
         fromCache: boolean;
     }
+    interface ExportEntitiesOptions {
+        asString: boolean;  // default true
+        includeMetadata: boolean;  // default true
+    }
 
     class EntityManager {
         dataService: DataService;
@@ -370,26 +388,26 @@ declare module breeze {
         hasChangesChanged: HasChangesChangedEvent;
         validationErrorsChanged: ValidationErrorsChangedEvent;
 
-        constructor (config?: EntityManagerOptions);
-        constructor (config?: string);
+        constructor(config?: EntityManagerOptions);
+        constructor(config?: string);
 
         addEntity(entity: Entity): Entity;
-        attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
+        attachEntity(entity: Entity, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity;
         clear(): void;
         createEmptyCopy(): EntityManager;
-        createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
-        createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: StrategySymbol): Entity;
-        createEntity(entityType: EntityType, config?: {}, entityState?: EntityStateSymbol): Entity;
+        createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity;
+        createEntity(entityType: EntityType, config?: {}, entityState?: EntityStateSymbol, mergeStrategy?: MergeStrategySymbol): Entity;
         detachEntity(entity: Entity): boolean;
-        executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise<QueryResult>;
-        executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise<QueryResult>;
+        executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise<QueryResult>;
+        executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise<QueryResult>;
 
         executeQueryLocally(query: EntityQuery): Entity[];
         exportEntities(entities?: Entity[], includeMetadata?: boolean): string;
-        fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Q.Promise<EntityByKeyResult>;
-        fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Q.Promise<EntityByKeyResult>;
-        fetchEntityByKey(entityKey: EntityKey, checkLocalCacheFirst?: boolean): Q.Promise<EntityByKeyResult>;
-        fetchMetadata(callback?: (schema: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise<any>;
+        exportEntities(entities?: Entity[], options?: ExportEntitiesOptions): any; // string | Object
+        fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): breeze.promises.IPromise<EntityByKeyResult>;
+        fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): breeze.promises.IPromise<EntityByKeyResult>;
+        fetchEntityByKey(entityKey: EntityKey): breeze.promises.IPromise<EntityByKeyResult>;
+        fetchMetadata(callback?: (schema: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise<any>;
         generateTempKeyValue(entity: Entity): any;
         getChanges(): Entity[];
         getChanges(entityTypeName: string): Entity[];
@@ -417,13 +435,13 @@ declare module breeze {
         hasChanges(entityType: EntityType): boolean;
         hasChanges(entityTypes: EntityType[]): boolean;
 
-        static importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager;
-        static importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager;
-        importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager;
-        importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager;
+        static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): EntityManager;
+        static importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): EntityManager;
+        importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): { entities: Entity[]; tempKeyMapping: { [key: string] : EntityKey } };
+        importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; metadataVersionFn?: (any: any) => void }): { entities: Entity[]; tempKeyMapping: { [key: string]: EntityKey } };
 
         rejectChanges(): Entity[];
-        saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Q.Promise<SaveResult>;
+        saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): breeze.promises.IPromise<SaveResult>;
         setProperties(config: EntityManagerProperties): void;
     }
 
@@ -451,15 +469,29 @@ declare module breeze {
     }
 
     interface ExecuteQueryErrorCallback {
-        (error: { query: EntityQuery; XHR: XMLHttpRequest; entityManager: EntityManager}): void;
+        (error: { query: EntityQuery; httpResponse: HttpResponse; entityManager: EntityManager; message?: string; stack?:string }): void;
     }
 
     interface SaveChangesSuccessCallback {
         (saveResult: SaveResult): void;
     }
 
+    interface EntityError {
+        entity: Entity;
+        errorMessage: string;
+        errorName: string;
+        isServerError: boolean;
+        propertyName: string;
+    }
+
     interface SaveChangesErrorCallback {
-        (error: { XHR: XMLHttpRequest; }): void;
+        (error: {
+            entityErrors: EntityError[];
+            httpResponse: HttpResponse;
+            message: string;
+            stack?: string;
+            status?: number
+        }): void;
     }
 
     class EntityChangedEventArgs {
@@ -469,7 +501,7 @@ declare module breeze {
     }
 
     class EntityChangedEvent extends breeze.core.Event {
-        subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
+        subscribe(callback?: (data: EntityChangedEventArgs) => void): number;
     }
 
     class HasChangesChangedEventArgs {
@@ -478,7 +510,7 @@ declare module breeze {
     }
 
     class HasChangesChangedEvent extends breeze.core.Event {
-        subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
+        subscribe(callback?: (data: HasChangesChangedEventArgs) => void): number;
     }
 
     class EntityQuery {
@@ -492,9 +524,11 @@ declare module breeze {
         takeCount: number;
         wherePredicate: Predicate;
 
-        constructor (resourceName?: string);
+        constructor(resourceName?: string);
+        /** Create query from an expression tree */
+        constructor(tree: Object);
 
-        execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Q.Promise<QueryResult>;
+        execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): breeze.promises.IPromise<QueryResult>;
         executeLocally(): Entity[];
         expand(propertyPaths: string[]): EntityQuery;
         expand(propertyPaths: string): EntityQuery;
@@ -505,9 +539,9 @@ declare module breeze {
         static fromEntityKey(entityKey: EntityKey): EntityQuery;
         static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
         inlineCount(enabled?: boolean): EntityQuery;
-        noTracking(enabled: boolean): EntityQuery;
-        orderBy(propertyPaths: string): EntityQuery;
-        orderBy(propertyPaths: string[]): EntityQuery;
+        noTracking(enabled?: boolean): EntityQuery;
+        orderBy(propertyPaths: string, isDescending?: boolean): EntityQuery;
+        orderBy(propertyPaths: string[], isDescending?: boolean): EntityQuery;
         orderByDesc(propertyPaths: string): EntityQuery;
         orderByDesc(propertyPaths: string[]): EntityQuery;
         select(propertyPaths: string): EntityQuery;
@@ -522,14 +556,18 @@ declare module breeze {
         using(obj: DataService): EntityQuery;
         using(obj: JsonResultsAdapter): EntityQuery;
         using(obj: QueryOptions): EntityQuery;
-        using(obj: StrategySymbol): EntityQuery;        
+        using(obj: MergeStrategySymbol): EntityQuery;
+        using(obj: FetchStrategySymbol): EntityQuery;
 
         where(predicate: Predicate): EntityQuery;
         where(property: string, operator: string, value: any): EntityQuery;
         where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery;
+        where(property: string, filterop: FilterQueryOpSymbol, property2: string, filterop2: FilterQueryOpSymbol, value: any): EntityQuery;  // for any/all clauses
+        where(property: string, filterop: string, property2: string, filterop2: string, value: any): EntityQuery;  // for any/all clauses
         where(predicate: FilterQueryOpSymbol): EntityQuery;
-        where(property: string, filterop: FilterQueryOpSymbol, property2: string, filterop2: FilterQueryOpSymbol,value:any): EntityQuery;
         withParameters(params: Object): EntityQuery;
+
+        toJSON(): string;
     }
 
     interface OrderByClause {
@@ -571,8 +609,8 @@ declare module breeze {
         unmappedProperties: DataProperty[];
         validators: Validator[];
 
-        constructor (config: MetadataStore);
-        constructor (config: EntityTypeOptions);
+        constructor(config: MetadataStore);
+        constructor(config: EntityTypeOptions);
 
         addProperty(property: IProperty): void;
         addValidator(validator: Validator, property?: IProperty): void;
@@ -601,10 +639,15 @@ declare module breeze {
     interface EntityTypeProperties {
         autoGeneratedKeyType?: AutoGeneratedKeyType;
         defaultResourceName?: string;
-    }    
+        serializerFn?: (dataProperty: DataProperty, value: any) => any;
+    }
+
+    class FetchStrategySymbol extends breeze.core.EnumSymbol {
+        private foo; // to distinguish this class from MergeStrategySymbol
+    }
     interface FetchStrategy extends breeze.core.IEnum {
-        FromLocalCache: StrategySymbol;
-        FromServer: StrategySymbol;
+        FromLocalCache: FetchStrategySymbol;
+        FromServer: FetchStrategySymbol;
     }
     var FetchStrategy: FetchStrategy;
 
@@ -622,6 +665,7 @@ declare module breeze {
         NotEquals: FilterQueryOpSymbol;
         StartsWith: FilterQueryOpSymbol;
         Any: FilterQueryOpSymbol;
+        All: FilterQueryOpSymbol;
     }
     var FilterQueryOp: FilterQueryOp;
 
@@ -629,16 +673,18 @@ declare module breeze {
         static caseInsensitiveSQL: LocalQueryComparisonOptions;
         static defaultInstance: LocalQueryComparisonOptions;
 
-        constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
+        constructor(config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; });
 
         setAsDefault(): void;
     }
 
-    class StrategySymbol extends breeze.core.EnumSymbol {
+    class MergeStrategySymbol extends breeze.core.EnumSymbol {
     }
     interface MergeStrategy extends breeze.core.IEnum {
-        OverwriteChanges: StrategySymbol;
-        PreserveChanges: StrategySymbol;
+        OverwriteChanges: MergeStrategySymbol;
+        PreserveChanges: MergeStrategySymbol;
+        SkipMerge: MergeStrategySymbol;
+        Disallowed: MergeStrategySymbol;
     }
     var MergeStrategy: MergeStrategy;
 
@@ -646,11 +692,11 @@ declare module breeze {
         constructor();
         constructor(config?: MetadataStoreOptions);
         namingConvention: NamingConvention;
-        addDataService(dataService: DataService): void;
+        addDataService(dataService: DataService, shouldOverwrite?: boolean): void;
         addEntityType(structuralType: IStructuralType): void;
         exportMetadata(): string;
-        fetchMetadata(dataService: string, callback?: (data: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise<any>;
-        fetchMetadata(dataService: DataService, callback?: (data: any) => void , errorCallback?: breeze.core.ErrorCallback): Q.Promise<any>;
+        fetchMetadata(dataService: string, callback?: (data: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise<any>;
+        fetchMetadata(dataService: DataService, callback?: (data: any) => void, errorCallback?: breeze.core.ErrorCallback): breeze.promises.IPromise<any>;
         getDataService(serviceName: string): DataService;
         getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType;
         getEntityTypes(): IStructuralType[];
@@ -658,11 +704,12 @@ declare module breeze {
         static importMetadata(exportedString: string): MetadataStore;
         importMetadata(exportedString: string, allowMerge?: boolean): MetadataStore;
         isEmpty(): boolean;
-        registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
+        registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) => void, noTrackingFn?: (entity: Entity) => Entity): void;
         trackUnmappedType(entityCtor: Function, interceptor?: Function): void;
         setEntityTypeForResourceName(resourceName: string, entityType: EntityType): void;
         setEntityTypeForResourceName(resourceName: string, entityTypeName: string): void;
         getEntityTypeNameForResourceName(resourceName: string): string;
+        setProperties(config: { name?: string; serializerFn?: Function }): void;
     }
 
     interface MetadataStoreOptions {
@@ -675,7 +722,7 @@ declare module breeze {
         static defaultInstance: NamingConvention;
         static none: NamingConvention;
 
-        constructor (config: NamingConventionOptions);
+        constructor(config: NamingConventionOptions);
 
         clientPropertyNameToServer(clientPropertyName: string): string;
         clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
@@ -704,7 +751,7 @@ declare module breeze {
         relatedDataProperties: DataProperty[];
         validators: Validator[];
 
-        constructor (config: NavigationPropertyOptions);
+        constructor(config: NavigationPropertyOptions);
     }
 
     interface NavigationPropertyOptions {
@@ -719,8 +766,12 @@ declare module breeze {
     }
 
     class Predicate {
-        constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean);
-        constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean);
+        constructor(property: string, operator: string, value: any);
+        constructor(property: string, operator: FilterQueryOpSymbol, value: any);
+        constructor(property: string, operator: string, value: { value: any; isLiteral?: boolean; dataType?: breeze.DataType });
+        constructor(property: string, operator: FilterQueryOpSymbol, value: { value: any; isLiteral?: boolean; dataType?: breeze.DataType });
+        /** Create predicate from an expression tree */
+        constructor(tree: Object);
 
         and: PredicateMethod;
         static and: PredicateMethod;
@@ -738,6 +789,8 @@ declare module breeze {
         toFunction(): Function;
         toString(): string;
         validate(entityType: EntityType): void;
+
+        toJSON(): string;
     }
 
     interface PredicateMethod {
@@ -749,37 +802,56 @@ declare module breeze {
 
     class QueryOptions {
         static defaultInstance: QueryOptions;
-        fetchStrategy: StrategySymbol;
-        mergeStrategy: StrategySymbol;
+        fetchStrategy: FetchStrategySymbol;
+        mergeStrategy: MergeStrategySymbol;
+        /** Whether query should return cached deleted entities (false by default) */
+        includeDeleted: boolean
 
-        constructor (config?: QueryOptionsConfiguration);
+        constructor(config?: QueryOptionsConfiguration);
 
         setAsDefault(): void;
         using(config: QueryOptionsConfiguration): QueryOptions;
-        using(config: StrategySymbol): QueryOptions;        
+        using(config: MergeStrategySymbol): QueryOptions;
+        using(config: FetchStrategySymbol): QueryOptions;
     }
 
     interface QueryOptionsConfiguration {
-        fetchStrategy?: StrategySymbol;
-        mergeStrategy?: StrategySymbol;
+        fetchStrategy?: FetchStrategySymbol;
+        mergeStrategy?: MergeStrategySymbol;
+    }
+
+    interface HttpResponse {
+        config: any;
+        data: Entity[];
+        error?: any;
+        saveContext?: any;
+        status: number;
+        getHeaders(headerName: string): string
     }
 
     interface QueryResult {
+        /** Top level entities returned */
         results: Entity[];
+        /** Query that was executed */
         query: EntityQuery;
-        XHR: XMLHttpRequest;
+        /** Raw response from the server */
+        httpResponse: HttpResponse;
+        /** EntityManager that executed the query */
         entityManager?: EntityManager;
-        inlineCount?: number
+        /** Total number of results available on the server */
+        inlineCount?: number;
+        /** All entities returned by the query.  Differs from results when an expand is used. */
+        retrievedEntities?: Entity[]
     }
 
     class SaveOptions {
         allowConcurrentSaves: boolean;
         resourceName: string;
         dataService: DataService;
-        tag: string;
+        tag: Object;
         static defaultInstance: SaveOptions;
 
-        constructor (config?: { allowConcurrentSaves?: boolean; });
+        constructor(config?: { allowConcurrentSaves?: boolean; });
 
         setAsDefault(): SaveOptions;
         using(config: SaveOptionsConfiguration): SaveOptions;
@@ -789,7 +861,7 @@ declare module breeze {
         allowConcurrentSaves?: boolean;
         resourceName?: string;
         dataService?: DataService;
-        tag?: string;
+        tag?: Object;
     }
 
     interface SaveResult {
@@ -807,7 +879,7 @@ declare module breeze {
         validator: Validator;
         getKey: (validator: Validator, property: string) => string;
 
-        constructor (validator: Validator, context: any, errorMessage: string, key: string);
+        constructor(validator: Validator, context: any, errorMessage: string, key: string);
     }
 
     class ValidationOptions {
@@ -817,7 +889,7 @@ declare module breeze {
         validateOnQuery: boolean;
         validateOnSave: boolean;
 
-        constructor (config?: ValidationOptionsConfiguration);
+        constructor(config?: ValidationOptionsConfiguration);
 
         setAsDefault(): ValidationOptions;
         using(config: ValidationOptionsConfiguration): ValidationOptions;
@@ -831,31 +903,65 @@ declare module breeze {
     }
 
     class Validator {
+        /** Map of standard error message templates keyed by validator name.*/
         static messageTemplates: any;
         context: any;
         name: string;
 
-        constructor (name: string, validatorFn: ValidatorFunction, context?: any);
+        constructor(name: string, validatorFn: ValidatorFunction, context?: any);
 
         static bool(): Validator;
-        static byte(): Validator;
+        /** integer between 0 and 255 inclusive */
+        static byte(context?: { messageTemplate?: string }): Validator;
         static date(): Validator;
+        /** Returns a ISO 8601 duration string Validator. */
         static duration(): Validator;
+        /** Validators number, double, and single are all the same */
+        static number(context?: { messageTemplate?: string }): Validator;
+        /** Validators number, double, and single are all the same */
+        static double(context?: { messageTemplate?: string }): Validator;
+        /** Validators number, double, and single are all the same */
+        static single(context?: { messageTemplate?: string }): Validator;
 
         static guid(): Validator;
-        static int16(): Validator;
-        static int32(): Validator;
-        static int64(): Validator;
-        static maxLength(context: { maxLength: number; }): Validator;
-        static number(): Validator;
-        static required(): Validator;
+        static int16(context?: { messageTemplate?: string }): Validator;
+        static int32(context?: { messageTemplate?: string }): Validator;
+        static int64(context?: { messageTemplate?: string }): Validator;
+        /** Same as int64 */
+        static integer(context?: { messageTemplate?: string }): Validator;
+        static maxLength(context: { maxLength: number; messageTemplate?: string }): Validator;
+        static required(context?: { messageTemplate?: string }): Validator;
         static string(): Validator;
-        static stringLength(context: { maxLength: number; minLength: number; }): Validator;
-        
-        static register(validator: Validator): void;
-        static registerFactory(fn: () => Validator, name: string): void;
+        static stringLength(context: { maxLength: number; minLength: number; messageTemplate?: string }): Validator;
+        /** Returns a credit card number validator that performs a Luhn algorithm checksum test for plausability */
+        static creditCard(context?: { messageTemplate?: string }): Validator;
+        /** Returns a regular expression validator; the expression must be specified in the context parameter */
+        static regularExpression(context: { expression: RegExp; messageTemplate?: string }): Validator;
+        /** Returns the email address validator */
+        static emailAddress(context?: { messageTemplate?: string }): Validator;
+        /** Returns the phone validator, which handles prefix, country code, area code, and local number, with [-/. ] break characters. */
+        static phone(context?: { messageTemplate?: string }): Validator;
+        /** Returns the URL (protocol required) validator */
+        static url(context?: { messageTemplate?: string }): Validator;
+        /** Always returns true */
+        static none(): Validator;
 
+        /** Creates a validator instance from a JSON object or an array of instances from an array of JSON objects. */
+        static fromJSON(json: string): Validator;
+        /** Register a validator instance so that any deserialized metadata can reference it. */
+        static register(validator: Validator): void;
+        /** Register a validator factory so that any deserialized metadata can reference it.  */
+        static registerFactory(fn: () => Validator, name: string): void;
+        /** Creates a regular expression validator with a fixed expression. */
+        static makeRegExpValidator(validatorName: string, expression: RegExp, defaultMessage: string, context?: any): Validator;
+
+        /** Run this validator against the specified value. 
+            @param value {Object} Value to validate
+            @param additionalContext {Object} Any additional contextual information that the Validator can make use of.
+            @return {ValidationError|null} A ValidationError if validation fails, null otherwise        */
         validate(value: any, context?: any): ValidationError;
+
+        /** Returns the message generated by the most recent execution of this Validator. */
         getMessage(): string;
     }
 
@@ -881,18 +987,94 @@ declare module breeze.config {
     var ajax: string;
     var dataService: string;
     var functionRegistry: Object;
-    export function getAdapter(interfaceName: string, adapterName: string): Object;
+    /**
+    Returns the ctor function used to implement a specific interface with a specific adapter name.
+    @method getAdapter
+    @param interfaceName {String} One of the following interface names "ajax", "dataService" or "modelLibrary"
+    @param [adapterName] {String} The name of any previously registered adapter. If this parameter is omitted then
+    this method returns the "default" adapter for this interface. If there is no default adapter, then a null is returned.
+    @return {Function|null} Returns either a ctor function or null.
+    **/
+    export function getAdapter(interfaceName: string, adapterName?: string): Function;
+    /**
+    Returns the adapter instance corresponding to the specified interface and adapter names.
+    @method getAdapterInstance
+    @param interfaceName {String} The name of the interface.
+    @param [adapterName] {String} - The name of a previously registered adapter.  If this parameter is
+    omitted then the default implementation of the specified interface is returned. If there is
+    no defaultInstance of this interface, then the first registered instance of this interface is returned.
+    @return {an instance of the specified adapter}
+    **/
     export function getAdapterInstance(interfaceName: string, adapterName?: string): Object;
-    export function initializeAdapterInstance(interfaceName: string, adapterName: string, isDefault: boolean): void;
-    export function initializeAdapterInstances(config: Object): void;
+    /**
+    Initializes a single adapter implementation. Initialization means either newing a instance of the 
+    specified interface and then calling "initialize" on it or simply calling "initialize" on the instance
+    if it already exists.
+    @method initializeAdapterInstance
+    @param interfaceName {String} The name of the interface to which the adapter to initialize belongs.
+    @param adapterName {String} - The name of a previously registered adapter to initialize.
+    @param [isDefault=true] {Boolean} - Whether to make this the default "adapter" for this interface. 
+    @return {an instance of the specified adapter}
+    **/
+    export function initializeAdapterInstance(interfaceName: string, adapterName: string, isDefault?: boolean): void;
+    /**
+    Initializes a collection of adapter implementations and makes each one the default for its corresponding interface.
+    @method initializeAdapterInstances
+    @param config {Object}
+    @param [config.ajax] {String} - the name of a previously registered "ajax" adapter
+    @param [config.dataService] {String} - the name of a previously registered "dataService" adapter
+    @param [config.modelLibrary] {String} - the name of a previously registered "modelLibrary" adapter
+    @param [config.uriBuilder] {String} - the name of a previously registered "uriBuilder" adapter
+    @return [array of instances]
+    **/
+    export function initializeAdapterInstances(config: Object): Object[];
     var interfaceInitialized: Event;
     var interfaceRegistry: Object;
     var objectRegistry: Object;
+    /**
+    Method use to register implementations of standard breeze interfaces.  Calls to this method are usually
+    made as the last step within an adapter implementation. 
+    @method registerAdapter
+    @param interfaceName {String} - one of the following interface names "ajax", "dataService" or "modelLibrary"
+    @param adapterCtor {Function} - an ctor function that returns an instance of the specified interface.  
+    **/
     export function registerAdapter(interfaceName: string, adapterCtor: Function): void;
     export function registerFunction(fn: Function, fnName: string): void;
     export function registerType(ctor: Function, typeName: string): void;
     //static setProperties(config: Object): void; //deprecated
+    /** 
+    Set the promise implementation, if Q.js is not found.
+    @param q - implementation of promise.  @see http://wiki.commonjs.org/wiki/Promises/A
+    */
+    export function setQ(q: breeze.promises.IPromiseService): void;
     var stringifyPad: string;
     var typeRegistry: Object;
 
 }
+
+/** Promises interface used by Breeze.  Usually implemented by Q (https://github.com/kriskowal/q) or angular.$q using breeze.config.setQ(impl) */
+declare module breeze.promises {
+    interface IPromise<T> {
+        then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => U): IPromise<U>;
+        then<U>(onFulfill: (value: T) => IPromise<U>, onReject?: (reason: any) => U): IPromise<U>;
+        then<U>(onFulfill: (value: T) => U, onReject?: (reason: any) => IPromise<U>): IPromise<U>;
+        then<U>(onFulfill: (value: T) => IPromise<U>, onReject?: (reason: any) => IPromise<U>): IPromise<U>;
+        catch<U>(onRejected: (reason: any) => U): IPromise<U>;
+        catch<U>(onRejected: (reason: any) => IPromise<U>): IPromise<U>;
+        finally(finallyCallback: () => any): IPromise<T>;
+    }
+
+    interface IDeferred<T> {
+        promise: IPromise<T>;
+        resolve(value: T): void;
+        reject(reason: any): void;
+    }
+
+    interface IPromiseService {
+        defer<T>(): IDeferred<T>;
+        reject(reason?: any): IPromise<any>;
+        resolve<T>(object: T): IPromise<T>;
+        resolve<T>(object: IPromise<T>): IPromise<T>;
+    }
+}
+