diff --git a/ydn-db/ydn-db-tests.ts b/ydn-db/ydn-db-tests.ts
new file mode 100644
index 000000000..95279b831
--- /dev/null
+++ b/ydn-db/ydn-db-tests.ts
@@ -0,0 +1,82 @@
+/// <reference path="ydn-db.d.ts" />
+
+var schema = {
+  stores: [{
+    name: 'todo',
+    keyPath: "timeStamp"
+  }]
+};
+
+
+/**
+ * Create and initialize the database. Depending on platform, this will
+ * create IndexedDB or WebSql or even localStorage storage mechanism.
+ * @type {ydn.db.Storage}
+ */
+var db = new ydn.db.Storage('todo_2', schema);
+
+var deleteTodo = function(id: any) {
+  db.remove('todo', id).fail(function(e) {
+    console.error(e);
+  });
+
+  getAllTodoItems();
+};
+
+var getAllTodoItems = function() {
+  var todos = document.getElementById("todoItems");
+  todos.innerHTML = "";
+
+  var df = db.values('todo');
+
+  df.done(function(items) {
+    var n = items.length;
+    for (var i = 0; i < n; i++) {
+      renderTodo(items[i]);
+    }
+  });
+
+  df.fail(function(e) {
+    console.error(e);
+  })
+};
+
+var renderTodo = function(row: any) {
+  var todos = document.getElementById("todoItems");
+  var li = document.createElement("li");
+  var a = document.createElement("a");
+  var t = document.createTextNode(row.text);
+
+  a.addEventListener("click", function() {
+    deleteTodo(row.timeStamp);
+  }, false);
+
+  a.textContent = " [Delete]";
+  li.appendChild(t);
+  li.appendChild(a);
+  todos.appendChild(li)
+};
+
+var addTodo = function() {
+  var todo = <HTMLInputElement>document.getElementById("todo");
+
+  var data = {
+    "text": todo.value,
+    "timeStamp": new Date().getTime()
+  };
+  db.put('todo', data).fail(function(e) {
+    console.error(e);
+  });
+
+  todo.value = "";
+
+  getAllTodoItems();
+};
+
+function init() {
+  getAllTodoItems();
+}
+
+db.onReady(function() {
+  init();
+});
diff --git a/ydn-db/ydn-db.d.ts b/ydn-db/ydn-db.d.ts
new file mode 100644
index 000000000..564c8ad4c
--- /dev/null
+++ b/ydn-db/ydn-db.d.ts
@@ -0,0 +1,306 @@
+// Type definitions for YDN-DB version 1
+// Project: http://dev.yathit.com/ydn-db/index.html
+// Definitions by: Kyaw Tun <https://github.com/yathit>, Gabriel Monteagudo <https://github.com/gabrielmaldi>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface FullTextSource {
+  storeName: string;
+  keyPath: string;
+  weight?: number;
+}
+
+interface FullTextCatalog {
+  name: string;
+  lang: string;
+  sources: FullTextSource[];
+}
+
+interface IndexSchemaJson {
+  name?: string;
+  keyPath: string|string[];
+  type?: string;
+  unique?: boolean;
+  multiEntry?: boolean;
+}
+
+interface StoreSchemaJson {
+  autoIncrement?: boolean;
+  dispatchEvents?: boolean;
+  name?: string;
+  indexes?: IndexSchemaJson[];
+  keyPath?: string;
+  type?: string;
+}
+
+interface DatabaseSchemaJson {
+  version?: number;
+  stores: StoreSchemaJson[];
+  fullTextCatalogs?: FullTextCatalog;
+}
+
+interface StorageOptions {
+  mechanisms?: string[];
+  size?: number;
+  autoSchema?: boolean;
+  isSerial?: boolean;
+  requestType?: string;
+}
+
+declare module ydn.db {
+  export class Request {
+    abort(): any;
+    always(callback: (data: any) => void): any;
+    done(callback: (data: any) => void): any;
+    fail(callback: (data: any) => void): any;
+    then(success_callback: (data: any) => any, error_callback: (data: Error) => any): any;
+    canAbort(): boolean;
+  }
+
+  export function cmp(first: any, second: any): number;
+
+  export function deleteDatabase(db_name: string, type?: string): void;
+
+  export class Key {
+    constructor(json: Object);
+    constructor(key_string: string);
+    constructor(store_name: string, id: any, parent_key?: Key);
+  }
+
+  export class Iterator {
+    join(peer_store_name: string, peer_field_name?: string, value?: any): any;
+    getKey(): any;
+    getPrimaryKey(): any;
+    reset(): Iterator;
+    restrict(peer_field_name: string, value: any): any;
+    resume(key: any, index_key: any): Iterator;
+    reverse(key: any, index_key: any): Iterator;
+  }
+
+  enum EventType {
+    created,
+    deleted,
+    error,
+    fail,
+    ready,
+    updated
+  }
+
+  enum Policy {
+    all,
+    atomic,
+    multi,
+    repeat,
+    single
+  }
+
+  enum TransactionMode {
+    readonly,
+    readwrite
+  }
+
+  enum Op {
+        ">", "<", "=", ">=", "<=", "^"
+  }
+
+  export class IndexKeyIterator extends Iterator {
+    constructor(store_name: string, index_name: string, key_range?: any, reverse?: boolean);
+
+    static where(store_name: string, index_name: string, op: Op, value: any, op2: Op, value2: any): any;
+
+  }
+
+  export class KeyIterator extends Iterator {
+    constructor(store_name: string, key_range?: any, reverse?: boolean);
+
+    static where(store_name: string, op: Op, value: any, op2: Op, value2: any): any;
+
+  }
+
+  export class ValueIterator extends Iterator {
+    constructor(store_name: string, key_range?: any, reverse?: boolean);
+
+    static where(store_name: string, op: Op, value: any, op2: Op, value2: any): any;
+
+  }
+
+  export class IndexValueIterator extends Iterator {
+    constructor(store_name: string, index_name: string, key_range?: any, reverse?: boolean);
+
+    static where(store_name: string, index_name: string, op: Op, value: any, op2: Op, value2: any): any;
+
+  }
+
+  export class Streamer {
+    constructor(storage: ydn.db.Storage, store_name: string, opt_field_name?: string);
+
+    push(key: any, value?: any): any;
+
+    collect(callback: (values: any[]) => void): any;
+
+    setSink(callback: (key: any, value: any, toWait: () => boolean) => void): any;
+  }
+
+  export class ICursor {
+    getKey(i?: number): any;
+    getPrimaryKey(i?: number): any;
+    getValue(i?: number): any;
+    clear(i?: number): Request;
+    update(value: Object, i?: number): Request;
+  }
+
+  export class Query {
+    count(): Request;
+    open(callback: (ICursor: any) => void, Iterator: any, TransactionMode: any): Request;
+    patch(Object: any): Request;
+    patch(field_name: string, value: any): Request;
+    patch(field_names: string[], value: any[]): Request;
+    order(field_name: string): Query;
+    order(field_name: string, descending: boolean): Query;
+    order(field_names: string[]): Query;
+    order(field_names: string[], descending: boolean): Query;
+    reverse(): Query;
+    list(): Request;
+    list(limit: number): Request;
+    where(field_name: string, op: Op, value: any): any;
+    where(field_name: string, op: Op, value: any, op2: Op, value2: any): any;
+  }
+
+  export class DbOperator {
+
+    add(store_name: string, value: any, key: any): Request;
+    add(store_name: string, value: any): Request;
+
+    clear(store_name: string, key_or_key_range: any): Request;
+    clear(store_name: string): Request;
+    clear(store_names: string[]): Request;
+
+    count(store_name: string, key_range?: any): Request;
+    count(store_name: string, index_name: string, key_range: any): Request;
+    count(store_names: string[]): Request;
+
+    executeSql(sql: string, params?: any[]): Request;
+
+    from(store_name: string): Query;
+    from(store_name: string, op: Op, value: any): Query;
+    from(store_name: string, op: Op, value: any, op2: Op, value2: any): Query;
+
+    get(store_name: string, key: any): Request;
+
+    keys(iter: Iterator, limit?: number): Request;
+    keys(store_name: string, key_range?: Object, limit?: number, offset?: number, reverse?: boolean): Request;
+    keys(store_name: string, index_name: string, key_range?: Object, limit?: number, offset?: number, reverse?: boolean): Request;
+    keys(store_name: string, limit?: boolean, offset?: number): Request;
+
+    open(next_callback: (cursor: ICursor) => any, iterator: Iterator, mode: TransactionMode): Request;
+
+    put(store_name: string, value: any, key: any): Request;
+    put(store_name: string, value: any[], key: any[]): Request;
+    put(store_name: string, value: any): Request;
+    put(store_name: string, value: any[]): Request;
+
+    remove(store_name: string, id_or_key_range: any): Request;
+    remove(store_name: string, index_name: string, id_or_key_range: any): Request;
+    clear(store_name: string, key_or_key_range: any): Request;
+
+    scan(solver: (keys: any[], values: any[]) => any, iterators: Iterator[]): Request;
+
+    values(iter: Iterator, limit?: number): Request;
+    values(store_name: string, key_range?: Object, limit?: number, offset?: number, reverse?: boolean): Request;
+    values(store_name: string, index_name: string, key_range?: Object, limit?: number, offset?: number, reverse?: boolean): Request;
+    values(store_name: string, ids?: Array<any>): Request;
+    values(keys?: Array<any>): Request;
+  }
+
+  export class Storage extends DbOperator {
+
+    constructor(db_name?: string, schema?: DatabaseSchemaJson, options?: StorageOptions);
+
+    addEventListener(type: EventType, handler: (event: any) => void, capture?: boolean): any;
+    addEventListener(type: EventType[], handler: (event: any) => void, capture?: boolean): any;
+
+    branch(thread: Policy, isSerial: boolean, scope: string[], mode: TransactionMode, maxRequest: number): DbOperator;
+
+    close(): any;
+
+    get(store_name: string, key: any): Request;
+
+    getName(callback: any): string;
+
+    getSchema(callback: any): DatabaseSchemaJson;
+
+    getType(): string;
+
+    onReady(Error?: any): any;
+
+    removeEventListener(type: EventType, handler: (event: any) => void, capture?: boolean): any;
+    removeEventListener(type: EventType[], handler: (event: any) => void, capture?: boolean): any;
+
+    run(callback: (iStorage: ydn.db.Storage) => void, store_names: string[], mode: TransactionMode): Request;
+
+    search(catalog_name: string): Request;
+
+    setName(name: string): any;
+
+    transaction(callback: (tx: any) => void, store_names: string[], mode: TransactionMode, completed_handler: (type: string, e?: Error) => void): any;
+
+  }
+}
+
+declare module ydb.db.algo {
+
+  export class Solver {
+
+  }
+
+  export class NestedLoop extends Solver {
+    constructor(out: { push: (value: any) => void }, limit?: number);
+  }
+
+  export class SortedMerge extends Solver {
+    constructor(out: { push: (value: any) => void }, limit?: number);
+  }
+
+  export class ZigzagMerge extends Solver {
+    constructor(out: { push: (value: any) => void }, limit?: number);
+  }
+
+}
+
+declare module ydn.db.events {
+
+  export class Event {
+
+    name: string;
+
+    type: ydn.db.EventType;
+  }
+
+  export class RecordEvent extends Event {
+
+    getStoreName(): string;
+
+    getKey(): any;
+
+    getValue(): any;
+  }
+
+
+  export class StorageEvent extends Event {
+
+    getError(): Error;
+
+    getVersion(): number;
+
+    getOldVersion(): number;
+  }
+
+
+  export class StoreEvent extends Event {
+
+    getStoreName(): string;
+
+    getKeys(): any[];
+
+    getValues(): any[];
+  }
+}