Updated breeze.d.ts for breeze v 0.84.4 + associated tests

breeze/breeze-tests.ts

@@ -1,8 +1,19 @@
-/// <reference path="breeze-0.65.d.ts" />
+/// <reference path="breeze.d.ts" />
 
 import breeze = module(Breeze);
 import core = module(BreezeCore);
 
+function test_dataType() {
+    var typ = breeze.DataType.DateTime;
+    var nm = typ.getName();
+    var isNumber = typ.isNumeric;
+    var dv = typ.defaultValue;
+    var symbs = breeze.DataType.getSymbols();
+    var x = typ.parentEnum === <BreezeCore.IEnum> breeze.DataType;
+    var isFalse = breeze.DataType.contains(breeze.DataType.Double);
+    var dt = breeze.DataType.fromName("Decimal");
+}
+
 function test_dataProperty() {
     var lastNameProp = new breeze.DataProperty({
         name: "lastName",
@@ -11,7 +22,17 @@ function test_dataProperty() {
         maxLength: 20
     });
     var personEntityType: breeze.EntityType;
-    personEntityType.addProperty(lastNameProp);
+    personEntityType.addProperty(lastNameProp);   
+}
+
+function test_dataService() {
+    var ds = new breeze.DataService({
+        serviceName: "api/NorthwindIBModel",
+        hasServerMetadata: true
+    });
+    var em = new breeze.EntityManager({
+        dataService: ds
+    });
 }
 
 function test_entityAspect() {
@@ -22,10 +43,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) {
-            var orders = data.results;
-        }).fail(function (exception) { });
+    order.entityAspect.loadNavigationProperty("Orders").then(function (data) {
+        var orders = data.results;
+    }).fail(function (exception) { });
     order.entityAspect.rejectChanges();
     order.entityAspect.setDeleted();
     order.entityAspect.setModified();
@@ -37,31 +57,30 @@ function test_entityAspect() {
     var isOk = order.entityAspect.validateProperty("Order");
     var orderDateProperty = order.entityType.getProperty("OrderDate");
     //var isOk = order.entityAspect.validateProperty(OrderDateProperty);
-    order.entityAspect.propertyChanged.subscribe(
-    function (propertyChangedArgs) {
+    order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) {
         var entity = propertyChangedArgs.entity;
         var propertyNameChanged = propertyChangedArgs.propertyName;
         var oldValue = propertyChangedArgs.oldValue;
         var newValue = propertyChangedArgs.newValue;
     });
-    order.entityAspect.validationErrorsChanged.subscribe(
-    function (validationChangeArgs) {
+    order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) {
         var entity = validationChangeArgs.entity;
         var errorsAdded = validationChangeArgs.added;
         var errorsCleared = validationChangeArgs.removed;
     });
+    
 }
 
 function test_entityKey() {
     var em1: breeze.EntityManager;
     var employee1: breeze.Entity;
     var empType = em1.metadataStore.getEntityType("Employee");
-    var entityKey = new breeze.EntityKey(empType, 1);
+    var entityKey = new breeze.EntityKey(<breeze.EntityType> empType, 1);
     var empKey = employee1.entityAspect.getKey();
     var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
-    var empTerrKey = new breeze.EntityKey(empTerrType, [1, 77]);
+    var empTerrKey = new breeze.EntityKey(<breeze.EntityType> empTerrType, [1, 77]);
     var empType = em1.metadataStore.getEntityType("Employee");
-    var empKey1 = new breeze.EntityKey(empType, 1);
+    var empKey1 = new breeze.EntityKey(<breeze.EntityType> empType, 1);
     var empKey2 = employee1.entityAspect.getKey();
     if (empKey1.equals(empKey2)) { }
     if (breeze.EntityKey.equals(empKey1, empKey2)) { }
@@ -130,7 +149,7 @@ function test_entityManager() {
         queryOptions: queryOptions,
         validationOptions: validationOptions
     });
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var cust1 = custType.createEntity();
     em1.addEntity(cust1);
     em1.attachEntity(cust1, breeze.EntityState.Added);
@@ -189,9 +208,11 @@ function test_entityManager() {
        .fail(function (exception) {
        });
     var employeeType = em1.metadataStore.getEntityType("Employee");
-    var employeeKey = new breeze.EntityKey(employeeType, 1);
-    var employee = em1.findEntityByKey(employeeKey);
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var employeeKey = new breeze.EntityKey(<breeze.EntityType> employeeType, 1);
+    var employee = em1.fetchEntityByKey(employeeKey);
+    var emp2 = em1.fetchEntityByKey("Employee", 6);
+    var emp3 = em1.fetchEntityByKey("Entityee", [6]);
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var custumer = custType.createEntity();
     var customerId = em.generateTempKeyValue(custumer);
     em1.saveChanges()
@@ -199,25 +220,25 @@ function test_entityManager() {
             var sameCust1 = data.results[0];
         });
     var changedEntities = em1.getChanges();
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var changedCustomers = em1.getChanges(custType);
-    var custType = em1.metadataStore.getEntityType("Customer");
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var changedCustomersAndOrders = em1.getChanges([custType, orderType]);
     var entities = em1.getEntities();
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customers = em1.getEntities(custType);
-    var custType = em1.metadataStore.getEntityType("Customer");
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var customersAndOrders = em1.getChanges([custType, orderType]);
-    var custType = em1.metadataStore.getEntityType("Customer");
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added);
     if (em1.hasChanges()) { }
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     if (em1.hasChanges(custType)) { }
-    var custType = em1.metadataStore.getEntityType("Customer");
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     if (em1.hasChanges([custType, orderType])) { }
     var bundle = em1.exportEntities();
     window.localStorage.setItem("myEntityManager", bundle);
@@ -258,10 +279,10 @@ function test_entityManager() {
         var entity = changeArgs.entity;
     });
     var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
-    em.hasChanges.subscribe(function (args) {
-        var hasChanges = args.hasChanges;
-        var entityManager = args.entityManager;
-    });
+    //em.hasChanges.subscribe(function (args) {
+    //    var hasChanges = args.hasChanges;
+    //    var entityManager = args.entityManager;
+    //});
 }
 
 function test_entityQuery() {
@@ -309,13 +330,13 @@ function test_entityQuery() {
     var customerQuery = breeze.EntityQuery.fromEntities(customer);
     var metadataStore: breeze.MetadataStore;
     var empType = metadataStore.getEntityType("Employee");
-    var entityKey = new breeze.EntityKey(empType, 1);
+    var entityKey = new breeze.EntityKey(<breeze.EntityType> empType, 1);
     var query = breeze.EntityQuery.fromEntityKey(entityKey);
     var employee: breeze.Entity;
     var entityKey = employee.entityAspect.getKey();
     var query = breeze.EntityQuery.fromEntityKey(entityKey);
     var ordersNavProp = employee.entityType.getProperty("Orders");
-    var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+    var query = breeze.EntityQuery.fromEntityNavigation(employee, <breeze.NavigationProperty> ordersNavProp);
     var query = new breeze.EntityQuery("Customers")
         .orderBy("CompanyName");
     var query = new breeze.EntityQuery("Customers")
@@ -396,6 +417,7 @@ function test_entityState() {
     return es === breeze.EntityState.Unchanged;
     var es = anEntity.entityAspect.entityState;
     return es.isUnchangedOrModified();
+    
     return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
 }
 
@@ -413,11 +435,11 @@ function test_entityType() {
     myEntityType.addProperty(dataProperty1);
     myEntityType.addProperty(dataProperty2);
     myEntityType.addProperty(navigationProperty1);
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var countryProp = custType.getProperty("Country");
     var valFn = function (v) {
         if (v == null) return true;
-        return (core.stringStartsWith(v, "US"));
+        return (v.substring(0,2) === "US");
     };
     var countryValidator = new breeze.Validator("countryIsUS", valFn,
         { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
@@ -426,74 +448,74 @@ function test_entityType() {
     var someEntityLevelValidator: breeze.Validator;
     custType.addValidator(someEntityLevelValidator);
     custType.validators.push(someEntityLevelValidator);
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var cust1 = custType.createEntity();
     em1.addEntity(cust1);
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customerNameDataProp = custType.getDataProperty("CustomerName");
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customerOrdersNavProp = custType.getDataProperty("Orders");
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var arrayOfProps = custType.getProperties();
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var companyNameProp = custType.getProperty("CompanyName");
-    var orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
+    var orderDetailType = <breeze.EntityType> em1.metadataStore.getEntityType("OrderDetail");
     var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var arrayOfPropNames = custType.getPropertyNames();
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     custType.setProperties({
         autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity,
         defaultResourceName: "CustomersAndIncludedOrders"
     });
 }
 
-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();
+//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 });
-    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";
+//}
 
 function test_event() {
     var myEntityManager: breeze.EntityManager;
@@ -502,7 +524,7 @@ function test_event() {
     core.Event.enable("propertyChanged", myEntityManager, false);
     core.Event.enable("propertyChanged", myEntityManager, true);
     core.Event.enable("propertyChanged", myEntity.entityAspect, false);
-    core.Event.enable("propertyChanged", myEntity.entityAspect, null);
+    core.Event.enable("propertyChanged", myEntity.entityAspect, <Function> null);
     core.Event.enable("validationErrorsChanged", myEntityManager, function (em) {
         return em.customTag === "blue";
     });
@@ -548,6 +570,11 @@ function test_namingConventions() {
             return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
         }
     });
+    var nc = new breeze.NamingConvention({
+        serverPropertyNameToClient: function (x) {
+            return "xxx";
+        }
+    });
     var ms = new breeze.MetadataStore({ namingConvention: namingConv });
     var em = new breeze.EntityManager({ metadataStore: ms });
     var namingConv = new breeze.NamingConvention({
@@ -580,6 +607,8 @@ function test_navigationProperty() {
 
 function test_predicate() {
     var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+    var p1a = breeze.Predicate.create("CompanyName", "==", "City");
+    var p2a = p1a.and(p1a.not());
     var query = new breeze.EntityQuery("Customers").where(p1);
     var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null);
     var query = new breeze.EntityQuery("Customers").where(p2);
@@ -633,9 +662,9 @@ function test_queryOptions() {
     em1.setProperties({ queryOptions: newQo });
     var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
     newQo.setAsDefault();
-    var queryOptions = em1.defaultQueryOptions.using(breeze.MergeStrategy.PreserveChanges);
-    var queryOptions = em1.defaultQueryOptions.using(breeze.FetchStrategy.FromLocalCache);
-    var queryOptions = em1.defaultQueryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+    var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges);
+    var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache);
+    var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
 }
 
 function test_validationOptions() {
@@ -652,16 +681,16 @@ function test_validationOptions() {
 function test_validator() {
     var valFn = function (v) {
         if (v == null) return true;
-        return (stringStartsWith(v, "US"));
+        return ( v.substr(0,2)=== "US");
     };
     var countryValidator = new breeze.Validator("countryIsUS", valFn, {
         displayName: "Country",
         messageTemplate: "'%displayName%' must start with 'US'"
     });
     var metadataStore: breeze.MetadataStore;
-    var custType = metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> metadataStore.getEntityType("Customer");
     var countryProp = custType.getProperty("Country");
-    prop.validators.push(countryValidator);
+    countryProp.validators.push(countryValidator);
     function isValidZipCode(value) {
         var re = /^\d{5}([\-]\d{4})?$/;
         return (re.test(value));
@@ -676,7 +705,7 @@ function test_validator() {
     var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn,
         { messageTemplate: "For the US, this is not a valid PostalCode" });
     var em1: breeze.EntityManager;
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     custType.validators.push(zipCodeValidator);
     var numericRangeValidator = function (context) {
         var valFn = function (v, ctx) {
@@ -693,72 +722,65 @@ function test_validator() {
         });
     };
     freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
-    var productType = em1.metadataStore.getEntityType("Product");
+    var productType = <breeze.EntityType> em1.metadataStore.getEntityType("Product");
     var discontinuedProperty = productType.getProperty("Discontinued");
     discontinuedProperty.validators.push(breeze.Validator.bool());
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var freightProperty = orderType.getProperty("Freight");
     regionProperty.validators.push(breeze.Validator.byte());
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var orderDateProperty = orderType.getProperty("OrderDate");
     orderDateProperty.validators.push(breeze.Validator.date());
     var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     v0.validate("adasdfasdf");
     var errMessage = v0.getMessage();
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customerIdProperty = custType.getProperty("CustomerID");
     customerIdProperty.validators.push(breeze.Validator.guid());
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var freightProperty = orderType.getProperty("Freight");
     freightProperty.validators.push(breeze.Validator.int16());
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var freightProperty = orderType.getProperty("Freight");
     freightProperty.validators.push(breeze.Validator.int32());
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var freightProperty = orderType.getProperty("Freight");
     freightProperty.validators.push(breeze.Validator.int64());
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var regionProperty = custType.getProperty("Region");
     regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 }));
-    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var freightProperty = orderType.getProperty("Freight");
     freightProperty.validators.push(breeze.Validator.number());
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var regionProperty = custType.getProperty("Region");
     regionProperty.validators.push(breeze.Validator.required());
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var regionProperty = custType.getProperty("Region");
     regionProperty.validators.push(breeze.Validator.string());
-    var custType = em1.metadataStore.getEntityType("Customer");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var regionProperty = custType.getProperty("Region");
     regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
     var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     var result = validator.validate("asdf");
-    ok(result === null);
+    var ok = result === null;
     result = validator.validate("adasdfasdf");
     var errMsg = result.errorMessage;
     var context = result.context;
     var sameValidator = result.validator;
     var valFn = function (v) {
         if (v == null) return true;
-        return (stringStartsWith(v, "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.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
 }
 
 function test_demo() {
-    var core = breeze.core,
-        entityModel = breeze.entityModel;
 
-    core.config.setProperties({
-        trackingImplementation: entityModel.entityTracking_ko,
-        remoteAccessImplementation: entityModel.remoteAccess_webApi
-    });
+    var manager = new breeze.EntityManager('api/northwind');
 
-    var manager = new entityModel.EntityManager('api/northwind');
-
-    var query = new entityModel.EntityQuery()
+    var query = new breeze.EntityQuery()
         .from("Employees");
 
     manager.executeQuery(query).then(function (data) { });

breeze/breeze.d.ts

@@ -0,0 +1,730 @@
+// Type definitions for Breeze 1.0
+// Project: http://www.breezejs.com/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Updated Jan 14 2011 - Jay Traband ( www.ideablade.com).
+
+
+declare module BreezeCore {
+
+    interface ErrorCallback {
+        (error: Error): void;
+    }
+
+    interface IEnum {
+        contains(object: any): bool;
+        fromName(name: string): EnumSymbol;
+        getNames(): string[];
+        getSymbols(): EnumSymbol[];
+    }
+
+    class Enum implements IEnum {
+        constructor (name: string, methodObj?: any);
+
+        addSymbol(propertiesObj?: any): EnumSymbol;
+        contains(object: any): bool;
+        fromName(name: string): EnumSymbol;
+        getNames(): string[];
+        getSymbols(): EnumSymbol[];
+        static isSymbol(object: any): bool;
+        seal(): void;
+    }
+
+    class EnumSymbol {
+        parentEnum: IEnum;
+
+        getName(): string;
+        toString(): string;
+    }
+
+    class Event {
+        constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback);
+
+        static enable(eventName: string, target: any): void;
+        static enable(eventName: string, target: any, isEnabled: bool): void;
+        static enable(eventName: string, target: any, isEnabled: Function): void;
+
+        static isEnabled(eventName: string, target: any): bool;
+        publish(data: any, publishAsync?: bool, errorCallback?: ErrorCallback): void;
+        publishAsync(data: any, errorCallback?: ErrorCallback): void;
+        subscribe(callback?: (data: any) => void ): number;
+        unsubscribe(unsubKey: number): bool;
+    }
+}
+
+declare module Breeze {
+
+    interface Entity {
+        entityAspect: EntityAspect;
+        entityType: EntityType;
+    }
+
+    interface ComplexObject {
+        complexAspect: ComplexAspect;
+        complexType: ComplexType;
+    }
+
+    interface IProperty {
+        name: string;
+        parentEntityType: EntityType;
+        validators: Validator[];
+        isDataProperty: bool;
+        isNavigationProperty: bool;
+    }
+
+    interface IStructuralType {
+        complexProperties: DataProperty[];
+        dataProperties: DataProperty[];
+        name: string;
+        namespace: string;
+        shortName: string;
+        unmappedProperties: DataProperty[];
+        validators: Validator[];
+    }
+
+    class AutoGeneratedKeyType {
+        static Identity: AutoGeneratedKeyType;
+        static KeyGenerator: AutoGeneratedKeyType;
+        static None: AutoGeneratedKeyType;
+    }
+
+    class ComplexAspect {
+        complexObject: ComplexObject;
+        entityAspect: EntityAspect;
+        parent: Object;
+        parentProperty: DataProperty;
+        propertyPath: string;
+        originalValues: Object;
+    }
+
+    class ComplexType implements IStructuralType {
+        complexProperties: DataProperty[];
+        dataProperties: DataProperty[];
+        name: string;
+        namespace: string;
+        shortName: string;
+        unmappedProperties: DataProperty[];
+        validators: Validator[];
+        addProperty(dataProperty: DataProperty);
+        getProperties(): DataProperty[];
+    }
+
+    class DataProperty implements IProperty {
+        complexTypeName: string;
+        concurrencyMode: string;
+        dataType: DataTypeSymbol;
+        defaultValue: any;
+        fixedLength: bool;
+        isComplexProperty: bool;
+        isDataProperty: bool;
+        isNavigationProperty: bool;
+        isNullable: bool;
+        isPartOfKey: bool;
+        isUnmapped: bool;
+        
+        maxLength: number;
+        name: string;
+        nameOnServer: string;
+        parentEntityType: EntityType;
+        relatedNavigationProperty: NavigationProperty;
+        validators: Validator[];
+        constructor (config: DataPropertyOptions);
+    }
+
+    interface DataPropertyOptions {
+        complexTypeName?: string;
+        concurrencyMode?: string;
+        dataType?: DataTypeSymbol;
+        defaultValue?: any;
+        fixedLength?: bool;
+        isNullable?: bool;
+        isPartOfKey?: bool;
+        isUnmapped?: bool;
+        maxLength?: number;
+        name?: string;
+        nameOnServer?: string;
+        validators?: Validator[];
+    }
+
+    class DataService {
+        adapterName: string;
+        hasServerMetadata: bool;
+        serviceName: string;
+        constructor(config: DataServiceOptions);
+    }
+
+    interface DataServiceOptions {
+        adapterName?: string;
+        hasServerMetadata?: bool;
+        serviceName?: string;
+    }
+
+    class DataTypeSymbol extends BreezeCore.EnumSymbol {
+         defaultValue: any;
+         isNumeric: bool;
+    }
+    interface DataType extends BreezeCore.IEnum {
+        Binary: DataTypeSymbol;
+        Boolean: DataTypeSymbol;
+        Byte: DataTypeSymbol;
+        DateTime: DataTypeSymbol;
+        Decimal: DataTypeSymbol;
+        Double: DataTypeSymbol;
+        Guid: DataTypeSymbol;
+        Int16: DataTypeSymbol;
+        Int32: DataTypeSymbol;
+        Int64: DataTypeSymbol;
+        Single: DataTypeSymbol;
+        String: DataTypeSymbol;
+        Time: DataTypeSymbol;
+        Undefined: DataTypeSymbol;
+        toDataType(typeName: string): DataTypeSymbol;
+        parseDateFromServer(date: any): Date;
+
+    }
+    declare var DataType: DataType; 
+
+    class EntityActionSymbol extends BreezeCore.EnumSymbol {
+    }
+    interface EntityAction extends BreezeCore.IEnum {
+        AcceptChanges: EntityActionSymbol;
+        Attach: EntityActionSymbol;
+        AttachOnImport: EntityActionSymbol;
+        AttachOnQuery: EntityActionSymbol;
+        Clear: EntityActionSymbol;
+        Detach: EntityActionSymbol;
+        EntityStateChange: EntityActionSymbol;
+        MergeOnImport: EntityActionSymbol;
+        MergeOnSave: EntityActionSymbol;
+        MergeOnQuery: EntityActionSymbol;
+        PropertyChange: EntityActionSymbol;
+        RejectChanges: EntityActionSymbol;
+    }
+    var EntityAction: EntityAction;
+
+    class EntityAspect {
+        entity: Entity;
+        entityManager: EntityManager;
+        entityState: EntityStateSymbol;
+        isBeingSaved: bool;
+        originalValues: any;
+
+        propertyChanged: PropertyChangedEvent;
+        validationErrorsChanged: ValidationErrorsChangedEvent;
+
+        acceptChanges(): void;
+        addValidationError(validationError: ValidationError): void;
+        clearValidationErrors(): void;
+        getKey(forceRefresh?: bool): EntityKey;
+
+        getValidationErrors(): ValidationError[];
+        getValidationErrors(property: string): ValidationError[];
+        getValidationErrors(property: IProperty): ValidationError[];
+
+        loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise;
+        loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise;
+
+        rejectChanges(): void;
+
+        removeValidationError(validator: Validator): void;
+        removeValidationError(validator: Validator, property: DataProperty): void;
+        removeValidationError(validator: Validator, property: NavigationProperty): void;
+
+        setDeleted(): void;
+        setModified(): void;
+        setUnchanged(): void;
+        validateEntity(): bool;
+
+        validateProperty(property: string, context?: any): bool;
+        validateProperty(property: DataProperty, context?: any): bool;
+        validateProperty(property: NavigationProperty, context?: any): bool;
+    }
+
+    class PropertyChangedEventArgs {
+        entity: Entity;
+        propertyName: string;
+        oldValue: any;
+        newValue: any;
+    }
+
+    class PropertyChangedEvent extends BreezeCore.Event {
+        subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
+    }
+
+    class ValidationErrorsChangedEventArgs {
+        entity: Entity;
+        added: ValidationError[]; 
+        removed: ValidationError[]; 
+    }
+
+    class ValidationErrorsChangedEvent extends BreezeCore.Event {
+        subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
+    }
+
+    class EntityKey {
+        constructor (entityType: EntityType, keyValue: any);
+        constructor (entityType: EntityType, keyValues: any[]);
+
+        equals(entityKey: EntityKey): bool;
+        static equals(k1: EntityKey, k2: EntityKey): bool;
+    }
+
+    class EntityManager {
+        dataService: DataService;
+        keyGeneratorCtor: Function;
+        metadataStore: MetadataStore;
+        queryOptions: QueryOptions;
+        saveOptions: SaveOptions;
+        serviceName: string;
+        validationOptions: ValidationOptions;
+
+        entityChanged: EntityChangedEvent;
+        // hasChanges: BreezeCore.Event;
+
+        constructor (config?: EntityManagerOptions);
+        constructor (config?: string);
+
+        addEntity(entity: Entity): Entity;
+        attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
+        clear(): void;
+        createEmptyCopy(): EntityManager;
+        detachEntity(entity: Entity): bool;
+
+        executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+        executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+
+        executeQueryLocally(query: EntityQuery): Entity[];
+        exportEntities(entities?: Entity[]): string;
+        fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Entity;
+        fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Entity;
+        fetchEntityByKey(entityKey: EntityKey): Entity;
+        fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
+        generateTempKeyValue(entity: Entity): any;
+        getChanges(): Entity[];
+        getChanges(entityTypeName: string): Entity[];
+        getChanges(entityTypeNames: string[]): Entity[];
+        getChanges(entityType: EntityType): Entity[];
+        getChanges(entityTypes: EntityType[]): Entity[];
+
+        getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[];
+        getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[];
+        getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[];
+        getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[];
+
+        getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[];
+        getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[];
+        getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[];
+        getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[];
+
+        getEntityByKey(typeName: string, keyValue: any): Entity;
+        getEntityByKey(typeName: string, keyValues: any[]): Entity;
+        getEntityByKey(entityKey: EntityKey): Entity;
+
+        hasChanges(): bool;
+        hasChanges(entityTypeName: string): bool;
+        hasChanges(entityTypeNames: string[]): bool;
+        hasChanges(entityType: EntityType): bool;
+        hasChanges(entityTypes: EntityType[]): bool;
+
+        static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+        importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager;
+
+        rejectChanges(): Entity[];
+        saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
+        setProperties(config: EntityManagerProperties): void;
+    }
+
+    interface EntityManagerOptions {
+        serviceName?: string;
+        dataService?: DataService;
+        metadataStore?: MetadataStore;
+        queryOptions?: QueryOptions;
+        saveOptions?: SaveOptions;
+        validationOptions?: ValidationOptions;
+        keyGeneratorCtor?: Function;
+    }
+
+    interface EntityManagerProperties {
+        serviceName?: string;
+        dataService?: DataService;
+        queryOptions?: QueryOptions;
+        saveOptions?: SaveOptions;
+        validationOptions?: ValidationOptions;
+        keyGeneratorCtor?: Function;
+    }
+
+    interface ExecuteQuerySuccessCallback {
+        (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void;
+    }
+
+    interface ExecuteQueryErrorCallback {
+        (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void;
+    }
+
+    interface SaveChangesSuccessCallback {
+        (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void;
+    }
+
+    interface SaveChangesErrorCallback {
+        (error: { XHR: XMLHttpRequest; }): void;
+    }
+
+    class EntityChangedEventArgs {
+        entity: Entity;
+        entityAction: EntityActionSymbol;
+        args: Object;
+    }
+
+    class EntityChangedEvent extends BreezeCore.Event {
+        subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
+    }
+
+    class EntityQuery {
+        entityManager: EntityManager;
+        orderByClause: OrderByClause;
+        parameters: Object;
+        queryOptions: QueryOptions;
+        resourceName: string;
+        skipCount: number;
+        takeCount: number;
+        wherePredicate: Predicate;
+
+        constructor (resourceName?: string);
+
+        execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise;
+        executeLocally(): Entity[];
+        expand(propertyPaths: string[]): EntityQuery;
+        expand(propertyPaths: string): EntityQuery;
+        static from(resourceName: string): EntityQuery;
+        from(resourceName: string): EntityQuery;
+        static fromEntities(entity: Entity): EntityQuery;
+        static fromEntities(entities: Entity[]): EntityQuery;
+        static fromEntityKey(entityKey: EntityKey): EntityQuery;
+        static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery;
+        inlineCount(enabled?: bool): EntityQuery;
+        orderBy(propertyPaths: string): EntityQuery;
+        orderBy(propertyPaths: string[]): EntityQuery;
+        orderByDesc(propertyPaths: string): EntityQuery;
+        orderByDesc(propertyPaths: string[]): EntityQuery;
+        select(propertyPaths: string): EntityQuery;
+        select(propertyPaths: string[]): EntityQuery;
+        skip(count: number): EntityQuery;
+        take(count: number): EntityQuery;
+        top(count: number): EntityQuery;
+
+        using(obj: EntityManager): 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(predicate: FilterQueryOpSymbol): EntityQuery;
+        withParameters(params: Object): EntityQuery;
+    }
+
+    interface OrderByClause {
+    }
+
+    class EntityStateSymbol extends BreezeCore.EnumSymbol {
+        isAdded(): bool;
+        isAddedModifiedOrDeleted(): bool;
+        isDeleted(): bool;
+        isDetached(): bool;
+        isModified(): bool;
+        isUnchanged(): bool;
+        isUnchangedOrModified(): bool;
+    }
+    interface EntityState extends BreezeCore.IEnum {
+        Added: EntityStateSymbol;
+        Deleted: EntityStateSymbol;
+        Detached: EntityStateSymbol;
+        Modified: EntityStateSymbol;
+        Unchanged: EntityStateSymbol;
+    }
+    var EntityState: EntityState;
+
+    class EntityType implements IStructuralType {
+        autoGeneratedKeyType: AutoGeneratedKeyType;
+        complexProperties: DataProperty[];
+        concurrencyProperties: DataProperty[];
+        dataProperties: DataProperty[];
+        defaultResourceName: string;
+        foreignKeyProperties: DataProperty[];
+        keyProperties: DataProperty[];
+        metadataStore: MetadataStore;
+        name: string;
+        namespace: string;
+        navigationProperties: NavigationProperty[];
+        shortName: string;
+        unmappedProperties: DataProperty[];
+        validators: Validator[];
+
+        constructor (config: MetadataStore);
+        constructor (config: EntityTypeOptions);
+
+        addProperty(property: IProperty): void;
+        addValidator(validator: Validator, property?: IProperty): void;
+        createEntity(initialValues?: Object): Entity;
+        getDataProperty(propertyName: string): DataProperty;
+        getEntityCtor(): Function;
+        getNavigationProperty(propertyName: string): NavigationProperty;
+        getProperties(): IProperty[];
+        getProperty(propertyPath: string, throwIfNotFound?: bool): IProperty;
+        getPropertyNames(): string[];
+        setProperties(config: EntityTypeProperties): void;
+        toString(): string;
+    }
+
+    interface EntityTypeOptions {
+        shortName?: string;
+        namespace?: string;
+        autogeneratedKeyType?: AutoGeneratedKeyType;
+        defaultResourceName?: string;
+    }
+
+    interface EntityTypeProperties {
+        autogeneratedKeyType?: AutoGeneratedKeyType;
+        defaultResourceName?: string;
+    }
+
+    class FetchStrategySymbol extends BreezeCore.EnumSymbol {
+    }
+    interface FetchStrategy extends BreezeCore.IEnum {
+        FromLocalCache: FetchStrategySymbol;
+        FromServer: FetchStrategySymbol;
+    }
+    var FetchStrategy: FetchStrategy;
+
+    class FilterQueryOpSymbol extends BreezeCore.EnumSymbol {
+    }
+    interface FilterQueryOp extends BreezeCore.IEnum {
+        Contains: FilterQueryOpSymbol;
+        EndsWith: FilterQueryOpSymbol;
+        Equals: FilterQueryOpSymbol;
+        GreaterThan: FilterQueryOpSymbol;
+        GreaterThanOrEqual: FilterQueryOpSymbol;
+        LessThan: FilterQueryOpSymbol;
+        LessThanOrEqual: FilterQueryOpSymbol;
+        NotEquals: FilterQueryOpSymbol;
+        StartsWith: FilterQueryOpSymbol;
+    }
+    var FilterQueryOp: FilterQueryOp;
+
+    class LocalQueryComparisonOptions {
+        static caseInsensitiveSQL: LocalQueryComparisonOptions;
+        static defaultInstance: LocalQueryComparisonOptions;
+
+        constructor (config: { name?: string; isCaseSensitive?: bool; usesSql92CompliantStringComparison?: bool; });
+
+        setAsDefault(): void;
+    }
+
+    class MergeStrategySymbol extends BreezeCore.EnumSymbol {
+    }
+    interface MergeStrategy extends BreezeCore.IEnum {
+        OverwriteChanges: MergeStrategySymbol;
+        PreserveChanges: MergeStrategySymbol;
+    }
+    var MergeStrategy: MergeStrategy;
+
+    class MetadataStore {
+        namingConvention: NamingConvention;
+
+        constructor (config?: MetadataStoreOptions);
+        addDataService(dataService: DataService): void;
+        addEntityType(structuralType: IStructuralType): void;
+        exportMetadata(): string;
+        fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
+        fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise;
+        getDataService(serviceName: string): DataService;
+        getEntityType(entityTypeName: string, okIfNotFound?: bool): IStructuralType;
+        getEntityTypes(): IStructuralType[];
+        hasMetadataFor(serviceName: string): bool;
+        static importMetadata(exportedString: string): MetadataStore;
+        importMetadata(exportedString: string): MetadataStore;
+        isEmpty(): bool;
+        registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
+        trackUnmappedType(entityCtor: Function, interceptor?: Function);
+    }
+
+    interface MetadataStoreOptions {
+        namingConvention?: NamingConvention;
+        localQueryComparisonOptions?: LocalQueryComparisonOptions;
+    }
+
+    class NamingConvention {
+        static camelCase: NamingConvention;
+        static defaultInstance: NamingConvention;
+        static none: NamingConvention;
+
+        constructor (config: NamingConventionOptions);
+
+        clientPropertyNameToServer(clientPropertyName: string): string;
+        clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string;
+
+        serverPropertyNameToClient(serverPropertyName: string): string;
+        serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string;
+
+        setAsDefault();
+    }
+
+    interface NamingConventionOptions {
+        serverPropertyNameToClient?: (name: string) => string;
+        clientPropertyNameToServer?: (name: string) => string;
+    }
+
+    class NavigationProperty implements IProperty {
+        associationName: string;
+        entityType: EntityType;
+        foreignKeyNames: string[];
+        inverse: NavigationProperty;
+        isDataProperty: bool;
+        isNavigationProperty: bool;
+        isScalar: bool;
+        name: string;
+        parentEntityType: EntityType;
+        relatedDataProperties: DataProperty[];
+        validators: Validator[];
+
+        constructor (config: NavigationPropertyOptions);
+    }
+
+    interface NavigationPropertyOptions {
+        name?: string;
+        nameOnServer?: string;
+        entityTypeName: string;
+        isScalar?: bool;
+        associationName?: string;
+        foreignKeyNames?: string[];
+        foreignKeyNamesOnServer?: string[];
+        validators?: Validator[];
+    }
+
+    class Predicate {
+        constructor (property: string, operator: string, value: any, valueIsLiteral?: bool);
+        constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool);
+
+        and: PredicateMethod;
+        static and: PredicateMethod;
+
+        static create: PredicateMethod;
+
+        static isPredicate(o: any): bool;
+
+        static not(predicate: Predicate): Predicate;
+        not(): Predicate;
+
+        static or: PredicateMethod;
+        or: PredicateMethod;
+
+        toFunction(): Function;
+        toString(): string;
+        validate(entityType: EntityType): void;
+    }
+
+    interface PredicateMethod {
+        (predicates: Predicate[]): Predicate;
+        (...predicates: Predicate[]): Predicate;
+        (property: string, operator: string, value: any, valueIsLiteral?: bool): Predicate;
+        (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: bool): Predicate;
+    }
+
+    class Promise {
+        fail(errorCallback: Function): Promise;
+        fin(finallyCallback: Function): Promise;
+        then(callback: Function): Promise;
+    }
+
+    class QueryOptions {
+        static defaultInstance: QueryOptions;
+        fetchStrategy: FetchStrategySymbol;
+        mergeStrategy: MergeStrategySymbol;
+
+        constructor (config?: QueryOptionsConfiguration);
+
+        setAsDefault(): void;
+        using(config: QueryOptionsConfiguration): QueryOptions;
+        using(config: MergeStrategySymbol): QueryOptions;
+        using(config: FetchStrategySymbol): QueryOptions; 
+    }
+
+    interface QueryOptionsConfiguration {
+        fetchStrategy?: FetchStrategySymbol;
+        mergeStrategy?: MergeStrategySymbol;
+    }
+
+    class SaveOptions {
+        allowConcurrentSaves: bool;
+        static defaultInstance: SaveOptions;
+
+        constructor (config?: { allowConcurrentSaves?: bool; });
+
+        setAsDefault(): SaveOptions;
+    }
+
+    class ValidationError {
+        context: any;
+        errorMessage: string;
+        property: IProperty;
+        propertyName: string;
+        validator: Validator;
+
+        constructor (validator: Validator, context: any, errorMessage: string);
+    }
+
+    class ValidationOptions {
+        static defaultInstance: ValidationOptions;
+        validateOnAttach: bool;
+        validateOnPropertyChange: bool;
+        validateOnQuery: bool;
+        validateOnSave: bool;
+
+        constructor (config?: ValidationOptionsConfiguration);
+
+        setAsDefault(): ValidationOptions;
+        using(config: ValidationOptionsConfiguration): ValidationOptions;
+    }
+
+    interface ValidationOptionsConfiguration {
+        validateOnAttach?: bool;
+        validateOnSave?: bool;
+        validateOnQuery?: bool;
+        validateOnPropertyChange?: bool;
+    }
+
+    class Validator {
+        static messageTemplates: any;
+
+        constructor (name: string, validatorFn: ValidatorFunction, context?: any);
+
+        static bool(): Validator;
+        static byte(): Validator;
+        static date(): Validator;
+        static duration(): Validator;
+        getMessage(): string;
+        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 string(): Validator;
+        static stringLength(context: { maxLength: number; minLength: number; }): Validator;
+        validate(value: any, context?: any): ValidationError;
+    }
+
+    interface ValidatorFunction {
+        (value: any, context: ValidatorFunctionContext): void;
+    }
+
+    interface ValidatorFunctionContext {
+        value: any;
+        validatorName: string;
+        displayName: string;
+        messageTemplate: string;
+        message?: string;
+    }
+}