diff --git a/d.ts/anydb-sql.d.ts b/d.ts/anydb-sql.d.ts
index e6e28dc..76bcb34 100644
--- a/d.ts/anydb-sql.d.ts
+++ b/d.ts/anydb-sql.d.ts
@@ -10,21 +10,25 @@ declare module "anydb-sql" {
 
     module anydbSQL {
         export interface OrderByValueNode {}
-        export interface ColumnDefinition {
+
+        interface Named<Name extends string> {
+            name?: Name;
+        }
+        export interface ColumnDefinition<Name extends string, Type> extends Named<Name> {
             primaryKey?:boolean;
             dataType?:string;
             references?: {table:string; column: string}
             notNull?:boolean
             unique?:boolean
+            defaultValue?: Type
         }
 
-        export interface TableDefinition {
-            name:string
-            columns:Dictionary<ColumnDefinition>
-            has?:Dictionary<{from:string; many?:boolean}>
+        export interface TableDefinition<Name extends string, Row> {
+            name: Name
+            columns:{[CName in keyof Row]: ColumnDefinition<CName, Row[CName]>}
+            has?:{[key: string]:{from:string; many?:boolean}}
         }
 
-
         export interface QueryLike {
             query:string;
             values: any[]
@@ -40,25 +44,12 @@ declare module "anydb-sql" {
             commitAsync():Promise<void>
         }
 
-        export interface SubQuery<T> {
-            select(node:Column<T>):SubQuery<T>
-            select(...nodes: any[]):SubQuery<T>
-            where(...nodes:any[]):SubQuery<T>
-            from(table:TableNode):SubQuery<T>
-            from(statement:string):SubQuery<T>
-            group(...nodes:any[]):SubQuery<T>
-            order(criteria:OrderByValueNode):SubQuery<T>
-            exists():BinaryNode
-            notExists(): BinaryNode;
-            notExists(subQuery:SubQuery<any>):BinaryNode
-        }
-
         interface Executable<T> {
             get():Promise<T>
             getWithin(tx:DatabaseConnection):Promise<T>
             exec():Promise<void>
             all():Promise<T[]>
-            execWithin(tx:DatabaseConnection):Promise<void> 
+            execWithin(tx:DatabaseConnection):Promise<void>
             allWithin(tx:DatabaseConnection):Promise<T[]>
             toQuery():QueryLike;
         }
@@ -66,14 +57,31 @@ declare module "anydb-sql" {
         interface Queryable<T> {
             where(...nodes:any[]):Query<T>
             delete():ModifyingQuery
-            select<U>(...nodes:any[]):Query<U>
-            selectDeep<U>(...nodesOrTables:any[]):Query<U>
+            select<N1 extends string, T1>(n1: Column<N1, T1>):Query<T1>
+            select<N1 extends string, T1, N2 extends string, T2>(
+                n1: Column<N1, T1>,
+                n2: Column<N2, T2>):Query<{[N in N1]: T1} & {[N in N2]: T2}>
+            select<N1 extends string, T1, N2 extends string, T2, N3 extends string, T3>(
+                n1: Column<N1, T1>,
+                n2: Column<N2, T2>,
+                n3: Column<N3, T3>):Query<{[N in N1]: T1} & {[N in N2]: T2} & {[N in N3]: T3}>
+            select<U>(...nodesOrTables:any[]):Query<U>
+
+            selectDeep<N1 extends string, T1>(n1: Table<N1, T1>):Query<T1>
+            selectDeep<N1 extends string, T1, N2 extends string, T2>(
+                n1: Table<N1, T1>,
+                n2: Table<N2, T2>):Query<{[N in N1]: T1} & {[N in N2]: T2}>
+            selectDeep<N1 extends string, T1, N2 extends string, T2, N3 extends string, T3>(
+                n1: Table<N1, T1>,
+                n2: Table<N2, T2>,
+                n3: Table<N3, T3>):Query<{[N in N1]: T1} & {[N in N2]: T2} & {[N in N3]: T3}>
+            //selectDeep<U>(...nodesOrTables:any[]):Query<U>
         }
 
         export interface Query<T> extends Executable<T>, Queryable<T> {
             from(table:TableNode):Query<T>
             from(statement:string):Query<T>
-            update(o:Dictionary<any>):ModifyingQuery
+            update(o:{[key: string]:any}):ModifyingQuery
             update(o:{}):ModifyingQuery
             group(...nodes:any[]):Query<T>
             order(...criteria:OrderByValueNode[]):Query<T>
@@ -81,6 +89,20 @@ declare module "anydb-sql" {
             offset(o:number):Query<T>
         }
 
+        export interface SubQuery<T> {
+            select<Name>(node:Column<Name, T>):SubQuery<T>
+            select(...nodes: any[]):SubQuery<T>
+            where(...nodes:any[]):SubQuery<T>
+            from(table:TableNode):SubQuery<T>
+            from(statement:string):SubQuery<T>
+            group(...nodes:any[]):SubQuery<T>
+            order(criteria:OrderByValueNode):SubQuery<T>
+            exists():BinaryNode
+            notExists(): BinaryNode;
+            notExists(subQuery:SubQuery<any>):BinaryNode
+        }
+
+
         export interface ModifyingQuery extends Executable<void> {
             returning<U>(...nodes:any[]):Query<U>
             where(...nodes:any[]):ModifyingQuery
@@ -102,10 +124,15 @@ declare module "anydb-sql" {
         interface DropQuery extends Executable<void> {
             ifExists():Executable<void>
         }
-        export interface Table<T> extends TableNode, Queryable<T> {
+
+        type Columns<T> = {
+            [Name in keyof T]: Column<Name, T[Name]>
+        }
+        type Table<Name extends string, T> = TableNode & Queryable<T> & Named<Name> & Columns<T> & {
+
             create():CreateQuery
             drop():DropQuery
-            as(name:string):Table<T>
+            as<OtherName extends string>(name:OtherName):Table<OtherName, T>
             update(o:any):ModifyingQuery
             insert(row:T):ModifyingQuery
             insert(rows:T[]):ModifyingQuery
@@ -113,21 +140,24 @@ declare module "anydb-sql" {
             select<U>(...nodes:any[]):Query<U>
             from<U>(table:TableNode):Query<U>
             from<U>(statement:string):Query<U>
-            star():Column<any>
+            star():Column<void, void>
             subQuery<U>():SubQuery<U>
             eventEmitter:{emit:(type:string, ...args:any[])=>void
                           on:(eventName:string, handler:Function)=>void}
-            columns:Column<any>[]
+            columns:Column<void, void>[]
             sql: SQL;
             alter():AlterQuery<T>;
             indexes(): IndexQuery;
         }
+
+        type Selectable<Name extends string, T> = Table<Name, T> | Column<Name, T>
+
         export interface AlterQuery<T> extends Executable<void> {
-            addColumn(column:Column<any>): AlterQuery<T>;
+            addColumn(column:Column<any, any>): AlterQuery<T>;
             addColumn(name: string, options:string): AlterQuery<T>;
-            dropColumn(column: Column<any>|string): AlterQuery<T>;
-            renameColumn(column: Column<any>, newColumn: Column<any>):AlterQuery<T>;
-            renameColumn(column: Column<any>, newName: string):AlterQuery<T>;
+            dropColumn(column: Column<any, any>|string): AlterQuery<T>;
+            renameColumn(column: Column<any, any>, newColumn: Column<any, any>):AlterQuery<T>;
+            renameColumn(column: Column<any, any>, newName: string):AlterQuery<T>;
             renameColumn(name: string, newName: string):AlterQuery<T>;
             rename(newName: string): AlterQuery<T>
         }
@@ -135,20 +165,20 @@ declare module "anydb-sql" {
             create(): IndexCreationQuery;
             create(indexName: string): IndexCreationQuery;
             drop(indexName: string): Executable<void>;
-            drop(...columns: Column<any>[]): Executable<void>
+            drop(...columns: Column<any, any>[]): Executable<void>
         }
         export interface IndexCreationQuery extends Executable<void> {
             unique(): IndexCreationQuery;
             using(name: string): IndexCreationQuery;
-            on(...columns: (Column<any>|OrderByValueNode)[]): IndexCreationQuery;
+            on(...columns: (Column<any, any>|OrderByValueNode)[]): IndexCreationQuery;
             withParser(parserName: string): IndexCreationQuery;
             fulltext(): IndexCreationQuery;
             spatial(): IndexCreationQuery;
-        } 
+        }
 
         export interface SQL {
             functions: {
-                LOWER(c:Column<string>):Column<string>
+                LOWER<Name>(c:Column<Name, string>):Column<Name, string>
             }
         }
 
@@ -157,7 +187,8 @@ declare module "anydb-sql" {
             or(node:BinaryNode):BinaryNode
         }
 
-        export interface Column<T> {
+        export interface Column<Name, T> {
+            name: Name
             in(arr:T[]):BinaryNode
             in(subQuery:SubQuery<T>):BinaryNode
             notIn(arr:T[]):BinaryNode
@@ -169,30 +200,30 @@ declare module "anydb-sql" {
             lt(node:any):BinaryNode
             like(str:string):BinaryNode
             multiply:{
-                (node:Column<T>):Column<T>
-                (n:number):Column<number>
+                (node:Column<any, T>):Column<any, T>
+                (n:number):Column<any, number> //todo check column names
             }
             isNull():BinaryNode
             isNotNull():BinaryNode
-            sum():Column<number>
-            count():Column<number>
-            count(name:string):Column<number>
-            distinct():Column<T>
-            as(name:string):Column<T>
+            //todo check column names
+            sum():Column<any, number>
+            count():Column<any, number>
+            count(name:string):Column<any, number>
+            distinct():Column<Name, T>
+            as<OtherName>(name:OtherName):Column<OtherName, T>
             ascending:OrderByValueNode
             descending:OrderByValueNode
             asc:OrderByValueNode
             desc:OrderByValueNode
-            name: string;
         }
 
         export interface AnydbSql extends DatabaseConnection {
-            define<T>(map:TableDefinition):Table<T>;
+            define<Name extends string, T>(map:TableDefinition<Name, T>):Table<Name, T>;
             transaction<T>(fn:(tx:Transaction)=>Promise<T>):Promise<T>
-            allOf(...tables:Table<any>[]):any
-            models:Dictionary<Table<any>>
-            functions:{LOWER:(name:Column<string>)=>Column<string>
-                       RTRIM:(name:Column<string>)=>Column<string>}
+            allOf(...tables:Table<any, any>[]):any
+            models: {[key:string]: Table<any, any>}
+            functions:{LOWER:<Name>(name:Column<Name, string>)=>Column<Name, string>
+                       RTRIM:<Name>(name:Column<Name, string>)=>Column<Name, string>}
             makeFunction(name:string):Function
             begin():Transaction
             open():void;
diff --git a/d.ts/test.ts b/d.ts/test.ts
new file mode 100644
index 0000000..5b3feb7
--- /dev/null
+++ b/d.ts/test.ts
@@ -0,0 +1,49 @@
+import * as dbsql from 'anydb-sql'
+
+let db = dbsql({});
+
+interface User {
+    id: string
+    name: string
+    created: Date
+}
+
+let User = db.define<'User', User>({
+    name: 'User',
+    columns: {
+        id: {name: 'id', dataType: 'string'},
+        name: {name: 'name', dataType: 'string'},
+        created: {name: 'created', dataType: 'date'}
+    }
+})
+
+interface Post {
+    id: string
+    name: string;
+    created: Date;
+    userId: string;
+}
+
+
+let Post = db.define<'Post', Post>({
+    name: 'Post',
+    columns: {
+        id: {name: 'id', dataType: 'string'},
+        name: {name: 'name', dataType: 'string'},
+        created: {name: 'created', dataType: 'date'},
+        userId: {name: 'userId', dataType: 'string'}
+    }
+})
+
+
+let q2 = User.select(User.name)
+
+let q3 = User.where({id: 1}).select(User.name, User.id)
+
+q3.get().then(u => u.id)
+
+let q4 = User
+    .from(User.join(Post).on(User.id.equals(Post.userId)))
+    .selectDeep(User, Post)
+
+let all = q4.all().then(x => x[0].Post.created)
diff --git a/package.json b/package.json
index 278bc46..4efa92e 100644
--- a/package.json
+++ b/package.json
@@ -40,6 +40,7 @@
     "sql": "^0.45.3"
   },
   "devDependencies": {
+    "@types/bluebird": "^3.0.36",
     "blue-tape": "^0.1.7",
     "sqlite3": "3.x"
   }
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..2b47831
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "noImplicitAny": true
+    }
+}
\ No newline at end of file