Merge pull request #441 from Diullei/master

breeze updated - 1.2.7

breeze/breeze-1.0-tests.ts

@@ -0,0 +1,787 @@
+/// <reference path="breeze-1.0.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",
+        dataType: breeze.DataType.String,
+        isNullable: true,
+        maxLength: 20
+    });
+    var personEntityType: breeze.EntityType;
+    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() {
+    var order: breeze.Entity;
+    order.entityAspect.acceptChanges();
+    var entityKey = order.entityAspect.getKey();
+    var valErrors = order.entityAspect.getValidationErrors();
+    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.rejectChanges();
+    order.entityAspect.setDeleted();
+    order.entityAspect.setModified();
+    order.entityAspect.setUnchanged();
+    var isOk = order.entityAspect.validateEntity();
+    if (!isOk) {
+        var errors = order.entityAspect.getValidationErrors();
+    }
+    var isOk = order.entityAspect.validateProperty("Order");
+    var orderDateProperty = order.entityType.getProperty("OrderDate");
+    //var isOk = order.entityAspect.validateProperty(OrderDateProperty);
+    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) {
+        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(<breeze.EntityType> empType, 1);
+    var empKey = employee1.entityAspect.getKey();
+    var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
+    var empTerrKey = new breeze.EntityKey(<breeze.EntityType> empTerrType, [1, 77]);
+    var empType = em1.metadataStore.getEntityType("Employee");
+    var empKey1 = new breeze.EntityKey(<breeze.EntityType> empType, 1);
+    var empKey2 = employee1.entityAspect.getKey();
+    if (empKey1.equals(empKey2)) { }
+    if (breeze.EntityKey.equals(empKey1, empKey2)) { }
+}
+
+function test_metadataStore() {
+    var ms = new breeze.MetadataStore();
+    var entityManager = new breeze.EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        metadataStore: ms
+    });
+    var em1: breeze.EntityManager;
+    em1.setProperties({ metadataStore: ms });
+    var metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    var metadataFromStorage = window.localStorage.getItem("metadata");
+    var newMetadataStore = new breeze.MetadataStore();
+    newMetadataStore.importMetadata(metadataFromStorage);
+    var ms = new breeze.MetadataStore();
+    ms.fetchMetadata("api/NorthwindIBModel")
+        .then(function (rawMetadata) { })
+        .fail(function (exception) { });
+    var odType = em1.metadataStore.getEntityType("OrderDetail");
+    var badType = em1.metadataStore.getEntityType("Foo", false);
+    var allTypes = em1.metadataStore.getEntityTypes();
+    if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { }
+    var metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    var metadataFromStorage = window.localStorage.getItem("metadata");
+    var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage);
+    var metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    var metadataFromStorage = window.localStorage.getItem("metadata");
+    var newMetadataStore = new breeze.MetadataStore();
+    newMetadataStore.importMetadata(metadataFromStorage);
+    if (em1.metadataStore.isEmpty()) { }
+    var Customer = function () {
+        this.miscData = "asdf";
+    }
+    em1.metadataStore.registerEntityTypeCtor("Customer", Customer);
+}
+
+function test_entityManager() {
+    var entityManager = new breeze.EntityManager("api/NorthwindIBModel");
+    var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+    var metadataStore = new breeze.MetadataStore();
+    var entityManager = new breeze.EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        metadataStore: metadataStore
+    });
+    return new breeze.QueryOptions({
+        mergeStrategy: null,
+        fetchStrategy: this.fetchStrategy
+    });
+    var queryOptions = new breeze.QueryOptions({
+        mergeStrategy: breeze.MergeStrategy.OverwriteChanges,
+        fetchStrategy: breeze.FetchStrategy.FromServer
+    });
+    var validationOptions = new breeze.ValidationOptions({
+        validateOnAttach: true,
+        validateOnSave: true,
+        validateOnQuery: false
+    });
+    var entityManager = new breeze.EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        queryOptions: queryOptions,
+        validationOptions: validationOptions
+    });
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var cust1 = custType.createEntity();
+    em1.addEntity(cust1);
+    em1.attachEntity(cust1, breeze.EntityState.Added);
+    em1.clear();
+    var em2 = em1.createEmptyCopy();
+    em1.detachEntity(cust1);
+    var serviceName: string;
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders");
+    em.executeQuery(query)
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders");
+    em.executeQuery(query,
+       function (data) {
+           var orders = data.results;
+       },
+       function (err) {
+       });
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders").using(em);
+    query.execute()
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders");
+    var orders = em.executeQueryLocally(query);
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache);
+    em.executeQuery(query)
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var bundle = em1.exportEntities();
+    window.localStorage.setItem("myEntityManager", bundle);
+    var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    var em2 = new breeze.EntityManager({
+        serviceName: em1.serviceName,
+        metadataStore: em1.metadataStore
+    });
+    em2.importEntities(bundleFromStorage);
+    var entitiesToExport: breeze.Entity[];
+    var bundle = em1.exportEntities(entitiesToExport);
+    em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+    var em1 = new breeze.EntityManager("api/NorthwindIBModel");
+    em1.fetchMetadata()
+       .then(function () {
+           var metadataStore = em1.metadataStore;
+       })
+       .fail(function (exception) {
+       });
+    var employeeType = em1.metadataStore.getEntityType("Employee");
+    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()
+        .then(function (data) {
+            var sameCust1 = data.results[0];
+        });
+    var changedEntities = em1.getChanges();
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var changedCustomers = em1.getChanges(custType);
+    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 = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var customers = em1.getEntities(custType);
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var customersAndOrders = em1.getChanges([custType, orderType]);
+    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 = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    if (em1.hasChanges(custType)) { }
+    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);
+    var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    var em2 = breeze.EntityManager.importEntities(bundleFromStorage);
+    var bundle = em1.exportEntities();
+    var em2 = new breeze.EntityManager({
+        serviceName: em1.serviceName,
+        metadataStore: em1.metadataStore
+    });
+    em2.importEntities(bundle);
+    var bundle = em1.exportEntities();
+    em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges });
+    em.saveChanges().then(function (saveResult) {
+        var savedEntities = saveResult.entities;
+        var keyMappings = saveResult.keyMappings;
+    }).fail(function (e) {
+    });
+    var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true });
+    var entitiesToSave: breeze.Entity[];
+    em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) {
+        var savedEntities = saveResult.entities;
+        var keyMappings = saveResult.keyMappings;
+    }).fail(function (e) {
+    });
+    em.saveChanges(entitiesToSave, null,
+        function (saveResult) {
+            var savedEntities = saveResult.entities;
+            var keyMappings = saveResult.keyMappings;
+        }, function (e) { }
+    );
+    em1.setProperties({
+        serviceName: "api/foo",
+    });
+    var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+    em.entityChanged.subscribe(function (changeArgs) {
+        var action = changeArgs.entityAction;
+        var entity = changeArgs.entity;
+    });
+    var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+    em.hasChangesChanged.subscribe(function (args) {
+        var hasChangesChanged = args.hasChanges;
+        var entityManager = args.entityManager;
+    });
+}
+
+function test_entityQuery() {
+    var query = new breeze.EntityQuery("Customers");
+    var query = new breeze.EntityQuery("Customers")
+       .where("CompanyName", "startsWith", "C")
+       .orderBy("Region");
+    var serviceName: string;
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders").using(em);
+    query.execute()
+        .then(function (data) { })
+        .fail(function (err) { });
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders").using(em);
+    query.execute(
+       function (data) {
+           var orders = data.results;
+       },
+       function (err) { });
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders");
+    em.executeQuery(query)
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var query = new breeze.EntityQuery("Orders").using(em);
+    var orders = query.executeLocally();
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .expand("Orders");
+    var query = new breeze.EntityQuery("Orders")
+        .expand("Customer, Employee");
+    var query = new breeze.EntityQuery("Orders")
+        .expand("Customer, OrderDetails, OrderDetails.Product");
+    var query = breeze.EntityQuery.from("Customers");
+    var query = new breeze.EntityQuery("Customers");
+    var query = new breeze.EntityQuery().from("Customers");
+    var customer: breeze.Entity;
+    var customers: breeze.Entity[];
+    var customersQuery = breeze.EntityQuery.fromEntities(customers);
+    var customersQuery = breeze.EntityQuery.fromEntities(customers)
+        .where("Region", breeze.FilterQueryOp.NotEquals, null);
+    var customerQuery = breeze.EntityQuery.fromEntities(customer);
+    var metadataStore: breeze.MetadataStore;
+    var empType = metadataStore.getEntityType("Employee");
+    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, <breeze.NavigationProperty> ordersNavProp);
+    var query = new breeze.EntityQuery("Customers")
+        .orderBy("CompanyName");
+    var query = new breeze.EntityQuery("Customers")
+        .orderBy("Region, CompanyName");
+    var query = new breeze.EntityQuery("Products")
+        .orderBy("Category.CategoryName");
+    var query = new breeze.EntityQuery("Customers")
+        .orderBy("CompanyName desc");
+    var query = new breeze.EntityQuery("Customers")
+        .orderBy("Region desc, CompanyName desc");
+    var query = new breeze.EntityQuery("Customers")
+        .orderByDesc("CompanyName");
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("CompanyName");
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("Orders");
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("CompanyName, Orders");
+    var query = new breeze.EntityQuery("Orders")
+        .where("Customer.CompanyName", "startsWith", "C")
+        .select("Customer.CompanyName, Customer, OrderDate");
+    var query = new breeze.EntityQuery("Customers")
+       .where("CompanyName", "startsWith", "C")
+       .skip(5);
+    var query = new breeze.EntityQuery("Customers")
+        .take(5);
+    var query = new breeze.EntityQuery("Customers")
+        .top(5);
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders")
+        .using(em);
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders")
+        .using(breeze.MergeStrategy.PreserveChanges);
+    var em = new breeze.EntityManager(serviceName);
+    var query = new breeze.EntityQuery("Orders")
+        .using(breeze.FetchStrategy.FromLocalCache);
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C");
+    var query = new breeze.EntityQuery("Customers")
+        .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+    var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C");
+    var query = new breeze.EntityQuery("Customers")
+        .where(pred);
+    var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null);
+    var query = new breeze.EntityQuery("Customers")
+        .where(pred);
+    var query = new breeze.EntityQuery("Products")
+        .where("Category.CategoryName", "startswith", "S");
+    var query = new breeze.EntityQuery("Customers")
+        .where("toLower(CompanyName)", "startsWith", "c");
+    var query = new breeze.EntityQuery("Customers")
+        .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
+}
+
+function test_entityState() {
+    var anEntity: breeze.Entity;
+    var es = anEntity.entityAspect.entityState;
+    return es.isAdded();
+    return es === breeze.EntityState.Added;
+    var es = anEntity.entityAspect.entityState;
+    return es.isAddedModifiedOrDeleted();
+    return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted;
+    var es = anEntity.entityAspect.entityState;
+    return es.isDeleted();
+    return es === breeze.EntityState.Deleted;
+    var es = anEntity.entityAspect.entityState;
+    return es.isDetached();
+    return es === breeze.EntityState.Detached;
+    var es = anEntity.entityAspect.entityState;
+    return es.isModified();
+    return es === breeze.EntityState.Modified;
+    var es = anEntity.entityAspect.entityState;
+    return es.isUnchanged();
+    return es === breeze.EntityState.Unchanged;
+    var es = anEntity.entityAspect.entityState;
+    return es.isUnchangedOrModified();
+    
+    return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
+}
+
+function test_entityType() {
+    var myMetadataStore: breeze.MetadataStore;
+    var myEntityType: breeze.EntityType;
+    var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty;
+    var em1: breeze.EntityManager;
+    var entityManager = new breeze.EntityType({
+        metadataStore: myMetadataStore,
+        serviceName: "api/NorthwindIBModel",
+        name: "person",
+        namespace: "myAppNamespace"
+    });
+    myEntityType.addProperty(dataProperty1);
+    myEntityType.addProperty(dataProperty2);
+    myEntityType.addProperty(navigationProperty1);
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var countryProp = custType.getProperty("Country");
+    var valFn = function (v) {
+        if (v == null) return true;
+        return (v.substring(0,2) === "US");
+    };
+    var countryValidator = new breeze.Validator("countryIsUS", valFn,
+        { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
+    custType.addValidator(countryValidator, countryProp);
+    countryProp.validators.push(countryValidator);
+    var someEntityLevelValidator: breeze.Validator;
+    custType.addValidator(someEntityLevelValidator);
+    custType.validators.push(someEntityLevelValidator);
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var cust1 = custType.createEntity();
+    em1.addEntity(cust1);
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var customerNameDataProp = custType.getDataProperty("CustomerName");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var customerOrdersNavProp = custType.getDataProperty("Orders");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var arrayOfProps = custType.getProperties();
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var companyNameProp = custType.getProperty("CompanyName");
+    var orderDetailType = <breeze.EntityType> em1.metadataStore.getEntityType("OrderDetail");
+    var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var arrayOfPropNames = custType.getPropertyNames();
+    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();
+
+
+//    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;
+    var myEntity, person: breeze.Entity;
+    var salaryEvent = new core.Event("salaryEvent", person);
+    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, <Function> null);
+    core.Event.enable("validationErrorsChanged", myEntityManager, function (em) {
+        return em.customTag === "blue";
+    });
+    core.Event.isEnabled("propertyChanged", myEntityManager);
+    salaryEvent.publish({ eventType: "payRaise", amount: 100 });
+    salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true);
+    salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { });
+    salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 });
+    salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { });
+    salaryEvent.subscribe(function (eventArgs) {
+        if (eventArgs.eventType === "payRaise") { }
+    });
+    var order: breeze.Entity;
+    order.entityAspect.propertyChanged.subscribe(function (pcEvent) {
+        if (pcEvent.propertyName === "OrderDate") { }
+    });
+    var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { });
+    order.entityAspect.propertyChanged.unsubscribe(token);
+}
+
+function test_localQueryComparisonOptions() {
+    var lqco = new breeze.LocalQueryComparisonOptions({
+        name: "caseSensitive-nonSQL",
+        isCaseSensitive: true,
+        usesSql92CompliantStringComparison: false
+    });
+    lqco.setAsDefault();
+    var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco });
+    var em = new breeze.EntityManager({ metadataStore: ms });
+    var lqco = new breeze.LocalQueryComparisonOptions({
+        isCaseSensitive: false,
+        usesSql92CompliantStringComparison: true
+    });
+    lqco.setAsDefault();
+}
+
+function test_namingConventions() {
+    var namingConv = new breeze.NamingConvention({
+        serverPropertyNameToClient: function (serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function (clientPropertyName) {
+            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({
+        serverPropertyNameToClient: function (serverPropertyName) {
+            return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1);
+        },
+        clientPropertyNameToServer: function (clientPropertyName) {
+            return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1);
+        }
+    });
+    namingConv.setAsDefault();
+}
+
+function test_navigationProperty() {
+    var homeAddressProp = new breeze.NavigationProperty({
+        name: "homeAddress",
+        entityTypeName: "Address:#myNamespace",
+        isScalar: true,
+        associationName: "address_person",
+        foreignKeyNames: ["homeAddressId"]
+    });
+    var homeAddressIdProp = new breeze.DataProperty({
+        name: "homeAddressId",
+        dataType: breeze.DataType.Int32
+    });
+    var personEntityType: breeze.EntityType;
+    personEntityType.addProperty(homeAddressProp);
+    personEntityType.addProperty(homeAddressIdProp);
+}
+
+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);
+    var dt = new Date(88, 9, 12);
+    var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+    var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = breeze.Predicate.create("Freight", ">", 100);
+    var newPred = p1.and(p2, p3);
+    var preds = [p2, p3];
+    var newPred = p1.and(preds);
+    var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+        .and("Size", "gt", 2000);
+    var dt = new Date(88, 9, 12);
+    var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+    var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = breeze.Predicate.create("Freight", ">", 100);
+    var newPred = breeze.Predicate.and(p1, p2, p3);
+    var preds = [p1, p2, p3];
+    var newPred = breeze.Predicate.and(preds);
+    var p1 = breeze.Predicate.create("Freight", "gt", 100);
+    var predArgs: any[] = ["Freight", "gt", 100];
+    var p1 = breeze.Predicate.create(predArgs);
+    var p1 = new breeze.Predicate("Freight", "gt", 100);
+    var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B");
+    if (breeze.Predicate.isPredicate(p1)) { }
+    var p1 = breeze.Predicate.create("Freight", "gt", 100);
+    var not_p1 = breeze.Predicate.not(p1);
+    var not_p1 = p1.not();
+    var not_p1 = breeze.Predicate.create("Freight", "le", 100);
+    var dt = new Date(88, 9, 12);
+    var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+    var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = breeze.Predicate.create("Freight", ">", 100);
+    var newPred = breeze.Predicate.or(p1, p2, p3);
+    var preds = [p1, p2, p3];
+    var newPred = breeze.Predicate.or(preds);
+    var dt = new Date(88, 9, 12);
+    var p1 = breeze.Predicate.create("OrderDate", "ne", dt);
+    var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = breeze.Predicate.create("Freight", ">", 100);
+    var newPred = p1.and(p2, p3);
+    var preds = [p2, p3];
+    var newPred = p1.and(preds);
+    var p4 = breeze.Predicate.create("ShipCity", "startswith", "F")
+        .or("Size", "gt", 2000);
+}
+
+function test_queryOptions() {
+    var em1: breeze.EntityManager;
+    var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+    em1.setProperties({ queryOptions: newQo });
+    var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges });
+    newQo.setAsDefault();
+    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() {
+    var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false });
+    var em1: breeze.EntityManager;
+    em1.setProperties({ validationOptions: newVo });
+    var validationOptions = new breeze.ValidationOptions()
+    var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+    newOptions.setAsDefault();
+    var validationOptions = new breeze.ValidationOptions();
+    var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+}
+
+function test_validator() {
+    var valFn = function (v) {
+        if (v == null) return true;
+        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 = <breeze.EntityType> metadataStore.getEntityType("Customer");
+    var countryProp = custType.getProperty("Country");
+    countryProp.validators.push(countryValidator);
+    function isValidZipCode(value) {
+        var re = /^\d{5}([\-]\d{4})?$/;
+        return (re.test(value));
+    }
+    var valFn = function (v) {
+        if (v.getProperty("Country") === "USA") {
+            var postalCode = v.getProperty("PostalCode");
+            return isValidZipCode(postalCode);
+        }
+        return true;
+    };
+    var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn,
+        { messageTemplate: "For the US, this is not a valid PostalCode" });
+    var em1: breeze.EntityManager;
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    custType.validators.push(zipCodeValidator);
+    var numericRangeValidator = function (context) {
+        var valFn = function (v, ctx) {
+            if (v == null) return true;
+            if (typeof (v) !== "number") return false;
+            if (ctx.min != null && v < ctx.min) return false;
+            if (ctx.max != null && v > ctx.max) return false;
+            return true;
+        };
+        return new breeze.Validator("numericRange", valFn, {
+            messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%",
+            min: context.min,
+            max: context.max
+        });
+    };
+    freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 }));
+    var productType = <breeze.EntityType> em1.metadataStore.getEntityType("Product");
+    var discontinuedProperty = productType.getProperty("Discontinued");
+    discontinuedProperty.validators.push(breeze.Validator.bool());
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    regionProperty.validators.push(breeze.Validator.byte());
+    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 = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var customerIdProperty = custType.getProperty("CustomerID");
+    customerIdProperty.validators.push(breeze.Validator.guid());
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(breeze.Validator.int16());
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(breeze.Validator.int32());
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(breeze.Validator.int64());
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 }));
+    var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(breeze.Validator.number());
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(breeze.Validator.required());
+    var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(breeze.Validator.string());
+    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");
+    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 (v.substr(0,2) ===  "US");
+    };
+    var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" });
+    breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'";
+}
+
+function test_demo() {
+
+    var manager = new breeze.EntityManager('api/northwind');
+
+    var query = new breeze.EntityQuery()
+        .from("Employees");
+
+    manager.executeQuery(query).then(function (data) { });
+}

breeze/breeze-1.0.d.ts

@@ -0,0 +1,731 @@
+// 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;
+        hasChangesChanged: 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;
+        createEntity(entityTypeName: string, propertyInitializer: {}): Entity;
+
+        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;
+    }
+}

breeze/breeze-tests.ts

@@ -1,7 +1,6 @@
 /// <reference path="breeze.d.ts" />
 
-import breeze = module(Breeze);
-import core = module(BreezeCore);
+import core = module(breezeCore);
 
 function test_dataType() {
     var typ = breeze.DataType.DateTime;
@@ -9,9 +8,10 @@ function test_dataType() {
     var isNumber = typ.isNumeric;
     var dv = typ.defaultValue;
     var symbs = breeze.DataType.getSymbols();
-    var x = typ.parentEnum === <BreezeCore.IEnum> breeze.DataType;
+    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() {
@@ -33,6 +33,7 @@ function test_dataService() {
     var em = new breeze.EntityManager({
         dataService: ds
     });
+    
 }
 
 function test_entityAspect() {
@@ -125,12 +126,13 @@ function test_metadataStore() {
 
 function test_entityManager() {
     var entityManager = new breeze.EntityManager("api/NorthwindIBModel");
-    var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
+    var em1 = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
     var metadataStore = new breeze.MetadataStore();
     var entityManager = new breeze.EntityManager({
         serviceName: "api/NorthwindIBModel",
         metadataStore: metadataStore
     });
+    
     return new breeze.QueryOptions({
         mergeStrategy: null,
         fetchStrategy: this.fetchStrategy
@@ -152,6 +154,10 @@ function test_entityManager() {
     var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var cust1 = custType.createEntity();
     em1.addEntity(cust1);
+
+    var cust2 = em1.createEntity("Customer", { companyName: "foo" });
+    var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
+    
     em1.attachEntity(cust1, breeze.EntityState.Added);
     em1.clear();
     var em2 = em1.createEmptyCopy();
@@ -239,7 +245,8 @@ function test_entityManager() {
     if (em1.hasChanges(custType)) { }
     var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
-    if (em1.hasChanges([custType, orderType])) { }
+    if (em1.hasChanges([custType, orderType])) { };
+    
     var bundle = em1.exportEntities();
     window.localStorage.setItem("myEntityManager", bundle);
     var bundleFromStorage = window.localStorage.getItem("myEntityManager");
@@ -280,7 +287,7 @@ function test_entityManager() {
     });
     var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" });
     em.hasChangesChanged.subscribe(function (args) {
-        var hasChangesChanged = args.hasChanges;
+        var hasChanges = args.hasChanges;
         var entityManager = args.entityManager;
     });
 }
@@ -377,6 +384,8 @@ function test_entityQuery() {
     var em = new breeze.EntityManager(serviceName);
     var query = new breeze.EntityQuery("Orders")
         .using(breeze.FetchStrategy.FromLocalCache);
+    var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } });
+    var q2 = query.using(adapter);
     var query = new breeze.EntityQuery("Customers")
         .where("CompanyName", "startsWith", "C");
     var query = new breeze.EntityQuery("Customers")
@@ -393,6 +402,7 @@ function test_entityQuery() {
         .where("toLower(CompanyName)", "startsWith", "c");
     var query = new breeze.EntityQuery("Customers")
         .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM");
+    var q2 = query.toType("foo").orderBy("foo2");
 }
 
 function test_entityState() {
@@ -784,4 +794,4 @@ function test_demo() {
         .from("Employees");
 
     manager.executeQuery(query).then(function (data) { });
-}
+}

breeze/breeze.d.ts

@@ -1,12 +1,13 @@
-// Type definitions for Breeze 1.0
+// Type definitions for Breeze 1.2.7
 // Project: http://www.breezejs.com/
-// Definitions by: Boris Yankov <https://github.com/borisyankov/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, 
+//				   IdeaBlade <https://github.com/IdeaBlade/Breeze/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped 
 
-// Updated Jan 14 2011 - Jay Traband (www.ideablade.com)
+// Updated March 27 2013 - John Lantz (www.ideablade.com)
 
 
-declare module BreezeCore {
+declare module breezeCore {
 
     interface ErrorCallback {
         (error: Error): void;
@@ -53,7 +54,7 @@ declare module BreezeCore {
     }
 }
 
-declare module Breeze {
+declare module breeze {
 
     interface Entity {
         entityAspect: EntityAspect;
@@ -151,6 +152,7 @@ declare module Breeze {
         adapterName: string;
         hasServerMetadata: bool;
         serviceName: string;
+        jsonResultsAdapter: JsonResultsAdapter;
         constructor(config: DataServiceOptions);
     }
 
@@ -158,13 +160,38 @@ declare module Breeze {
         adapterName?: string;
         hasServerMetadata?: bool;
         serviceName?: string;
+        jsonResultsAdapter?: JsonResultsAdapter;
     }
 
-    class DataTypeSymbol extends BreezeCore.EnumSymbol {
+    class JsonResultsAdapter {
+        name: string;
+        extractResults: (data: {}) => {};
+        visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; };
+        constructor(config: {
+            name: string;
+            extractResults?: (data: {}) => {};
+            visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: bool; };
+        });
+    }
+
+    interface QueryContext {
+        query: any; // how to also say it could be an EntityQuery or a string
+        entityManager: EntityManager;
+        jsonResultsAdapter: JsonResultsAdapter; 
+        mergeStrategy: MergeStrategy;
+    }
+
+    interface NodeContext {
+        nodeType: string;
+    }
+
+
+
+    class DataTypeSymbol extends breezeCore.EnumSymbol {
          defaultValue: any;
          isNumeric: bool;
     }
-    interface DataType extends BreezeCore.IEnum {
+    interface DataType extends breezeCore.IEnum {
         Binary: DataTypeSymbol;
         Boolean: DataTypeSymbol;
         Byte: DataTypeSymbol;
@@ -185,9 +212,9 @@ declare module Breeze {
     }
     declare var DataType: DataType; 
 
-    class EntityActionSymbol extends BreezeCore.EnumSymbol {
+    class EntityActionSymbol extends breezeCore.EnumSymbol {
     }
-    interface EntityAction extends BreezeCore.IEnum {
+    interface EntityAction extends breezeCore.IEnum {
         AcceptChanges: EntityActionSymbol;
         Attach: EntityActionSymbol;
         AttachOnImport: EntityActionSymbol;
@@ -248,7 +275,7 @@ declare module Breeze {
         newValue: any;
     }
 
-    class PropertyChangedEvent extends BreezeCore.Event {
+    class PropertyChangedEvent extends breezeCore.Event {
         subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number;
     }
 
@@ -258,7 +285,7 @@ declare module Breeze {
         removed: ValidationError[]; 
     }
 
-    class ValidationErrorsChangedEvent extends BreezeCore.Event {
+    class ValidationErrorsChangedEvent extends breezeCore.Event {
         subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number;
     }
 
@@ -280,7 +307,7 @@ declare module Breeze {
         validationOptions: ValidationOptions;
 
         entityChanged: EntityChangedEvent;
-        hasChangesChanged: BreezeCore.Event;
+        hasChangesChanged: HasChangesChangedEvent;
 
         constructor (config?: EntityManagerOptions);
         constructor (config?: string);
@@ -289,18 +316,17 @@ declare module Breeze {
         attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity;
         clear(): void;
         createEmptyCopy(): EntityManager;
+        createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity;
         detachEntity(entity: Entity): bool;
-        createEntity(entityTypeName: string, propertyInitializer: {}): Entity;
-
         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;
+        fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: bool): Promise;
+        fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: bool): Promise;
+        fetchEntityByKey(entityKey: EntityKey): Promise;
+        fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise;
         generateTempKeyValue(entity: Entity): any;
         getChanges(): Entity[];
         getChanges(entityTypeName: string): Entity[];
@@ -377,10 +403,19 @@ declare module Breeze {
         args: Object;
     }
 
-    class EntityChangedEvent extends BreezeCore.Event {
+    class EntityChangedEvent extends breezeCore.Event {
         subscribe(callback?: (data: EntityChangedEventArgs) => void ): number;
     }
 
+    class HasChangesChangedEventArgs {
+        entityManager: EntityManager;
+        hasChanges: bool;
+    }
+
+    class HasChangesChangedEvent extends breezeCore.Event {
+        subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number;
+    }
+
     class EntityQuery {
         entityManager: EntityManager;
         orderByClause: OrderByClause;
@@ -413,10 +448,13 @@ declare module Breeze {
         skip(count: number): EntityQuery;
         take(count: number): EntityQuery;
         top(count: number): EntityQuery;
+        toType(typeName: string): EntityQuery;
+        toType(type: EntityType): EntityQuery;
 
         using(obj: EntityManager): EntityQuery;
         using(obj: MergeStrategySymbol): EntityQuery;
-        using(obj: FetchStrategySymbol): EntityQuery; 
+        using(obj: FetchStrategySymbol): EntityQuery;
+        using(obj: JsonResultsAdapter): EntityQuery;
 
         where(predicate: Predicate): EntityQuery;
         where(property: string, operator: string, value: any): EntityQuery;
@@ -428,7 +466,7 @@ declare module Breeze {
     interface OrderByClause {
     }
 
-    class EntityStateSymbol extends BreezeCore.EnumSymbol {
+    class EntityStateSymbol extends breezeCore.EnumSymbol {
         isAdded(): bool;
         isAddedModifiedOrDeleted(): bool;
         isDeleted(): bool;
@@ -437,7 +475,7 @@ declare module Breeze {
         isUnchanged(): bool;
         isUnchangedOrModified(): bool;
     }
-    interface EntityState extends BreezeCore.IEnum {
+    interface EntityState extends breezeCore.IEnum {
         Added: EntityStateSymbol;
         Deleted: EntityStateSymbol;
         Detached: EntityStateSymbol;
@@ -490,17 +528,17 @@ declare module Breeze {
         defaultResourceName?: string;
     }
 
-    class FetchStrategySymbol extends BreezeCore.EnumSymbol {
+    class FetchStrategySymbol extends breezeCore.EnumSymbol {
     }
-    interface FetchStrategy extends BreezeCore.IEnum {
+    interface FetchStrategy extends breezeCore.IEnum {
         FromLocalCache: FetchStrategySymbol;
         FromServer: FetchStrategySymbol;
     }
     var FetchStrategy: FetchStrategy;
 
-    class FilterQueryOpSymbol extends BreezeCore.EnumSymbol {
+    class FilterQueryOpSymbol extends breezeCore.EnumSymbol {
     }
-    interface FilterQueryOp extends BreezeCore.IEnum {
+    interface FilterQueryOp extends breezeCore.IEnum {
         Contains: FilterQueryOpSymbol;
         EndsWith: FilterQueryOpSymbol;
         Equals: FilterQueryOpSymbol;
@@ -522,9 +560,9 @@ declare module Breeze {
         setAsDefault(): void;
     }
 
-    class MergeStrategySymbol extends BreezeCore.EnumSymbol {
+    class MergeStrategySymbol extends breezeCore.EnumSymbol {
     }
-    interface MergeStrategy extends BreezeCore.IEnum {
+    interface MergeStrategy extends breezeCore.IEnum {
         OverwriteChanges: MergeStrategySymbol;
         PreserveChanges: MergeStrategySymbol;
     }
@@ -537,8 +575,8 @@ declare module Breeze {
         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;
+        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[];
@@ -728,4 +766,4 @@ declare module Breeze {
         messageTemplate: string;
         message?: string;
     }
-}
+}