diff --git a/alt/alt-tests.ts b/alt/alt-tests.ts
new file mode 100644
index 000000000..403c9d99a
--- /dev/null
+++ b/alt/alt-tests.ts
@@ -0,0 +1,143 @@
+/**
+ * Created by shearerbeard on 6/28/15.
+ */
+///<reference path="alt.d.ts"/>
+///<reference path="../es6-promise/es6-promise.d.ts" />
+
+import Alt = require("alt");
+import Promise = require("es6-promise");
+
+//New alt instance
+var alt = new Alt();
+
+//Interfaces for our Action Types
+interface TestActionsGenerate {
+    notifyTest(str:string):void;
+}
+
+interface TestActionsExplicit {
+    doTest(str:string):void;
+    success():void;
+    error():void;
+    loading():void;
+}
+
+//Create abstracts to inherit ghost methods
+class AbstractActions implements AltJS.ActionsClass {
+    constructor( alt:AltJS.Alt){}
+    actions:any;
+    dispatch: ( ...payload:Array<any>) => void;
+    generateActions:( ...actions:Array<string>) => void;
+}
+
+class AbstractStoreModel<S> implements AltJS.StoreModel<S> {
+  bindActions:( ...actions:Array<Object>) => void;
+  bindAction:( ...args:Array<any>) => void;
+  bindListeners:(obj:any)=> void;
+  exportPublicMethods:(config:{[key:string]:(...args:Array<any>) => any}) => any;
+  exportAsync:( source:any) => void;
+  waitFor:any;
+  exportConfig:any;
+  getState:() => S;
+}
+
+class GenerateActionsClass extends AbstractActions {
+    constructor(config:AltJS.Alt) {
+        this.generateActions("notifyTest");
+        super(config);
+    }
+}
+
+class ExplicitActionsClass extends AbstractActions {
+    doTest(str:string) {
+        this.dispatch(str);
+    }
+    success() {
+        this.dispatch();
+    }
+    error() {
+        this.dispatch();
+    }
+    loading() {
+        this.dispatch();
+    }
+}
+
+var generatedActions = alt.createActions<TestActionsGenerate>(GenerateActionsClass);
+var explicitActions = alt.createActions<ExplicitActionsClass>(ExplicitActionsClass);
+
+interface AltTestState {
+    hello:string;
+}
+
+var testSource:AltJS.Source = {
+    fakeLoad():AltJS.SourceModel<string> {
+        return {
+            remote() {
+                return new Promise.Promise<string>((res:any, rej:any) => {
+                    setTimeout(() => {
+                        if(true) {
+                            res("stuff");
+                        } else {
+                            rej("Things have broken");
+                        }
+                    }, 250)
+                });
+            },
+            local() {
+                return "local";
+            },
+            success: explicitActions.success,
+            error: explicitActions.error,
+            loading:explicitActions.loading
+        };
+    }
+};
+
+class TestStore extends AbstractStoreModel<AltTestState> implements AltTestState {
+    hello:string = "world";
+    constructor() {
+        super();
+        this.bindAction(generatedActions.notifyTest, this.onTest);
+        this.bindActions(explicitActions);
+        this.exportAsync(testSource);
+        this.exportPublicMethods({
+            split: this.split
+        });
+    }
+    onTest(str:string) {
+        this.hello = str;
+    }
+
+    onDoTest(str:string) {
+        this.hello = str;
+    }
+
+    split():string[] {
+        return this.hello.split("");
+    }
+}
+
+interface ExtendedTestStore extends AltJS.AltStore<AltTestState> {
+    fakeLoad():string;
+    split():Array<string>;
+}
+
+var testStore = <ExtendedTestStore>alt.createStore<AltTestState>(TestStore);
+
+function testCallback(state:AltTestState) {
+    console.log(state);
+}
+
+//Listen allows a typed state callback
+testStore.listen(testCallback);
+testStore.unlisten(testCallback);
+
+//State generic passes to derived store
+var name:string = testStore.getState().hello;
+var nameChars:Array<string> = testStore.split();
+
+generatedActions.notifyTest("types");
+explicitActions.doTest("more types");
+
+export var result = testStore.getState();
diff --git a/alt/alt.d.ts b/alt/alt.d.ts
index 7f74b069e..750c89131 100644
--- a/alt/alt.d.ts
+++ b/alt/alt.d.ts
@@ -3,29 +3,64 @@
 // Definitions by: Michael Shearer <https://github.com/Shearerbeard>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="../flux/flux.d.ts"/>
-
+///<reference path="../react/react.d.ts"/>
+///<reference path="../es6-promise/es6-promise.d.ts" />
 
 declare module AltJS {
 
-  export interface StoreModel<S> {
-    bindActions?( ...actions:Array<Object>);
-    exportPublicMethods?<M>(exportConfig:M):void;
-    getState?():S;
-    exportAsync?(source:Source);
-    waitFor?(store:AltStore<any>):void;
+  interface StoreReduce {
+    action:any;
+    data: any;
   }
 
-  export type Source = {[name:string]:() => SourceModel};
+  export interface StoreModel<S> {
+    //Actions
+    bindAction?( action:Action<any>, handler:ActionHandler):void;
+    bindActions?(actions:ActionsClass):void;
 
-  export interface SourceModel {
-    local( ...args:Array<any>);
-    remote( ...args:Array<any>);
-    shouldFetch?(state:Object, ...args:Array<any>);
-    loading: ( ...args:Array<any>) => void;
-    success:( ...args:Array<any>) => void;
-    error:( ...args:Array<any>) => void;
-    interceptResponse?(response:Object, action:AltJS.Action<any>, ...args:Array<any>);
+    //Methods/Listeners
+    exportPublicMethods?(exportConfig:any):void;
+    bindListeners?(config:{[methodName:string]:Action<any> | Actions}):void;
+    exportAsync?(source:Source):void;
+    registerAsync?(datasource:Source):void;
+
+    //state
+    setState?(state:S):void;
+    setState?(stateFn:(currentState:S, nextState:S) => S):void;
+    getState?():S;
+    waitFor?(store:AltStore<any>):void;
+
+    //events
+    onSerialize?(fn:(data:any) => any):void;
+    onDeserialize?(fn:(data:any) => any):void;
+    on?(event:AltJS.lifeCycleEvents, callback:() => any):void;
+    emitChange?():void;
+    waitFor?(storeOrStores:AltStore<any> | Array<AltStore<any>>):void;
+    otherwise?(data:any, action:AltJS.Action<any>):void;
+    observe?(alt:Alt):any;
+    reduce?(state:any, config:StoreReduce):Object;
+    preventDefault?():void;
+    afterEach?(payload:Object, state:Object):void;
+    beforeEach?(payload:Object, state:Object):void;
+    // TODO: Embed dispatcher interface in def
+    dispatcher?:any;
+
+    //instance
+    getInstance?():AltJS.AltStore<S>;
+    alt?:Alt;
+    displayName?:string;
+  }
+
+  export type Source = {[name:string]:() => SourceModel<any>};
+
+  export interface SourceModel<S> {
+    local(...args:Array<any>):S;
+    remote(...args:Array<any>):Promise<S>;
+    shouldFetch?(state:Object, ...args:Array<any>):boolean;
+    loading: (action:Action<any>) => void;
+    success:(action:Action<S>) => void;
+    error:(action:Action<any>) => void;
+    interceptResponse?(response:any, action:Action<any>, ...args:Array<any>):any;
   }
 
   export interface AltStore<S> {
@@ -46,111 +81,87 @@ declare module AltJS {
   export type Actions = {[action:string]:Action<any>};
 
   export interface Action<T> {
-    (T);
+    ( args:T):void;
     defer(data:any):void;
   }
 
   export interface ActionsClass {
-    generateActions?( ...action:Array<string>);
-    dispatch( ...payload:Array<any>);
+    generateActions?( ...action:Array<string>):void;
+    dispatch( ...payload:Array<any>):void;
     actions?:Actions;
   }
-}
-
-declare module "alt/utils/chromeDebug" {
-	function chromeDebug(alt:any):void;
-	export = chromeDebug;
-}
-
-declare module "alt/AltContainer" {
-
-  import * as React from "react";
-
-  interface ContainerProps {
-    store:AltJS.AltStore<any>
-  }
-
-  class AltContainer extends React.Component<ContainerProps, any> {
-  }
-
-  export = AltContainer;
-}
-
-declare module "alt" {
-
-  import {Dispatcher} from "flux";
 
   type StateTransform = (store:StoreModel<any>) => AltJS.AltStore<any>;
 
   interface AltConfig {
-    dispatcher?:Dispatcher<any>;
-    serialize?:(data:Object) => string;
-    deserialize?:(serialized:string) => Object;
+    dispatcher?:any;
+    serialize?:(serializeFn:(data:Object) => string) => void;
+    deserialize?:(deserializeFn:(serialData:string) => Object) => void;
     storeTransforms?:Array<StateTransform>;
     batchingFunction?:(callback:( ...data:Array<any>) => any) => void;
   }
 
   class Alt {
     constructor(config?:AltConfig);
-    actions:AltJS.Actions;
-    bootstrap(data:string);
+    actions:Actions;
+    bootstrap(jsonData:string):void;
     takeSnapshot( ...storeNames:Array<string>):string;
     flush():Object;
-    recycle( ...store:Array<AltJS.AltStore<any>>);
-    rollback();
-    dispatch(action?:AltJS.Action<any>, data?:Object, details?:any);
-    addActions(actionsName:string, actions:AltJS.ActionsClass);
-    addStore(name:string, store:StoreModel<any>, saveStore?:boolean);
-    getStore(name:string):AltJS.AltStore<any>;
-    getActions(actionsName:string):AltJS.Actions;
-    createAction<T>(name:string, implementation:AltJS.ActionsClass):AltJS.Action<T>;
-    createAction<T>(name:string, implementation:AltJS.ActionsClass, ...args:Array<any>):AltJS.Action<T>;
+    recycle( ...stores:Array<AltJS.AltStore<any>>):void;
+    rollback():void;
+    dispatch(action?:AltJS.Action<any>, data?:Object, details?:any):void;
+
+    //Actions methods
+    addActions(actionsName:string, ActionsClass: ActionsClassConstructor):void;
     createActions<T>(ActionsClass: ActionsClassConstructor, exportObj?: Object):T;
     createActions<T>(ActionsClass: ActionsClassConstructor, exportObj?: Object, ...constructorArgs:Array<any>):T;
-    generateActions<T>( ...action:Array<string>):T;
+    generateActions<T>( ...actions:Array<string>):T;
+    getActions(actionsName:string):AltJS.Actions;
+
+    //Stores methods
+    addStore(name:string, store:StoreModel<any>, saveStore?:boolean):void;
     createStore<S>(store:StoreModel<S>, name?:string):AltJS.AltStore<S>;
+    getStore(name:string):AltJS.AltStore<any>;
+  }
+
+  export interface AltFactory {
+    new(config?:AltConfig):Alt;
   }
 
   type ActionsClassConstructor = new (alt:Alt) => AltJS.ActionsClass;
 
   type ActionHandler = ( ...data:Array<any>) => any;
-  type ExportConfig = {[key:string]:( ...args:Array<any>) => any};
+  type ExportConfig = {[key:string]:(...args:Array<any>) => any};
+}
 
-  interface StoreReduce {
-    action:any;
-    data: any;
-  }
+declare module "alt/utils/chromeDebug" {
+  function chromeDebug(alt:AltJS.Alt):void;
+  export = chromeDebug;
+}
+
+declare module "alt/AltContainer" {
+
+  import React = require("react");
 
-  interface StoreModel<S> extends AltJS.StoreModel<S> {
-    setState?(currentState:Object, nextState:Object):Object;
-    getState?():S;
-    onSerialize?(data:any):void;
-    onDeserialize?(data:any):void;
-    on?(event:AltJS.lifeCycleEvents, callback:() => any):void;
-    bindActions?(action:AltJS.Action<any>, method:ActionHandler):void;
-    bindListeners?(config:{string: AltJS.Action<any> | AltJS.Actions});
-    waitFor?(dispatcherSource:any):void;
-    exportPublicMethods?(exportConfig:ExportConfig):void;
-    getInstance?():AltJS.AltStore<S>;
-    emitChange?():void;
-    dispatcher?:Dispatcher<any>;
-    alt?:Alt;
-    displayName?:string;
-    otherwise?(data:any, action:AltJS.Action<any>);
-    reduce?(state:any, config:StoreReduce):Object;
-    preventDefault?();
-    observe?(alt:Alt):any;
-    registerAsync?(datasource:AltJS.Source);
-    beforeEach?(payload:Object, state:Object);
-    afterEach?(payload:Object, state:Object);
-    unlisten?();
+  interface ContainerProps {
+    store?:AltJS.AltStore<any>;
+    stores?:Array<AltJS.AltStore<any>>;
+    inject?:{[key:string]:any};
+    actions?:{[key:string]:Object};
+    render?:(...props:Array<any>) => React.ReactElement<any>;
+    flux?:AltJS.Alt;
+    transform?:(store:AltJS.AltStore<any>, actions:any) => any;
+    shouldComponentUpdate?:(props:any) => boolean;
+    component?:React.Component<any, any>;
   }
 
-  type StoreModelConstructor = (alt:Alt) => StoreModel<any>;
+  type AltContainer = React.ReactElement<ContainerProps>;
+  var AltContainer:React.ComponentClass<ContainerProps>;
 
-  interface AltFactory {
-    new(config?:AltConfig):Alt;
-  }
+  export = AltContainer;
+}
 
-  export = Alt;
+declare module "alt" {
+  var alt:AltJS.AltFactory;
+  export = alt;
 }