diff --git a/dexie/dexie-tests.ts b/dexie/dexie-tests.ts
new file mode 100644
index 000000000..89318f070
--- /dev/null
+++ b/dexie/dexie-tests.ts
@@ -0,0 +1,256 @@
+/// <reference path="dexie.d.ts" /> 
+
+import Dexie = require("Dexie");
+
+module Utils {
+
+    export class Console {
+        textarea: HTMLTextAreaElement;
+
+        constructor() {
+            this.textarea = document.createElement('textarea');
+        }
+
+        log(txt: string, type?: string) {
+            if (type) this.textarea.value += type + " ";
+            this.textarea.value += txt + "\n";
+        }
+        error = function (txt: string) {
+            this.log(txt, "ERROR!");
+        }
+    }
+
+}
+
+module AppDb {
+
+    export class AppDatabase extends Dexie {
+
+        contacts: Dexie.Table<Contact, number>;
+        emails: Dexie.Table<IEmailAddress, number>;
+        phones: Dexie.Table<IPhoneNumber, number>;
+
+        constructor() {
+
+            super("MyTypeScriptAppDb");
+
+            var db = this;
+
+            //
+            // Define tables and indexes
+            //
+            db.version(1).stores({
+                contacts: '++id, first, last',
+                emails: '++id, contactId, type, email',
+                phones: '++id, contactId, type, phone',
+            });
+
+            // Let's physically map Contact class to contacts table.
+            // This will make it possible to call loadEmailsAndPhones()
+            // directly on retrieved database objects.
+            db.contacts.mapToClass(Contact);
+        }
+    }
+
+    /* Just for code completion and compilation - defines
+     * the interface of objects stored in the emails table.
+     */
+    export interface IEmailAddress {
+        id?: number;
+        contactId: number;
+        type: string;
+        email: string;
+    }
+
+    /* Just for code completion and compilation - defines
+     * the interface of objects stored in the phones table.
+     */
+    export interface IPhoneNumber {
+        id?: number;
+        contactId: number;
+        type: string;
+        phone: string;
+    }
+
+    /* This is a 'physical' class that is mapped to
+     * the contacts table. We can have methods on it that
+     * we could call on retrieved database objects.
+     */
+    export class Contact {
+        id: number;
+        first: string;
+        last: string;
+        emails: IEmailAddress[];
+        phones: IPhoneNumber[];
+
+        constructor(first: string, last: string, id?: number) {
+            this.first = first;
+            this.last = last;
+            if (id) this.id = id;
+        }
+
+        loadEmailsAndPhones() {
+            return Dexie.Promise.all(
+                db.emails
+                    .where('contactId').equals(this.id)
+                    .toArray(emails => this.emails = emails)
+                ,
+                db.phones
+                    .where('contactId').equals(this.id)
+                    .toArray(phones => this.phones = phones)
+
+                ).then(x => this);
+        }
+
+        save() {
+            return db.transaction('rw', db.contacts, db.emails, db.phones, () => {
+                Dexie.Promise.all(
+                    // Save existing arrays
+                    Dexie.Promise.all(this.emails.map(email => db.emails.put(email))),
+                    Dexie.Promise.all(this.phones.map(phone => db.phones.put(phone))))
+                    .then(results => {
+                        // Remove items from DB that is was not saved here:
+                        var emailIds = results[0], // array of resulting primary keys
+                            phoneIds = results[1]; // array of resulting primary keys
+
+                        db.emails.where('contactId').equals(this.id)
+                            .and(email => emailIds.indexOf(email.id) === -1)
+                            .delete();
+
+                        db.phones.where('contactId').equals(this.id)
+                            .and(phone => phoneIds.indexOf(phone.id) === -1)
+                            .delete();
+
+                        // At last, save our own properties.
+                        // (Must not do put(this) because we would get
+                        // reduntant emails/phones arrays saved into db)
+                        db.contacts.put(
+                            new Contact(this.first, this.last, this.id))
+                            .then(id => this.id = id);
+                    });
+            });
+        }
+    }
+
+    export var db = new AppDatabase();
+    db.open();
+}
+
+
+import Console = Utils.Console;
+import db = AppDb.db;
+
+document.addEventListener('DOMContentLoaded', () => {
+
+    // Initialize our Console widget - it will log browser window.
+    var console = new Console();
+    document.getElementById('consoleArea').appendChild(console.textarea);
+
+    // Test it:
+    console.log("Hello world!");
+
+    // Make sure to never miss any unexpected error:
+    Dexie.Promise.on.error.subscribe(e => {
+        // Log any uncatched error:
+        console.error(e);
+    });
+
+    //
+    // Let's clear and re-seed the database:
+    //
+    clearDatabase()
+        .then(seedDatabase)
+        .then(playALittle_add_phone_to_adam)
+        .then(printContacts);
+
+    function clearDatabase() {
+        console.log("Clearing database...");
+        return Dexie.Promise.all(
+            db.contacts.clear(),
+            db.emails.clear(),
+            db.phones.clear());
+    }
+
+    function seedDatabase() {
+        console.log("Seeding database with some contacts...");
+        return db.transaction('rw', db.contacts, db.emails, db.phones, () => {
+            // Populate a contact
+            db.contacts.add(new AppDb.Contact('Arnold', 'Fitzgerald')).then(id => {
+                // Populate some emails and phone numbers for the contact
+                db.emails.add({ contactId: id, type: 'home', email: 'arnold@email.com' });
+                db.emails.add({ contactId: id, type: 'work', email: 'arnold@abc.com' });
+                db.phones.add({ contactId: id, type: 'home', phone: '12345678' });
+                db.phones.add({ contactId: id, type: 'work', phone: '987654321' });
+            });
+
+            // ... and another one...
+            db.contacts.add(new AppDb.Contact('Adam', 'Tensta')).then(id => {
+                // Populate some emails and phone numbers for the contact
+                db.emails.add({ contactId: id, type: 'home', email: 'adam@tensta.se' });
+                db.phones.add({ contactId: id, type: 'work', phone: '88888888' });
+            });
+        });
+    }
+
+    function playALittle_add_phone_to_adam() {
+        // Now, just to examplify how to use the save() method as an alternative
+        // to db.phones.add(), we will add yet another phone number
+        // to an existing contact and then re-save it:
+        console.log("Playing a little: adding another phone entry for Adam Tensta...");
+        return db.contacts
+            .where('last').equals('Tensta').first(c => c.loadEmailsAndPhones())
+            .then(contact => {
+                // Also add another phone number to Adam Tensta:
+                contact.phones.push({
+                    contactId: contact.id,
+                    type: 'custom',
+                    phone: '112'
+                });
+                contact.save();
+            });
+    }
+
+    function printContacts() {
+
+        // Now we're gonna list all contacts starting with letter 'A'
+        // and print them out.
+        // For each contact, also resolve its collection of
+        // phone number entries and email addresses by reverse-quering
+        // the foreign tables.
+
+        // For atomicity and speed, use a single transaction for the
+        // queries to make:
+        db.transaction('r', [db.contacts, db.phones, db.emails], () => {
+
+            // Query some contacts
+            return db.contacts
+                .where('first').startsWithIgnoreCase('a')
+                .sortBy('id')
+                .then(contacts =>
+
+                    // Resolve array properties 'emails' and 'phones'
+                    // on each and every contact:
+                    Dexie.Promise.all(
+                        contacts.map(contact =>
+                            contact.loadEmailsAndPhones()))
+                );
+
+        }).then(contacts => {
+
+                // Print result
+                console.log("Database contains the following contacts:");
+                contacts.forEach(contact => {
+                    console.log(contact.id + ". " + contact.first + " " + contact.last);
+                    console.log("   Phone numbers: ");
+                    contact.phones.forEach(phone => {
+                        console.log("     " + phone.phone + "(" + phone.type + ")");
+                    });
+                    console.log("   Emails: ");
+                    contact.emails.forEach(email => {
+                        console.log("     " + email.email + "(" + email.type + ")");
+                    });
+                });
+            });
+    }
+});
+
diff --git a/dexie/dexie.d.ts b/dexie/dexie.d.ts
new file mode 100644
index 000000000..7d498f4d3
--- /dev/null
+++ b/dexie/dexie.d.ts
@@ -0,0 +1,316 @@
+
+interface Thenable<R> {
+    then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
+    then<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable<U>;
+}
+
+declare class Dexie {
+    constructor(databaseName: string);
+
+    constructor(databaseName: string, options: { addons: Array<(db: Dexie) => void> });
+
+    name: string;
+    tables: Dexie.Table<any, any>[];
+    verno: number;
+
+    static addons: Array<(db: Dexie) => void>;
+    static version: number;
+
+    static getDatabaseNames(): Dexie.Promise<Array<string>>;
+
+    static getDatabaseNames<U>(onFulfilled: (value: Array<string>) => Thenable<U>): Dexie.Promise<U>;
+
+    static getDatabaseNames<U>(onFulfilled: (value: Array<string>) => U): Dexie.Promise<U>;
+
+    static getByKeyPath(obj: Object, keyPath: string): any;
+
+    static setByKeyPath(obj: Object, keyPath: string, value: any): void;
+
+    static delByKeyPath(obj: Object, keyPath: string): void;
+
+    static shallowClone(obj: Object): Object;
+
+    static deepClone(obj: Object): Object;
+
+    version(versionNumber: Number): Dexie.Version
+
+    on: {
+        (eventName: string, subscriber: () => any): void;
+        (eventName: string, subscriber: () => any, bSticky: boolean): void;
+        ready: Dexie.DexieOnReadyEvent;
+        error: Dexie.DexieErrorEvent;
+        populate: Dexie.DexieEvent;
+        blocked: Dexie.DexieEvent;
+        versionchange: Dexie.DexieVersionChangeEvent;
+    }
+
+    open(): Dexie.Promise<void>;
+
+    table(tableName: string): Dexie.Table<any, any>;
+
+    table<T>(tableName: string): Dexie.Table<T, any>;
+
+    table<T, Key>(tableName: string): Dexie.Table<T, Key>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, scope: () => Thenable<U>): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, table2: Dexie.Table<any, any>, scope: () => Thenable<U>): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, table2: Dexie.Table<any, any>, table3: Dexie.Table<any, any>, scope: () => Thenable<U>): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, tables: Dexie.Table<any, any>[], scope: () => Thenable<U>): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, scope: () => U): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, table2: Dexie.Table<any, any>, scope: () => U): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, table: Dexie.Table<any, any>, table2: Dexie.Table<any, any>, table3: Dexie.Table<any, any>, scope: () => U): Dexie.Promise<U>;
+
+    transaction<U>(mode: string, tables: Dexie.Table<any, any>[], scope: () => U): Dexie.Promise<U>;
+
+    close(): void;
+
+    delete(): Dexie.Promise<void>;
+
+    isOpen(): boolean;
+
+    hasFailed(): boolean;
+
+    backendDB(): IDBDatabase;
+
+    vip<U>(scopeFunction: () => U): U;
+}
+
+declare module Dexie {
+
+    class Promise<R> implements Thenable<R> {
+        constructor(callback: (resolve: (value?: Thenable<R>) => void, reject: (error?: any) => void) => void);
+
+        constructor(callback: (resolve: (value?: R) => void, reject: (error?: any) => void) => void);
+
+        then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Promise<U>;
+
+        then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Promise<U>;
+
+        then<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable<U>): Promise<U>;
+
+        then<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Promise<U>;
+
+        catch<U>(onRejected: (error: any) => Promise<U>): Promise<U>;
+
+        catch<U>(ExceptionType: Function, onRejected: (error : any) => Promise<U>): Promise<U>;
+
+        catch<U>(errorName: string, onRejected: (error : any) => Promise<U>): Promise<U>;
+
+        finally<R>(onFinally: () => any): Promise<R>;
+
+        onuncatched: () => any;
+    }
+
+    module Promise {
+        function resolve<R>(value?: Thenable<R>): Promise<R>;
+
+        function resolve<R>(value?: R): Promise<R>;
+
+        function reject(error: any): Promise<any>;
+
+        function all<R>(promises: Thenable<R>[]): Promise<R[]>;
+
+        function all<R>(...promises: Thenable<R>[]): Promise<R[]>;
+
+        function race<R>(promises: Thenable<R>[]): Promise<R>;
+
+        function newPSD<R>(scope: () => R): R;
+
+        var PSD: any;
+
+        var on: {
+            (eventName: string, subscriber: (...args : any[]) => any): void;
+            error: DexieErrorEvent;
+        }
+    }
+
+
+    interface Version {
+        stores(schema: { [key: string]: string }): Version;
+        upgrade(fn: (trans: Transaction) => void): Version;
+    }
+
+    interface Transaction {
+        active: boolean;
+        db: Dexie;
+        mode: string;
+        idbtrans: IDBTransaction;
+        tables: { [type: string]: Table<any, any> };
+        storeNames: Array<string>;
+        on: {
+            (eventName: string, subscriber: () => any): void;
+            complete: DexieEvent;
+            abort: DexieEvent;
+            error: DexieEvent;
+        }
+        abort(): void;
+        table(tableName: string): Table<any, any>;
+        table<T>(tableName: string): Table<T, any>;
+        table<T, Key>(tableName: string): Table<T, Key>;
+    }
+
+    interface DexieEvent {
+        subscribe(fn: () => any) : void;
+        unsubscribe(fn: () => any) : void;
+        fire() : any;
+    }
+
+    interface DexieErrorEvent {
+        subscribe(fn: (error: any) => any) : void;
+        unsubscribe(fn: (error: any) => any) : void;
+        fire(error: any) : any;
+    }
+
+    interface DexieVersionChangeEvent {
+        subscribe(fn: (event: IDBVersionChangeEvent) => any) : void;
+        unsubscribe(fn: (event: IDBVersionChangeEvent) => any) : void;
+        fire(event: IDBVersionChangeEvent) : any;
+    }
+
+    interface DexieOnReadyEvent
+    {
+        subscribe(fn: () => any, bSticky: boolean) : void;
+        unsubscribe(fn: () => any) : void;
+        fire() : any;
+    }
+
+    interface Table<T, Key> {
+        name: string;
+        schema: TableSchema;
+        hook: {
+            (eventName: string, subscriber: () => any): void;
+            creating: DexieEvent;
+            reading: DexieEvent;
+            updating: DexieEvent;
+            deleting: DexieEvent;
+        }
+
+        get(key: Key): Promise<T>;
+        where(index: string): WhereClause<T, Key>;
+
+        filter(fn: (obj: T) => boolean): Collection<T, Key>;
+
+        count(): Promise<number>;
+        count<U>(onFulfilled: (value: number) => Thenable<U>): Promise<U>;
+        count<U>(onFulfilled: (value: number) => U): Promise<U>;
+
+        offset(n: number): Collection<T, Key>;
+
+        limit(n: number): Collection<T, Key>;
+
+        each(callback: (obj: T, cursor: IDBCursor) => any): Promise<void>;
+
+        toArray(): Promise<Array<T>>;
+        toArray<U>(onFulfilled: (value: Array<T>) => Thenable<U>): Promise<U>;
+        toArray<U>(onFulfilled: (value: Array<T>) => U): Promise<U>;
+
+        toCollection(): Collection<T, Key>;
+        orderBy(index: string): Collection<T, Key>;
+        reverse(): Collection<T, Key>;
+        mapToClass(constructor: Function): Function;
+        add(item: T, key?: Key): Promise<Key>;
+        update(key: Key, changes: { [keyPath: string]: any }) : Promise<number>;
+        put(item: T, key?: Key): Promise<Key>;
+        delete(key: Key): Promise<void>;
+        clear(): Promise<void>;
+    }
+
+    interface WhereClause<T, Key> {
+        above(key: number): Collection<T, Key>;
+        above(key: string): Collection<T, Key>;
+        above(key: Date): Collection<T, Key>;
+        above(key: Array<any>): Collection<T, Key>;
+        aboveOrEqual(key: number): Collection<T, Key>;
+        aboveOrEqual(key: string): Collection<T, Key>;
+        aboveOrEqual(key: Date): Collection<T, Key>;
+        aboveOrEqual(key: Array<any>): Collection<T, Key>;
+        anyOf(keys: Array<any>): Collection<T, Key>;
+        anyOf(...keys: any[]): Collection<T, Key>;
+        below(key: number): Collection<T, Key>;
+        below(key: string): Collection<T, Key>;
+        below(key: Date): Collection<T, Key>;
+        below(key: Array<any>): Collection<T, Key>;
+        belowOrEqual(key: number): Collection<T, Key>;
+        belowOrEqual(key: string): Collection<T, Key>;
+        belowOrEqual(key: Date): Collection<T, Key>;
+        belowOrEqual(key: Array<any>): Collection<T, Key>;
+        between(lower: number, upper: number, includeLower?: boolean, includeUpper?: boolean): Collection<T, Key>;
+        between(lower: string, upper: string, includeLower?: boolean, includeUpper?: boolean): Collection<T, Key>;
+        between(lower: Date, upper: Date, includeLower?: boolean, includeUpper?: boolean): Collection<T, Key>;
+        between(lower: Array<any>, upper: Array<any>, includeLower?: boolean, includeUpper?: boolean): Collection<T, Key>;
+        equals(key: number): Collection<T, Key>;
+        equals(key: string): Collection<T, Key>;
+        equals(key: Date): Collection<T, Key>;
+        equals(key: Array<any>): Collection<T, Key>;
+        equalsIgnoreCase(key: string): Collection<T, Key>;
+        startsWith(key: string): Collection<T, Key>;
+        startsWithIgnoreCase(key: string): Collection<T, Key>;
+    }
+
+    interface Collection<T, Key> {
+        and(filter: (x: T) => boolean): Collection<T, Key>;
+        count(): Promise<number>;
+        count<U>(onFulfilled: (value: number) => Thenable<U>): Promise<U>;
+        count<U>(onFulfilled: (value: number) => U): Promise<U>;
+        distinct(): Collection<T, Key>;
+        each(callback: (obj: T, cursor: IDBCursor) => any): Promise<void>;
+        eachKey(callback: (key: Key, cursor: IDBCursor) => any): Promise<void>;
+        eachUniqueKey(callback: (key: Key, cursor: IDBCursor) => any): Promise<void>;
+        first(): Promise<T>;
+        first<U>(onFulfilled: (value: T) => Thenable<U>): Promise<U>;
+        first<U>(onFulfilled: (value: T) => U): Promise<U>;
+        keys(): Promise<Key[]>;
+        keys<U>(onFulfilled: (value: Key[]) => Thenable<U>): Promise<U>;
+        keys<U>(onFulfilled: (value: Key[]) => U): Promise<U>;
+        last(): Promise<T>;
+        last<U>(onFulfilled: (value: T) => Thenable<U>): Promise<U>;
+        last<U>(onFulfilled: (value: T) => U): Promise<U>;
+        limit(n: number): Collection<T, Key>;
+        offset(n: number): Collection<T, Key>;
+        or(indexOrPrimayKey: string): WhereClause<T, Key>;
+        reverse(): Collection<T, Key>;
+        sortBy(keyPath: string): Promise<T[]>;
+        sortBy<U>(keyPath: string, onFulfilled: (value: T[]) => Thenable<U>): Promise<U>;
+        sortBy<U>(keyPath: string, onFulfilled: (value: T[]) => U): Promise<U>;
+        toArray(): Promise<Array<T>>;
+        toArray<U>(onFulfilled: (value: Array<T>) => Thenable<U>): Promise<U>;
+        toArray<U>(onFulfilled: (value: Array<T>) => U): Promise<U>;
+        uniqueKeys(): Promise<Key[]>;
+        uniqueKeys<U>(onFulfilled: (value: Key[]) => Thenable<U>): Promise<U>;
+        uniqueKeys<U>(onFulfilled: (value: Key[]) => U): Promise<U>;
+        until(filter: (value: T) => boolean, includeStopEntry?: boolean): Collection<T, Key>;
+        // WriteableCollection:
+        delete(): Promise<number>;
+        modify(changes: { [keyPath: string]: any }): Promise<number>;
+        modify(changeCallback: (obj: T) => void): Promise<number>;
+    }
+
+    interface TableSchema {
+        name: string;
+        primKey: IndexSpec;
+        indexes: IndexSpec[];
+        mappedClass: Function;
+    }
+
+    interface IndexSpec {
+        name: string;
+        keyPath: any;
+        unique: boolean;
+        multi: boolean;
+        auto: boolean;
+        compound: boolean;
+        src: string;
+    }
+}
+
+declare module 'Dexie' {
+    export = Dexie;
+}