From 9c79d22fca92e198336324cd6d0038c3c730385a Mon Sep 17 00:00:00 2001 From: Jay Traband Date: Wed, 16 Jan 2013 10:39:48 -0800 Subject: [PATCH] Updated breeze.d.ts for breeze v 0.84.4 + associated tests --- breeze/breeze-tests.ts | 262 ++++++++------- breeze/breeze.d.ts | 730 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 872 insertions(+), 120 deletions(-) create mode 100644 breeze/breeze.d.ts diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts index 2f3e7e23d..06a50b3fc 100644 --- a/breeze/breeze-tests.ts +++ b/breeze/breeze-tests.ts @@ -1,8 +1,19 @@ -/// +/// 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 === 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( 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( empTerrType, [1, 77]); var empType = em1.metadataStore.getEntityType("Employee"); - var empKey1 = new breeze.EntityKey(empType, 1); + var empKey1 = new breeze.EntityKey( 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 = 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( employeeType, 1); + var employee = em1.fetchEntityByKey(employeeKey); + var emp2 = em1.fetchEntityByKey("Employee", 6); + var emp3 = em1.fetchEntityByKey("Entityee", [6]); + var custType = 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 = em1.metadataStore.getEntityType("Customer"); var changedCustomers = em1.getChanges(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); var changedCustomersAndOrders = em1.getChanges([custType, orderType]); var entities = em1.getEntities(); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var customers = em1.getEntities(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); var customersAndOrders = em1.getChanges([custType, orderType]); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = em1.metadataStore.getEntityType("Order"); var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added); if (em1.hasChanges()) { } - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); if (em1.hasChanges(custType)) { } - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); + var custType = em1.metadataStore.getEntityType("Customer"); + var orderType = 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( 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, 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 = 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 = em1.metadataStore.getEntityType("Customer"); var cust1 = custType.createEntity(); em1.addEntity(cust1); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var customerNameDataProp = custType.getDataProperty("CustomerName"); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var customerOrdersNavProp = custType.getDataProperty("Orders"); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var arrayOfProps = custType.getProperties(); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var companyNameProp = custType.getProperty("CompanyName"); - var orderDetailType = em1.metadataStore.getEntityType("OrderDetail"); + var orderDetailType = em1.metadataStore.getEntityType("OrderDetail"); var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName"); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var arrayOfPropNames = custType.getPropertyNames(); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = 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, 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 = 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 = 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 = em1.metadataStore.getEntityType("Product"); var discontinuedProperty = productType.getProperty("Discontinued"); discontinuedProperty.validators.push(breeze.Validator.bool()); - var orderType = em1.metadataStore.getEntityType("Order"); + var orderType = em1.metadataStore.getEntityType("Order"); var freightProperty = orderType.getProperty("Freight"); regionProperty.validators.push(breeze.Validator.byte()); - var orderType = em1.metadataStore.getEntityType("Order"); + var orderType = 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 = em1.metadataStore.getEntityType("Customer"); var customerIdProperty = custType.getProperty("CustomerID"); customerIdProperty.validators.push(breeze.Validator.guid()); - var orderType = em1.metadataStore.getEntityType("Order"); + var orderType = em1.metadataStore.getEntityType("Order"); var freightProperty = orderType.getProperty("Freight"); freightProperty.validators.push(breeze.Validator.int16()); - var orderType = em1.metadataStore.getEntityType("Order"); + var orderType = em1.metadataStore.getEntityType("Order"); var freightProperty = orderType.getProperty("Freight"); freightProperty.validators.push(breeze.Validator.int32()); - var orderType = em1.metadataStore.getEntityType("Order"); + var orderType = em1.metadataStore.getEntityType("Order"); var freightProperty = orderType.getProperty("Freight"); freightProperty.validators.push(breeze.Validator.int64()); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = 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 = em1.metadataStore.getEntityType("Order"); var freightProperty = orderType.getProperty("Freight"); freightProperty.validators.push(breeze.Validator.number()); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var regionProperty = custType.getProperty("Region"); regionProperty.validators.push(breeze.Validator.required()); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = em1.metadataStore.getEntityType("Customer"); var regionProperty = custType.getProperty("Region"); regionProperty.validators.push(breeze.Validator.string()); - var custType = em1.metadataStore.getEntityType("Customer"); + var custType = 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) { }); diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts new file mode 100644 index 000000000..9bacdf1f8 --- /dev/null +++ b/breeze/breeze.d.ts @@ -0,0 +1,730 @@ +// Type definitions for Breeze 1.0 +// Project: http://www.breezejs.com/ +// Definitions by: Boris Yankov +// 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; + } +} \ No newline at end of file