diff --git a/lovefield/lovefield-tests.ts b/lovefield/lovefield-tests.ts
new file mode 100644
index 0000000000..aa77f5b2c1
--- /dev/null
+++ b/lovefield/lovefield-tests.ts
@@ -0,0 +1,49 @@
+/// <reference path="./lovefield.d.ts"/>
+
+function main(): void {
+  var schemaBuilder: lf.schema.Builder = lf.schema.create('todo', 1);
+
+  schemaBuilder.createTable('Item').
+      addColumn('id', lf.Type.INTEGER).
+      addColumn('description', lf.Type.STRING).
+      addColumn('deadline', lf.Type.DATE_TIME).
+      addColumn('done', lf.Type.BOOLEAN).
+      addPrimaryKey(['id']).
+      addIndex('idxDeadline', ['deadline'], false, lf.Order.DESC);
+
+  var todoDb: lf.Database = null;
+  var itemSchema: lf.schema.Table = null;
+  var connectOptions: lf.schema.ConnectOptions = {
+    storeType: lf.schema.DataStoreType.MEMORY
+  }
+  schemaBuilder.connect(connectOptions).then(
+      function(db) {
+        todoDb = db;
+        itemSchema = db.getSchema().table('Item');
+        var row = itemSchema.createRow({
+          'id': 1,
+          'description': 'Get a cup of coffee',
+          'deadline': new Date(),
+          'done': false
+        });
+
+        return db.insertOrReplace().into(itemSchema).values([row]).exec();
+      }).then(
+      function() {
+        var column: lf.schema.Column = (<any>itemSchema).done;
+        return todoDb.select().from(itemSchema).where(column.eq(false)).exec();
+      }).then(
+      function(results) {
+        results.forEach(function(row) {
+          document.body.textContent =
+              (<any>row).description + ' before ' + (<any>row).deadline;
+        });
+
+        return todoDb.delete().from(itemSchema);
+      }).then(
+      function() {
+        return todoDb.select(lf.fn.count()).from(itemSchema).exec();
+      });
+}
+
+main();
diff --git a/lovefield/lovefield.d.ts b/lovefield/lovefield.d.ts
new file mode 100644
index 0000000000..b692a414fa
--- /dev/null
+++ b/lovefield/lovefield.d.ts
@@ -0,0 +1,214 @@
+// Type definitions for Lovefield v2.0.56
+// Project: http://google.github.io/lovefield/
+// Definitions by: freshp86 <https://github.com/freshp86>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../es6-promise/es6-promise.d.ts"/>
+
+declare module lf {
+  export enum Order { ASC, DESC }
+
+  export enum Type {
+    ARRAY_BUFFER,
+    BOOLEAN,
+    DATE_TIME,
+    INTEGER,
+    NUMBER,
+    OBJECT,
+    STRING
+  }
+
+  export interface Binder {
+    getIndex(): number
+  }
+
+  export interface Predicate {}
+  export interface Row {}
+  type ValueLiteral = string|number|boolean|Date;
+
+  export interface PredicateProvider {
+    eq(operand: ValueLiteral|schema.Column|Binder): Predicate
+    neq(operand: ValueLiteral|schema.Column|Binder): Predicate
+    lt(operand: ValueLiteral|schema.Column|Binder): Predicate
+    lte(operand: ValueLiteral|schema.Column|Binder): Predicate
+    gt(operand: ValueLiteral|schema.Column|Binder): Predicate
+    gte(operand: ValueLiteral|schema.Column|Binder): Predicate
+    match(operand: RegExp|Binder): Predicate
+    between(from: ValueLiteral|Binder, to: ValueLiteral|Binder): Predicate
+    in(values: Binder|Array<ValueLiteral>): Predicate
+    isNull(): Predicate
+    isNotNull(): Predicate
+  }
+
+  function bind(index: number): Binder;
+
+  export interface Transaction {
+    attach(query: query.Builder): Promise<Array<Object>>
+    begin(scope: Array<schema.Table>): Promise<void>
+    commit(): Promise<void>
+    exec(queries: Array<query.Builder>): Promise<Array<Array<Object>>>
+    rollback(): Promise<void>
+  }
+
+  export enum TransactionType { READ_ONLY, READ_WRITE }
+
+  export interface Database {
+    close(): void
+    createTransaction(type?: TransactionType): Transaction
+    delete(): query.Delete
+    getSchema(): schema.Database
+    insertOrReplace(): query.Insert
+    insert(): query.Insert
+    observe(query: query.Select, callback: Function): void
+    select(...columns: schema.Column[]): query.Select
+    unobserve(query: query.Select, callback: Function): void
+    update(table: schema.Table): query.Update
+  }
+
+  module query {
+    export interface Builder {
+      bind(...values: any[]): Builder
+      exec(): Promise<Array<Object>>
+      explain(): string
+      toSql(): string
+    }
+
+    export interface Delete extends Builder {
+      from(table: schema.Table): Delete
+      where(predicate: Predicate): Delete
+    }
+
+    export interface Insert extends Builder {
+      into(table: schema.Table): Insert
+      values(rows: Array<Row>|Binder|Array<Binder>): Insert
+    }
+
+    export interface Select extends Builder {
+      from(...tables: schema.Table[]): Select
+      groupBy(...columns: schema.Column[]): Select
+      innerJoin(table: schema.Table, predicate: Predicate): Select
+      leftOuterJoin(table: schema.Table, predicate: Predicate): Select
+      limit(numberOfRows: Binder|number): Select
+      orderBy(column: schema.Column, order?: Order): Select
+      skip(numberOfRows: Binder|number): Select
+      where(predicate: Predicate): Select
+    }
+
+    export interface Update extends Builder {
+      set(column: schema.Column, value: any): Update
+      where(predicate: Predicate): Update
+    }
+
+  }  // module query
+
+
+  module raw {
+    export interface BackStore {
+      getRawDBInstance(): any
+      getRawTransaction(): any
+      dropTable(tableName: string): Promise<void>
+      addTableColumn(
+          tableName: string, columnName: string,
+          defaultValue: string|boolean|number|Date|ArrayBuffer): Promise<void>
+      dropTableColumn(tableName: string, columnName:string): Promise<void>
+      renameTableColumn(
+          tableName: string, oldColumnName: string,
+          newColumnName:string) : Promise<void>
+      createRow(payload: Object): Row
+      getVersion(): number
+      dump(): Array<Object>
+    }
+  }  // module raw
+
+
+  module schema {
+    export enum DataStoreType {
+      FIREBASE,
+      INDEXED_DB,
+      LOCAL_STORAGE,
+      MEMORY,
+      WEB_SQL
+    }
+
+    export interface DatabasePragma {
+      enableBundledMode: boolean
+    }
+
+    export interface Database {
+      name(): string
+      pragma(): DatabasePragma
+      tables(): Array<schema.Table>
+      table(tableName: string): schema.Table
+      version(): number
+    }
+
+    export interface Column extends PredicateProvider {
+      as(name: string): Column
+      getName(): string
+      getNormalizedName(): string
+    }
+
+    export interface Table {
+      as(name: string): Table
+      createRow(value: Object): Row
+      getName(): string
+    }
+
+    export interface ConnectOptions {
+      onUpgrade?: (rawDb: raw.BackStore) => Promise<void>
+      storeType?: DataStoreType
+      webSqlDbSize?: number
+      // TODO(dpapad): firebase?
+    }
+
+    export interface Builder {
+      connect(options: ConnectOptions): Promise<lf.Database>
+      createTable(tableName: string): TableBuilder
+      getSchema(): Database
+      setPragma(pragma: DatabasePragma): void
+    }
+
+    export interface IndexedColumn {
+      autoIncrement: boolean
+      name: string
+      order: Order
+    }
+
+    export interface TableBuilder {
+      addColumn(name: string, type: lf.Type): TableBuilder
+      addForeignKey(): TableBuilder
+      addIndex(
+          name: string, columns: Array<string>|Array<IndexedColumn>,
+          unique?: boolean, order?: Order): TableBuilder
+      addNullable(columns: Array<Column>): TableBuilder
+      addPrimaryKey(columns: Array<string>|Array<IndexedColumn>): TableBuilder
+      addUnique(name: string, columns: Array<Column>): TableBuilder
+    }
+
+    function create(dbName: string, dbVersion: number): Builder
+  }  // module schema
+
+
+  module op {
+    function and(...args: Predicate[]): Predicate;
+    function not(operand: Predicate): Predicate;
+    function or(...args: Predicate[]): Predicate;
+  }  // module op
+
+
+  module fn {
+    function avg(column: schema.Column): schema.Column
+    function count(column?: schema.Column): schema.Column
+    function distinct(column: schema.Column): schema.Column
+    function geomean(column: schema.Column): schema.Column
+    function max(column: schema.Column): schema.Column
+    function min(column: schema.Column): schema.Column
+    function stddev(column: schema.Column): schema.Column
+    function sum(column: schema.Column): schema.Column
+  }  // module fn
+
+}  // module lf
+
+declare module 'lf' {
+  export = lf;
+}