Update to Breeze 1.5.2

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