diff --git a/Definitions/breeze-0.65.d.ts b/Definitions/breeze-0.65.d.ts
new file mode 100644
index 000000000..f1ca8759f
--- /dev/null
+++ b/Definitions/breeze-0.65.d.ts
@@ -0,0 +1,582 @@
+// 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
+
+
+
+interface Entity {
+    entityAspect: EntityAspect;
+    entityType: EntityType;
+}
+
+interface ErrorCallback {
+    (error: Error): void;
+}
+
+class AutoGeneratedKeyType {
+    static Identity: AutoGeneratedKeyType;
+    static KeyGenerator: AutoGeneratedKeyType;
+    static None: AutoGeneratedKeyType;
+}
+
+interface DataPropertyOptions {
+    name?: string;
+    nameOnServer?: string;
+    dataType?: DataType;
+    isNullable?: bool;
+    isPartOfKey?: bool;
+    isUnmapped?: bool;
+    concurrencyMode?: string;
+    maxLength?: number;
+    fixedLength?: bool;
+    validators?: Validator[];
+}
+
+class DataProperty {
+    concurrencyMode: string;
+    dataType: DataType;
+    defaultValue: any;
+    fixedLength: bool;
+    isNullable: bool;
+    isPartOfKey: bool;
+    isUnmapped: bool;
+    maxLength: number;
+    name: string;
+    parentEntityType: EntityType;
+    relatedNavigationProperty: NavigationProperty;
+    validators: Validator[];
+
+    constructor (config: DataPropertyOptions);
+}
+
+class DataType {
+    static Binary: DataType;
+    static Boolean: DataType;
+    static Byte: DataType;
+    static DateTime: DataType;
+    static Decimal: DataType;
+    static Double: DataType;
+    static Guid: DataType;
+    static Int16: DataType;
+    static Int32: DataType;
+    static Int64: DataType;
+    static Single: DataType;
+    static String: DataType;
+    static Undefined: DataType;
+
+    defaultValue: any;
+    isNumeric: bool;
+
+    static toDataType(typeName: string): DataType;
+}
+
+class EntityAction {
+    static AcceptChanges: EntityAction;
+    static Attach: EntityAction;
+    static AttachOnImport: EntityAction;
+    static AttachOnQuery: EntityAction;
+    static Clear: EntityAction;
+    static Detach: EntityAction;
+    static EntityStateChange: EntityAction;
+    static MergeOnImport: EntityAction;
+    static MergeOnSave: EntityAction;
+    static MergeOnQuery: EntityAction;
+    static PropertyChange: EntityAction;
+    static RejectChanges: EntityAction;
+}
+
+class EntityAspect {
+    entity: Entity;
+    entityManager: EntityManager;
+    entityState: EntityState;
+    isBeingSaved: bool;
+    originalValues: any;
+
+    propertyChanged: BreezeEvent;
+    validationErrorsChanged: BreezeEvent;
+
+    acceptChanges(): void;
+    addValidationError(validationError: ValidationError): void;
+    getKey(forceRefresh?: bool): EntityKey;
+
+    getValidationErrors(): ValidationError[];
+    getValidationErrors(property: string): ValidationError[];
+    getValidationErrors(property: DataProperty): ValidationError[];
+    getValidationErrors(property: NavigationProperty): 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 EntityKey {
+    constructor (entityType: EntityType, keyValue: any);
+    constructor (entityType: EntityType, keyValues: any[]);
+
+    equals(entityKey: EntityKey): bool;
+    static equals(k1: EntityKey, k2: EntityKey): bool;
+}
+
+interface EntityManagerOptions {
+    serviceName?: string;
+    metadataStore?: MetadataStore;
+    queryOptions?: QueryOptions;
+    saveOptions?: SaveOptions;
+    validationOptions?: ValidationOptions;
+    keyGeneratorCtor?: Function;
+    remoteAccessImplementation?: RemoteAccessImplementation;
+}
+
+interface RemoteAccessImplementation {
+}
+
+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;
+}
+
+interface EntityManagerProperties {
+    serviceName?: string;
+    queryOptions?: QueryOptions;
+    saveOptions?: SaveOptions;
+    validationOptions?: ValidationOptions;
+    remoteAccessImplementation?: RemoteAccessImplementation;
+    keyGeneratorCtor?: Function;
+}
+
+class EntityManager {
+    keyGeneratorCtor: Function;
+    metadataStore: MetadataStore;
+    queryOptions: QueryOptions;
+    remoteAccessImplementation: RemoteAccessImplementation;
+    saveOptions: SaveOptions;
+    serviceName: string;
+    validationOptions: ValidationOptions;
+
+    entityChanged: BreezeEvent;
+    //hasChanges: BreezeEvent;
+
+    constructor (config?: EntityManagerOptions);
+    constructor (config?: string);
+
+    addEntity(entity: Entity): Entity;
+    attachEntity(entity: Entity, entityState?: EntityState): 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;
+    fetchMetadata(callback?: (schema: any) => void , errorCallback?: ErrorCallback): Promise;
+    findEntityByKey(entityKey: EntityKey): Entity;
+    generateTempKeyValue(entity: Entity): any;
+    getChanges(): Entity[];
+
+    getChanges(entityType: EntityType): Entity[];
+    getChanges(entityTypes: EntityType[]): Entity[];
+
+    getEntities(entityTypes: EntityType, entityState?: EntityState): Entity[];
+    getEntities(entityTypes?: EntityType[], entityState?: EntityState): Entity[];
+    getEntities(entityType?: EntityType, entityStates?: EntityState[]): Entity[];
+    getEntities(entityTypes?: EntityType[], entityStates?: EntityState[]): Entity[];
+
+    hasChanges(): bool;
+    hasChanges(entityType: EntityType): bool;
+    hasChanges(entityTypes: EntityType[]): bool;
+
+    static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategy; }): EntityManager;
+    importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategy; }): EntityManager;
+
+    rejectChanges(): Entity[];
+    saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
+    setProperties(config: EntityManagerProperties): void;
+}
+
+class EntityQuery {
+    entityManager: EntityManager;
+    orderByClause: OrderByClause;
+    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;
+    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;
+    orderBy(propertyPaths: string): EntityQuery;
+    orderByDesc(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: MergeStrategy): EntityQuery;
+    //using(obj: FetchStrategy): EntityQuery; !!! same signature as MergeStrategy
+
+    where(predicate: Predicate): EntityQuery;
+    where(property: string, operator: string, value: any): EntityQuery;
+    where(property: string, operator: FilterQueryOp, value: any): EntityQuery;
+    where(predicate: FilterQueryOp): EntityQuery;
+}
+
+interface OrderByClause {
+}
+
+class EntityState {
+    static Added: EntityState;
+    static Deleted: EntityState;
+    static Detached: EntityState;
+    static Modified: EntityState;
+    static Unchanged: EntityState;
+
+    isAdded(): bool;
+    isAddedModifiedOrDeleted(): bool;
+    isDeleted(): bool;
+    isDetached(): bool;
+    isModified(): bool;
+    isUnchanged(): bool;
+    isUnchangedOrModified(): bool;
+}
+
+class EntityType {
+    autoGeneratedKeyType: AutoGeneratedKeyType;
+    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: DataProperty): void;
+    addProperty(property: NavigationProperty): void;
+    addValidator(validator: Validator, property?: any): void;
+    createEntity(): Entity;
+    getDataProperty(propertyName: string): DataProperty;
+    getEntityCtor(): Function;
+    getNavigationProperty(propertyName: string): NavigationProperty;
+    getProperties(): any;
+    getProperty(propertyPath: string, throwIfNotFound?: bool): any;
+    getPropertyNames(): string[];
+    setProperties(config: EntityTypeProperties): void;
+    toString(): string;
+}
+
+interface EntityTypeOptions {
+    metadataStore?: MetadataStore;
+    serviceName?: string;
+    shortName?: string;
+    namespace?: string;
+    defaultResourceName?: string;
+}
+
+interface EntityTypeProperties {
+    autogeneratedKeyType?: AutoGeneratedKeyType;
+    defaultResourceName?: string;
+}
+
+class Enum {
+    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: Enum;
+
+    getName(): string;
+    toString(): string;
+}
+
+class BreezeEvent {
+    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;
+}
+
+class FetchStrategy {
+    static FromLocalCache: MergeStrategy;
+    static FromServer: MergeStrategy;
+}
+
+class FilterQueryOp {
+    static Contains: FilterQueryOp;
+    static EndsWith: FilterQueryOp;
+    static Equals: FilterQueryOp;
+    static GreaterThan: FilterQueryOp;
+    static GreaterThanOrEqual: FilterQueryOp;
+    static LessThan: FilterQueryOp;
+    static LessThanOrEqual: FilterQueryOp;
+    static NotEquals: FilterQueryOp;
+    static StartsWith: FilterQueryOp;
+}
+
+class LocalQueryComparisonOptions {
+    static caseInsensitiveSQL: LocalQueryComparisonOptions;
+    static defaultInstance: LocalQueryComparisonOptions;
+
+    constructor (config: { name?: string; isCaseSensitive?: bool; usesSql92CompliantStringComparison?: bool; });
+
+    setAsDefault(): void;
+}
+
+class MergeStrategy {
+    static OverwriteChanges: MergeStrategy;
+    static PreserveChanges: MergeStrategy;
+}
+
+class MetadataStore {
+    namingConvention: NamingConvention;
+
+    constructor (config?: MetadataStoreOptions);
+
+    exportMetadata(): string;
+    fetchMetadata(serviceName: string, remoteAccessImplementation?: RemoteAccessImplementation, callback?: (data) => void , errorCallback?: ErrorCallback): Promise;
+    getEntityType(entityTypeName: string, okIfNotFound?: bool): EntityType;
+    getEntityTypes(): EntityType[];
+    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: DataProperty): string;
+    clientPropertyNameToServer(clientPropertyName: string, property: NavigationProperty): string;
+
+    serverPropertyNameToClient(serverPropertyName: string): string;
+    serverPropertyNameToClient(serverPropertyName: string, property: DataProperty): string;
+    serverPropertyNameToClient(serverPropertyName: string, property: NavigationProperty): string;
+
+    setAsDefault();
+}
+
+interface NamingConventionOptions {
+    serverPropertyNameToClient?: Function;
+    clientPropertyNameToServer?: Function;
+}
+
+class NavigationProperty {
+    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);
+    constructor (property: string, operator: FilterQueryOp, value: any);
+
+    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): bool;
+}
+
+interface PredicateMethod {
+    (predicates: Predicate[]): Predicate;
+    (...predicates: Predicate[]): Predicate;
+    (property: string, operator: string, value: any): Predicate;
+    (property: string, operator: FilterQueryOp, value: any): Predicate;
+}
+
+class Promise {
+    fail(errorCallback: Function): Promise;
+    fin(finallyCallback: Function): Promise;
+    then(callback: Function): Promise;
+}
+
+class QueryOptions {
+    static defaultInstance: QueryOptions;
+    fetchStrategy: FetchStrategy;
+    mergeStrategy: MergeStrategy;
+
+    constructor (config?: QueryOptionsConfiguration);
+
+    setAsDefault(): void;
+    using(config: QueryOptionsConfiguration): QueryOptions;
+    using(config: MergeStrategy): QueryOptions;
+    // using(config: FetchStrategy): QueryOptions; !!! same signature as MergeStrategy
+}
+
+interface QueryOptionsConfiguration {
+    fetchStrategy?: FetchStrategy;
+    mergeStrategy?: MergeStrategy;
+}
+
+class SaveOptions {
+    allowConcurrentSaves: bool;
+    static defaultInstance: SaveOptions;
+
+    constructor (config?: { allowConcurrentSaves?: bool; });
+
+    setAsDefault(): SaveOptions;
+}
+
+class ValidationError {
+    context: any;
+    errorMessage: string;
+    property: any; // DataProperty | NavigationProperty
+    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;
+    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;
+}
+
+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
diff --git a/README.md b/README.md
index 4d27c254d..ee8e66070 100644
--- a/README.md
+++ b/README.md
@@ -1,65 +1,54 @@
-DefinitelyTyped
-===============
-
-TypeScript type definitions repository for popular JavaScript libraries.
-
-The project aims to provide *high quality* definitions for the most popular libraries out there.
-
-Complete
---------
-* [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes))
-* [async](https://github.com/caolan/async)
-* [Backbone.js](http://backbonejs.org/)
-* [Bootstrap](http://twitter.github.com/bootstrap/)
-* [CodeMirror](http://codemirror.net) (by [Franois de Campredon](https://github.com/fdecampredon))
-* [Chosen](http://harvesthq.github.com/chosen/)
-* [dynatree](http://code.google.com/p/dynatree/) (by [Franois de Campredon](https://github.com/fdecampredon))
-* [EaselJS](http://www.createjs.com/#!/EaselJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
-* [ember.js](http://emberjs.com/)
-* [Express](http://expressjs.com/)
-* [Fancybox](http://fancybox.net/)
-* [GoogleMaps](https://developers.google.com/maps/) (by [Esben Nepper](https://github.com/eNepper))
-* [Handlebars](http://handlebarsjs.com/)
-* [History.js](https://github.com/balupton/History.js/)
-* [Humane.js](http://wavded.github.com/humane-js/) (by [John Vrbanac](https://github.com/jmvrbanac))
-* [Impress.js](https://github.com/bartaz/impress.js)
-* [Jasmine](http://pivotal.github.com/jasmine/)
-* [jQuery.Globalize](https://github.com/jquery/globalize)
-* [jQuery](http://jquery.com/) (from TypeScript samples)
-* [jQuery Mobile](http://jquerymobile.com)
-* [jQuery UI](http://jqueryui.com/)
-* [Knockback](http://kmalakoff.github.com/knockback/) (by [Marcel Binot](https://github.com/docgit))
-* [Knockout.js](http://knockoutjs.com/)
-* [Knockout.Mapping](https://github.com/SteveSanderson/knockout.mapping)
-* [linq.js](http://linqjs.codeplex.com/) (by Marcin Najder (https://github.com/marcinnajder))
-* [Modernizr](http://modernizr.com/)
-* [Moment.js](https://github.com/timrwood/moment) (by [Michael Lakerveld](https://github.com/Lakerfield))
-* [Mustache.js](https://github.com/janl/mustache.js)
-* [Node.js](http://nodejs.org/) (from TypeScript samples)
-* [node_redis](https://github.com/mranney/node_redis)
-* [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver)
-* [PhoneGap](http://phonegap.com)
-* [PreloadJS](http://www.createjs.com/#!/PreloadJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
-* [QUnit](http://qunitjs.com/) (by [Diullei Gomes](https://github.com/Diullei))
-* [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall))
-* [Sammy.js](http://sammyjs.org/)
-* [SoundJS](http://www.createjs.com/#!/SoundJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
-* [Spin](http://fgnass.github.com/spin.js/)
-* [Sugar](http://sugarjs.com/) (by Josh Baldwin)(https://github.com/jbaldwin/)
-* [Teechart](http://www.steema.com) (by [Steema]) (http://www.steema.com)
-* [Toastr](https://github.com/CodeSeven/toastr)
-* [TweenJS](http://www.createjs.com/#!/TweenJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
-* [Ubuntu Unity Web API](https://launchpad.net/libunity-webapps) (by [John Vrbanac](https://github.com/jmvrbanac))
-* [Underscore.js](http://underscorejs.org/)
-* [Underscore.js (Typed)](http://underscorejs.org/) (by Josh Baldwin)(https://github.com/jbaldwin/)
-
-Next
-----
-* Facebook SDK
-* jQuery.Validate
-* google.visualization
-* Meteor
-* Isotope
-* Zepto
-* Socket.IO
-* MongoDB 
\ No newline at end of file
+DefinitelyTyped
+===============
+
+TypeScript type definitions repository for popular JavaScript libraries.
+
+The project aims to provide *high quality* definitions for the most popular libraries out there.
+
+Complete
+--------
+* [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes))
+* [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
+* [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Bootstrap](http://twitter.github.com/bootstrap/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Breeze](http://www.breezejs.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon))
+* [Chosen](http://harvesthq.github.com/chosen/) (by [Boris Yankov](https://github.com/borisyankov))
+* [dynatree](http://code.google.com/p/dynatree/) (by [François de Campredon](https://github.com/fdecampredon))
+* [EaselJS](http://www.createjs.com/#!/EaselJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
+* [ember.js](http://emberjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Express](http://expressjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Fancybox](http://fancybox.net/) (by [Boris Yankov](https://github.com/borisyankov))
+* [GoogleMaps](https://developers.google.com/maps/) (by [Esben Nepper](https://github.com/eNepper))
+* [Handlebars](http://handlebarsjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [History.js](https://github.com/balupton/History.js/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Humane.js](http://wavded.github.com/humane-js/) (by [John Vrbanac](https://github.com/jmvrbanac))
+* [Impress.js](https://github.com/bartaz/impress.js) (by [Boris Yankov](https://github.com/borisyankov))
+* [Jasmine](http://pivotal.github.com/jasmine/) (by [Boris Yankov](https://github.com/borisyankov))
+* [jQuery.Globalize](https://github.com/jquery/globalize) (by [Boris Yankov](https://github.com/borisyankov))
+* [jQuery](http://jquery.com/) (from TypeScript samples)
+* [jQuery Mobile](http://jquerymobile.com) (by [Boris Yankov](https://github.com/borisyankov))
+* [jQuery UI](http://jqueryui.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Knockback](http://kmalakoff.github.com/knockback/) (by [Marcel Binot](https://github.com/docgit))
+* [Knockout.js](http://knockoutjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Knockout.Mapping](https://github.com/SteveSanderson/knockout.mapping) (by [Boris Yankov](https://github.com/borisyankov))
+* [linq.js](http://linqjs.codeplex.com/) (by [Marcin Najder](https://github.com/marcinnajder))
+* [Modernizr](http://modernizr.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Moment.js](https://github.com/timrwood/moment) (by [Michael Lakerveld](https://github.com/Lakerfield))
+* [Mustache.js](https://github.com/janl/mustache.js) (by [Boris Yankov](https://github.com/borisyankov))
+* [Node.js](http://nodejs.org/) (from TypeScript samples)
+* [node_redis](https://github.com/mranney/node_redis) (by [Boris Yankov](https://github.com/borisyankov))
+* [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) (by [Boris Yankov](https://github.com/borisyankov))
+* [PhoneGap](http://phonegap.com) (by [Boris Yankov](https://github.com/borisyankov))
+* [PreloadJS](http://www.createjs.com/#!/PreloadJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
+* [QUnit](http://qunitjs.com/) (by [Diullei Gomes](https://github.com/Diullei))
+* [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall))
+* [Sammy.js](http://sammyjs.org/) (by [Boris Yankov](https://github.com/borisyankov))
+* [SoundJS](http://www.createjs.com/#!/SoundJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
+* [Spin](http://fgnass.github.com/spin.js/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Sugar](http://sugarjs.com/) (by [Josh Baldwin](https://github.com/jbaldwin/))
+* [Teechart](http://www.steema.com) (by [Steema](http://www.steema.com))
+* [Toastr](https://github.com/CodeSeven/toastr) (by [Boris Yankov](https://github.com/borisyankov))
+* [TweenJS](http://www.createjs.com/#!/TweenJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
+* [Underscore.js](http://underscorejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Underscore.js (Typed)](http://underscorejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))
\ No newline at end of file
diff --git a/Tests/breeze-tests.ts b/Tests/breeze-tests.ts
new file mode 100644
index 000000000..bf71bb634
--- /dev/null
+++ b/Tests/breeze-tests.ts
@@ -0,0 +1,762 @@
+/// <reference path="../Definitions/breeze-0.65.d.ts" />
+
+function test_dataProperty() {
+    var lastNameProp = new DataProperty({
+        name: "lastName",
+        dataType: DataType.String,
+        isNullable: true,
+        maxLength: 20
+    });
+    var personEntityType: EntityType;
+    personEntityType.addProperty(lastNameProp);
+}
+
+function test_entityAspect() {
+    var order: 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: EntityManager;
+    var employee1: Entity;
+    var empType = em1.metadataStore.getEntityType("Employee");
+    var entityKey = new EntityKey(empType, 1);
+    var empKey = employee1.entityAspect.getKey();
+    var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
+    var empTerrKey = new EntityKey(empTerrType, [1, 77]);
+    var empType = em1.metadataStore.getEntityType("Employee");
+    var empKey1 = new EntityKey(empType, 1);
+    var empKey2 = employee1.entityAspect.getKey();
+    if (empKey1.equals(empKey2)) { }
+    if (EntityKey.equals(empKey1, empKey2)) { }
+}
+
+function test_metadataStore() {
+    var ms = new MetadataStore();
+    var entityManager = new EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        metadataStore: ms
+    });
+    var em1: EntityManager;
+    em1.setProperties({ metadataStore: ms });
+    var metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    var metadataFromStorage = window.localStorage.getItem("metadata");
+    var newMetadataStore = new MetadataStore();
+    newMetadataStore.importMetadata(metadataFromStorage);
+    var ms = new 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 = MetadataStore.importMetadata(metadataFromStorage);
+    var metadataAsString = ms.exportMetadata();
+    window.localStorage.setItem("metadata", metadataAsString);
+    var metadataFromStorage = window.localStorage.getItem("metadata");
+    var newMetadataStore = new 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 EntityManager("api/NorthwindIBModel");
+    var entityManager = new EntityManager({ serviceName: "api/NorthwindIBModel" });
+    var metadataStore = new MetadataStore();
+    var entityManager = new EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        metadataStore: metadataStore
+    });
+    return new QueryOptions({
+        mergeStrategy: null,
+        fetchStrategy: this.fetchStrategy
+    });
+    var queryOptions = new QueryOptions({
+        mergeStrategy: MergeStrategy.OverwriteChanges,
+        fetchStrategy: FetchStrategy.FromServer
+    });
+    var validationOptions = new ValidationOptions({
+        validateOnAttach: true,
+        validateOnSave: true,
+        validateOnQuery: false
+    });
+    var entityManager = new EntityManager({
+        serviceName: "api/NorthwindIBModel",
+        queryOptions: queryOptions,
+        validationOptions: validationOptions
+    });
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var cust1 = custType.createEntity();
+    em1.addEntity(cust1);
+    em1.attachEntity(cust1, EntityState.Added);
+    em1.clear();
+    var em2 = em1.createEmptyCopy();
+    em1.detachEntity(cust1);
+    var serviceName: string;
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders");
+    em.executeQuery(query)
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders");
+    em.executeQuery(query,
+       function (data) {
+           var orders = data.results;
+       },
+       function (err) {
+       });
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders").using(em);
+    query.execute()
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders");
+    var orders = em.executeQueryLocally(query);
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders").using(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 EntityManager({
+        serviceName: em1.serviceName,
+        metadataStore: em1.metadataStore
+    });
+    em2.importEntities(bundleFromStorage);
+    var entitiesToExport: Entity[];
+    var bundle = em1.exportEntities(entitiesToExport);
+    em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges });
+    var em1 = new EntityManager("api/NorthwindIBModel");
+    em1.fetchMetadata()
+       .then(function () {
+           var metadataStore = em1.metadataStore;
+       })
+       .fail(function (exception) {
+       });
+    var employeeType = em1.metadataStore.getEntityType("Employee");
+    var employeeKey = new EntityKey(employeeType, 1);
+    var employee = em1.findEntityByKey(employeeKey);
+    var custType = 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 = em1.metadataStore.getEntityType("Customer");
+    var changedCustomers = em1.getChanges(custType);
+    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 customers = em1.getEntities(custType);
+    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 addedCustomersAndOrders = em1.getEntities([custType, orderType], EntityState.Added);
+    if (em1.hasChanges()) { }
+    var custType = em1.metadataStore.getEntityType("Customer");
+    if (em1.hasChanges(custType)) { }
+    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);
+    var bundleFromStorage = window.localStorage.getItem("myEntityManager");
+    var em2 = EntityManager.importEntities(bundleFromStorage);
+    var bundle = em1.exportEntities();
+    var em2 = new EntityManager({
+        serviceName: em1.serviceName,
+        metadataStore: em1.metadataStore
+    });
+    em2.importEntities(bundle);
+    var bundle = em1.exportEntities();
+    em2.importEntities(bundle, { mergeStrategy: MergeStrategy.PreserveChanges });
+    em.saveChanges().then(function (saveResult) {
+        var savedEntities = saveResult.entities;
+        var keyMappings = saveResult.keyMappings;
+    }).fail(function (e) {
+    });
+    var saveOptions = new SaveOptions({ allowConcurrentSaves: true });
+    var entitiesToSave: 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 EntityManager({ serviceName: "api/NorthwindIBModel" });
+    em.entityChanged.subscribe(function (changeArgs) {
+        var action = changeArgs.entityAction;
+        var entity = changeArgs.entity;
+    });
+    var em = new EntityManager({ serviceName: "api/NorthwindIBModel" });
+    em.hasChanges.subscribe(function (args) {
+        var hasChanges = args.hasChanges;
+        var entityManager = args.entityManager;
+    });
+}
+
+function test_entityQuery() {
+    var query = new EntityQuery("Customers");
+    var query = new EntityQuery("Customers")
+       .where("CompanyName", "startsWith", "C")
+       .orderBy("Region");
+    var serviceName: string;
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders").using(em);
+    query.execute()
+        .then(function (data) { })
+        .fail(function (err) { });
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders").using(em);
+    query.execute(
+       function (data) {
+           var orders = data.results;
+       },
+       function (err) { });
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders");
+    em.executeQuery(query)
+      .then(function (data) {
+          var orders = data.results;
+      }).fail(function (err) {
+      });
+    var query = new EntityQuery("Orders").using(em);
+    var orders = query.executeLocally();
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .expand("Orders");
+    var query = new EntityQuery("Orders")
+        .expand("Customer, Employee");
+    var query = new EntityQuery("Orders")
+        .expand("Customer, OrderDetails, OrderDetails.Product");
+    var query = EntityQuery.from("Customers");
+    var query = new EntityQuery("Customers");
+    var query = new EntityQuery().from("Customers");
+    var customer: Entity;
+    var customers: Entity[];
+    var customersQuery = EntityQuery.fromEntities(customers);
+    var customersQuery = EntityQuery.fromEntities(customers)
+        .where("Region", FilterQueryOp.NotEquals, null);
+    var customerQuery = EntityQuery.fromEntities(customer);
+    var metadataStore: MetadataStore;
+    var empType = metadataStore.getEntityType("Employee");
+    var entityKey = new EntityKey(empType, 1);
+    var query = EntityQuery.fromEntityKey(entityKey);
+    var employee: Entity;
+    var entityKey = employee.entityAspect.getKey();
+    var query = EntityQuery.fromEntityKey(entityKey);
+    var ordersNavProp = employee.entityType.getProperty("Orders");
+    var query = EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+    var query = new EntityQuery("Customers")
+        .orderBy("CompanyName");
+    var query = new EntityQuery("Customers")
+        .orderBy("Region, CompanyName");
+    var query = new EntityQuery("Products")
+        .orderBy("Category.CategoryName");
+    var query = new EntityQuery("Customers")
+        .orderBy("CompanyName desc");
+    var query = new EntityQuery("Customers")
+        .orderBy("Region desc, CompanyName desc");
+    var query = new EntityQuery("Customers")
+        .orderByDesc("CompanyName");
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("CompanyName");
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("Orders");
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C")
+        .select("CompanyName, Orders");
+    var query = new EntityQuery("Orders")
+        .where("Customer.CompanyName", "startsWith", "C")
+        .select("Customer.CompanyName, Customer, OrderDate");
+    var query = new EntityQuery("Customers")
+       .where("CompanyName", "startsWith", "C")
+       .skip(5);
+    var query = new EntityQuery("Customers")
+        .take(5);
+    var query = new EntityQuery("Customers")
+        .top(5);
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders")
+        .using(em);
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders")
+        .using(MergeStrategy.PreserveChanges);
+    var em = new EntityManager(serviceName);
+    var query = new EntityQuery("Orders")
+        .using(FetchStrategy.FromLocalCache);
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", "startsWith", "C");
+    var query = new EntityQuery("Customers")
+        .where("CompanyName", FilterQueryOp.StartsWith, "C");
+    var pred = new Predicate("CompanyName", FilterQueryOp.StartsWith, "C");
+    var query = new EntityQuery("Customers")
+        .where(pred);
+    var pred = Predicate.create("CompanyName", "startswith", "C").and("Region", FilterQueryOp.Equals, null);
+    var query = new EntityQuery("Customers")
+        .where(pred);
+    var query = new EntityQuery("Products")
+        .where("Category.CategoryName", "startswith", "S");
+    var query = new EntityQuery("Customers")
+        .where("toLower(CompanyName)", "startsWith", "c");
+    var query = new EntityQuery("Customers")
+        .where("toUpper(substring(CompanyName, 1, 2))", FilterQueryOp.Equals, "OM");
+}
+
+function test_entityState() {
+    var anEntity: Entity;
+    var es = anEntity.entityAspect.entityState;
+    return es.isAdded();
+    return es === EntityState.Added;
+    var es = anEntity.entityAspect.entityState;
+    return es.isAddedModifiedOrDeleted();
+    return es === EntityState.Added || es === EntityState.Modified || es === EntityState.Deleted;
+    var es = anEntity.entityAspect.entityState;
+    return es.isDeleted();
+    return es === EntityState.Deleted;
+    var es = anEntity.entityAspect.entityState;
+    return es.isDetached();
+    return es === EntityState.Detached;
+    var es = anEntity.entityAspect.entityState;
+    return es.isModified();
+    return es === EntityState.Modified;
+    var es = anEntity.entityAspect.entityState;
+    return es.isUnchanged();
+    return es === EntityState.Unchanged;
+    var es = anEntity.entityAspect.entityState;
+    return es.isUnchangedOrModified();
+    return es === EntityState.Unchanged || es === EntityState.Modified;
+}
+
+function test_entityType() {
+    var myMetadataStore: MetadataStore;
+    var myEntityType: EntityType;
+    var dataProperty1, dataProperty2, navigationProperty1: DataProperty;
+    var em1: EntityManager;
+    var entityManager = new EntityType({
+        metadataStore: myMetadataStore,
+        serviceName: "api/NorthwindIBModel",
+        name: "person",
+        namespace: "myAppNamespace"
+    });
+    myEntityType.addProperty(dataProperty1);
+    myEntityType.addProperty(dataProperty2);
+    myEntityType.addProperty(navigationProperty1);
+    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"));
+    };
+    var countryValidator = new Validator("countryIsUS", valFn,
+        { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" });
+    custType.addValidator(countryValidator, countryProp);
+    countryProp.validators.push(countryValidator);
+    var someEntityLevelValidator: Validator;
+    custType.addValidator(someEntityLevelValidator);
+    custType.validators.push(someEntityLevelValidator);
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var cust1 = custType.createEntity();
+    em1.addEntity(cust1);
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var customerNameDataProp = custType.getDataProperty("CustomerName");
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var customerOrdersNavProp = custType.getDataProperty("Orders");
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var arrayOfProps = custType.getProperties();
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var companyNameProp = custType.getProperty("CompanyName");
+    var orderDetailType = em1.metadataStore.getEntityType("OrderDetail");
+    var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName");
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var arrayOfPropNames = custType.getPropertyNames();
+    var custType = em1.metadataStore.getEntityType("Customer");
+    custType.setProperties({
+        autoGeneratedKeyType: AutoGeneratedKeyType.Identity,
+        defaultResourceName: "CustomersAndIncludedOrders"
+    });
+}
+
+function test_enum() {
+    var prototype = {
+        nextDay: function () {
+            var nextIndex = (this.dayIndex + 1) % 7;
+            return DayOfWeek.getSymbols()[nextIndex];
+        }
+    };
+    var DayOfWeek = new 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 (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 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 Enum;
+    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: EntityManager;
+    var myEntity, person: Entity;
+    var salaryEvent = new BreezeEvent("salaryEvent", person);
+    BreezeEvent.enable("propertyChanged", myEntityManager, false);
+    BreezeEvent.enable("propertyChanged", myEntityManager, true);
+    BreezeEvent.enable("propertyChanged", myEntity.entityAspect, false);
+    BreezeEvent.enable("propertyChanged", myEntity.entityAspect, null);
+    BreezeEvent.enable("validationErrorsChanged", myEntityManager, function (em) {
+        return em.customTag === "blue";
+    });
+    BreezeEvent.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: 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 LocalQueryComparisonOptions({
+        name: "caseSensitive-nonSQL",
+        isCaseSensitive: true,
+        usesSql92CompliantStringComparison: false
+    });
+    lqco.setAsDefault();
+    var ms = new MetadataStore({ localQueryComparisonOptions: lqco });
+    var em = new EntityManager({ metadataStore: ms });
+    var lqco = new LocalQueryComparisonOptions({
+        isCaseSensitive: false,
+        usesSql92CompliantStringComparison: true
+    });
+    lqco.setAsDefault();
+}
+
+function test_namingConventions() {
+    var namingConv = new 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 ms = new MetadataStore({ namingConvention: namingConv });
+    var em = new EntityManager({ metadataStore: ms });
+    var namingConv = new 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 NavigationProperty({
+        name: "homeAddress",
+        entityTypeName: "Address:#myNamespace",
+        isScalar: true,
+        associationName: "address_person",
+        foreignKeyNames: ["homeAddressId"]
+    });
+    var homeAddressIdProp = new DataProperty({
+        name: "homeAddressId",
+        dataType: DataType.Int32
+    });
+    var personEntityType: EntityType;
+    personEntityType.addProperty(homeAddressProp);
+    personEntityType.addProperty(homeAddressIdProp);
+}
+
+function test_predicate() {
+    var p1 = new Predicate("CompanyName", "StartsWith", "B");
+    var query = new EntityQuery("Customers").where(p1);
+    var p2 = new Predicate("Region", FilterQueryOp.Equals, null);
+    var query = new EntityQuery("Customers").where(p2);
+    var dt = new Date(88, 9, 12);
+    var p1 = Predicate.create("OrderDate", "ne", dt);
+    var p2 = Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = Predicate.create("Freight", ">", 100);
+    var newPred = p1.and(p2, p3);
+    var preds = [p2, p3];
+    var newPred = p1.and(preds);
+    var p4 = Predicate.create("ShipCity", "startswith", "F")
+        .and("Size", "gt", 2000);
+    var dt = new Date(88, 9, 12);
+    var p1 = Predicate.create("OrderDate", "ne", dt);
+    var p2 = Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = Predicate.create("Freight", ">", 100);
+    var newPred = Predicate.and(p1, p2, p3);
+    var preds = [p1, p2, p3];
+    var newPred = Predicate.and(preds);
+    var p1 = Predicate.create("Freight", "gt", 100);
+    var predArgs: any[] = ["Freight", "gt", 100];
+    var p1 = Predicate.create(predArgs);
+    var p1 = new Predicate("Freight", "gt", 100);
+    var p1 = new Predicate("CompanyName", "StartsWith", "B");
+    if (Predicate.isPredicate(p1)) { }
+    var p1 = Predicate.create("Freight", "gt", 100);
+    var not_p1 = Predicate.not(p1);
+    var not_p1 = p1.not();
+    var not_p1 = Predicate.create("Freight", "le", 100);
+    var dt = new Date(88, 9, 12);
+    var p1 = Predicate.create("OrderDate", "ne", dt);
+    var p2 = Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = Predicate.create("Freight", ">", 100);
+    var newPred = Predicate.or(p1, p2, p3);
+    var preds = [p1, p2, p3];
+    var newPred = Predicate.or(preds);
+    var dt = new Date(88, 9, 12);
+    var p1 = Predicate.create("OrderDate", "ne", dt);
+    var p2 = Predicate.create("ShipCity", "startsWith", "C");
+    var p3 = Predicate.create("Freight", ">", 100);
+    var newPred = p1.and(p2, p3);
+    var preds = [p2, p3];
+    var newPred = p1.and(preds);
+    var p4 = Predicate.create("ShipCity", "startswith", "F")
+        .or("Size", "gt", 2000);
+}
+
+function test_queryOptions() {
+    var em1: EntityManager;
+    var newQo = new QueryOptions({ mergeStrategy: MergeStrategy.OverwriteChanges });
+    em1.setProperties({ queryOptions: newQo });
+    var newQo = new QueryOptions({ mergeStrategy: MergeStrategy.OverwriteChanges });
+    newQo.setAsDefault();
+    var queryOptions = em1.defaultQueryOptions.using(MergeStrategy.PreserveChanges);
+    var queryOptions = em1.defaultQueryOptions.using(FetchStrategy.FromLocalCache);
+    var queryOptions = em1.defaultQueryOptions.using({ mergeStrategy: OverwriteChanges });
+}
+
+function test_validationOptions() {
+    var newVo = new ValidationOptions({ validateOnSave: false, validateOnAttach: false });
+    var em1: EntityManager;
+    em1.setProperties({ validationOptions: newVo });
+    var validationOptions = new ValidationOptions()
+    var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+    newOptions.setAsDefault();
+    var validationOptions = new ValidationOptions();
+    var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false });
+}
+
+function test_validator() {
+    var valFn = function (v) {
+        if (v == null) return true;
+        return (core.stringStartsWith(v, "US"));
+    };
+    var countryValidator = new Validator("countryIsUS", valFn, {
+        displayName: "Country",
+        messageTemplate: "'%displayName%' must start with 'US'"
+    });
+    var metadataStore: MetadataStore;
+    var custType = metadataStore.getEntityType("Customer");
+    var countryProp = custType.getProperty("Country");
+    prop.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 Validator("zipCodeValidator", valFn,
+        { messageTemplate: "For the US, this is not a valid PostalCode" });
+    var em1: EntityManager;
+    var custType = 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 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 = em1.metadataStore.getEntityType("Product");
+    var discontinuedProperty = productType.getProperty("Discontinued");
+    discontinuedProperty.validators.push(Validator.bool());
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    regionProperty.validators.push(Validator.byte());
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var orderDateProperty = orderType.getProperty("OrderDate");
+    orderDateProperty.validators.push(Validator.date());
+    var v0 = Validator.maxLength({ maxLength: 5, displayName: "City" });
+    v0.validate("adasdfasdf");
+    var errMessage = v0.getMessage();
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var customerIdProperty = custType.getProperty("CustomerID");
+    customerIdProperty.validators.push(Validator.guid());
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(Validator.int16());
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(Validator.int32());
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(Validator.int64());
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(Validator.maxLength({ maxLength: 5 }));
+    var orderType = em1.metadataStore.getEntityType("Order");
+    var freightProperty = orderType.getProperty("Freight");
+    freightProperty.validators.push(Validator.number());
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(Validator.required());
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(Validator.string());
+    var custType = em1.metadataStore.getEntityType("Customer");
+    var regionProperty = custType.getProperty("Region");
+    regionProperty.validators.push(Validator.stringLength({ minLength: 2, maxLength: 5 }));
+    var validator = Validator.maxLength({ maxLength: 5, displayName: "City" });
+    var result = validator.validate("asdf");
+    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 (core.stringStartsWith(v, "US"));
+    };
+    var countryValidator = new Validator("countryIsUS", valFn, { displayName: "Country" });
+    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 entityModel.EntityManager('api/northwind');
+
+    var query = new entityModel.EntityQuery()
+        .from("Employees");
+
+    manager.executeQuery(query).then(function (data) { });
+}
\ No newline at end of file