diff --git a/react-router/legacy/react-router-0.12-test.ts b/react-router/legacy/react-router-0.12-test.ts
new file mode 100644
index 0000000000..d0d122bd47
--- /dev/null
+++ b/react-router/legacy/react-router-0.12-test.ts
@@ -0,0 +1,346 @@
+///<reference path="react-router-0.12.d.ts" />
+"use strict";
+
+import React = require('react');
+import Router = require('react-router');
+
+// Mixin
+class NavigationTest<T extends Router.Navigation> {
+    v: T;
+    
+    makePath() {
+        var v1: string = this.v.makePath('to');
+        var v2: string = this.v.makePath('to', {id: 1});
+        var v3: string = this.v.makePath('to', {id: 1}, {type: 'json'});
+    }
+    makeHref() {
+        var v1: string = this.v.makeHref('to');
+        var v2: string = this.v.makeHref('to', {id: 1});
+        var v3: string = this.v.makeHref('to', {id: 1}, {type: 'json'});
+    }
+    transitionTo() {
+        var v1: void = this.v.transitionTo('to');
+        var v2: void = this.v.transitionTo('to', {id: 1});
+        var v3: void = this.v.transitionTo('to', {id: 1}, {type: 'json'});
+    }
+    replaceWith() {
+        var v1: void = this.v.replaceWith('to');
+        var v2: void = this.v.replaceWith('to', {id: 1});
+        var v3: void = this.v.replaceWith('to', {id: 1}, {type: 'json'});
+    }
+    goBack() {
+        var v1: void = this.v.goBack();
+    }
+}
+
+class StateTest<T extends Router.State> {
+    v: T;
+    
+    getPath() {
+        var v1: string = this.v.getPath();
+    }
+    
+    getRoutes() {
+        var v1: Router.Route[] = this.v.getRoutes();
+    }
+    
+    getPathname() {
+        var v1: string = this.v.getPathname();
+    }
+    
+    getParams() {
+        var v1: {} = this.v.getParams();
+    }
+    
+    getQuery() {
+        var v1: {} = this.v.getQuery();
+    }
+    
+    isActive() {
+        var v1: boolean = this.v.isActive('to');
+        var v2: boolean = this.v.isActive('to', {id: 1});
+        var v3: boolean = this.v.isActive('to', {id: 1}, {type: 'json'});
+    }
+}
+
+class RouteHandlerMixinTest<T extends Router.RouteHandlerMixin> {
+    v: T;
+    
+    getRouteDepth() {
+        var v1: number = this.v.getRouteDepth();
+    }
+    
+    createChildRouteHandler() {
+        var v1: Router.RouteHandler = this.v.createChildRouteHandler({ref: 'hoge'});
+    }
+}
+
+
+// Location
+class LocationTest<T extends Router.LocationBase> {
+    v: T;
+    
+    push() {
+        var v1: void = this.v.push('path/to/hoge');
+    }
+    
+    replace() {
+        var v1: void = this.v.replace('path/to/hoge');
+    }
+    
+    pop() {
+        var v1: void = this.v.pop();
+    }
+    
+    getCurrentPath() {
+        var v1: void = this.v.getCurrentPath();
+    }
+}
+new LocationTest<Router.HashLocation>();
+new LocationTest<Router.HistoryLocation>();
+new LocationTest<Router.RefreshLocation>();
+
+class LocationListenerTest<T extends Router.LocationListener> {
+    v: T;
+    
+    addChangeListener() {
+        var v1: void = this.v.addChangeListener(() => console.log(1));
+    }
+    
+    removeChangeListener() {
+        var v1: void = this.v.removeChangeListener(() => console.log(1));
+    }
+}
+new LocationListenerTest<Router.HashLocation>();
+new LocationListenerTest<Router.HistoryLocation>();
+
+
+// Behavior
+class ScrollBehaviorTest<T extends Router.ScrollBehaviorBase> {
+    v: T;
+    
+    updateScrollPosition() {
+        var v1: void = this.v.updateScrollPosition({x: 33, y: 102}, 'scrollTop');
+    }
+}
+new ScrollBehaviorTest<Router.ImitateBrowserBehavior>();
+new ScrollBehaviorTest<Router.ScrollToTopBehavior>();
+
+
+// Component
+class DefaultRouteTest {
+    v: Router.DefaultRoute;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.DefaultRoute, null);
+        React.createElement(Router.DefaultRoute, {name: 'name', handler: Handler});
+    }
+}
+
+class LinkTest {
+    v: Router.Link;
+    
+    constructor() {
+        new NavigationTest<Router.Link>();
+        new StateTest<Router.Link>();
+    }
+    
+    props() {
+        var activeClassName: string = this.v.props.activeClassName;
+        var to: string = this.v.props.to;
+        var params: {} = this.v.props.params;
+        var query: {} = this.v.props.query;
+        var onClick: Function = this.v.props.onClick;
+    }
+    
+    getHref() {
+        var v1: string = this.v.getHref();
+    }
+    
+    getClassName() {
+        var v1: string = this.v.getClassName();
+    }
+    
+    createElement() {
+        React.createElement(Router.Link, null);
+        React.createElement(Router.Link, {to: 'home'});
+        React.createElement(Router.Link, {
+            activeClassName: 'name',
+            to: 'home',
+            params: {},
+            query: {},
+            onClick: () => console.log(1)
+        });
+    }
+}
+
+class NotFoundRouteTest {
+    v: Router.NotFoundRoute;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.NotFoundRoute, null);
+        React.createElement(Router.NotFoundRoute, {handler: Handler});
+        React.createElement(Router.NotFoundRoute, {handler: Handler, name: "home"});
+    }
+}
+
+class RedirectTest {
+    v: Router.Redirect;
+    
+    props() {
+        var path: string = this.v.props.path;
+        var from: string = this.v.props.from;
+        var to: string = this.v.props.to;
+    }
+    
+    createElement() {
+        React.createElement(Router.Redirect, null);
+        React.createElement(Router.Redirect, {});
+        React.createElement(Router.Redirect, {path: 'a', from: 'a', to: 'b'});
+    }
+}
+
+class RouteTest {
+    v: Router.Route;
+    
+    props() {
+        var name: string = this.v.props.name;
+        var path: string = this.v.props.path;
+        var handler: React.ComponentClass<any> = this.v.props.handler;
+        var ignoreScrollBehavior: boolean = this.v.props.ignoreScrollBehavior;
+    }
+    
+    createElement() {
+        var Handler: React.ComponentClass<any>;
+        React.createElement(Router.Route, null);
+        React.createElement(Router.Route, {});
+        React.createElement(Router.Route, {name: "home", path: "/", handler: Handler, ignoreScrollBehavior: true});
+    }
+}
+
+class RouteHandlerTest {
+    v: Router.RouteHandler;
+    
+    constructor() {
+        new RouteHandlerMixinTest<Router.RouteHandler>();
+    }
+    
+    createElement() {
+        React.createElement(Router.RouteHandler, null);
+        React.createElement(Router.RouteHandler, {});
+    }
+}
+
+
+// History
+class HistoryTest {
+    v: Router.History;
+    
+    length() {
+        var v1: number = this.v.length;
+    }
+    
+    back() {
+        var v1: void = this.v.back();
+    }
+}
+
+
+// Router
+class CreateTest {
+    v: Router.Router;
+    
+    constructor() {
+        // React.createElement() version
+        this.v = Router.create({
+            routes: React.createElement(Router.Route, null)
+        });
+        this.v = Router.create({
+            routes: React.createElement(Router.Route, null),
+            location: Router.HistoryLocation,
+            scrollBehavior: Router.ImitateBrowserBehavior
+        });
+        
+        // React.createFactory() version
+        this.v = Router.create({
+            routes: React.createFactory(Router.Route)()
+        });
+        this.v = Router.create({
+            routes: React.createFactory(Router.Route)(),
+            location: Router.HistoryLocation,
+            scrollBehavior: Router.ImitateBrowserBehavior
+        });
+    }
+    
+    run() {
+        this.v.run((Handler) => console.log(Handler));
+        this.v.run((Handler, state) => console.log(Handler, state));
+    }
+}
+
+class RunTest {
+    constructor() {
+        // React.createElement() version
+        var v1: Router.Router = Router.run(React.createElement(Router.Route, null), (Handler) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        var v2: Router.Router = Router.run(React.createElement(Router.Route, null), Router.HistoryLocation, (Handler, state) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        
+        // React.createFactory() version
+        var v3: Router.Router = Router.run(React.createFactory(Router.Route)(), (Handler) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+        var v4: Router.Router = Router.run(React.createFactory(Router.Route)(), Router.HistoryLocation, (Handler, state) => {
+            React.render(React.createElement(Handler, null), document.body);
+        });
+    }
+}
+
+
+// Transition
+class TransitionTest {
+    constructor() {
+        var v1: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params, query, callback) => {
+                transition.abort();
+                transition.redirect('to');
+                transition.redirect('to', {id: 1});
+                transition.redirect('to', {id: 1}, {type: 'json'});
+                transition.retry();
+            },
+            willTransitionFrom: (transition, component, callback) => {}
+        };
+        var v2: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params, query) => {},
+            willTransitionFrom: (transition, component) => {}
+        };
+        var v3: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition, params) => {},
+            willTransitionFrom: (transition) => {}
+        };
+        var v4: Router.TransitionStaticLifecycle = {
+            willTransitionTo: (transition) => {},
+            willTransitionFrom: () => {}
+        };
+        var v5: Router.TransitionStaticLifecycle = {
+            willTransitionTo: () => {}
+        };
+        var v6: Router.TransitionStaticLifecycle = {
+            willTransitionFrom: () => {}
+        };
+    }
+}
diff --git a/react-router/legacy/react-router-0.12.d.ts b/react-router/legacy/react-router-0.12.d.ts
new file mode 100644
index 0000000000..a38e558228
--- /dev/null
+++ b/react-router/legacy/react-router-0.12.d.ts
@@ -0,0 +1,278 @@
+// Type definitions for React Router 0.12.0
+// Project: https://github.com/rackt/react-router
+// Definitions by: Yuichi Murata <https://github.com/mrk21>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path='../../react/legacy/react-0.12.d.ts' />
+
+declare module ReactRouter {
+    //
+    // Mixin
+    // ----------------------------------------------------------------------
+    interface Navigation {
+        makePath(to: string, params?: {}, query?: {}): string;
+        makeHref(to: string, params?: {}, query?: {}): string;
+        transitionTo(to: string, params?: {}, query?: {}): void;
+        replaceWith(to: string, params?: {}, query?: {}): void;
+        goBack(): void;
+    }
+    
+    interface RouteHandlerMixin {
+        getRouteDepth(): number;
+        createChildRouteHandler(props: {}): RouteHandler;
+    }
+    
+    interface State {
+        getPath(): string;
+        getRoutes(): Route[];
+        getPathname(): string;
+        getParams(): {};
+        getQuery(): {};
+        isActive(to: string, params?: {}, query?: {}): boolean;
+    }
+    
+    var Navigation: Navigation;
+    var State: State;
+    var RouteHandlerMixin: RouteHandlerMixin;
+    
+    
+    //
+    // Component
+    // ----------------------------------------------------------------------
+    // DefaultRoute
+    interface DefaultRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface DefaultRoute extends React.ReactElement<DefaultRouteProp> {
+        __react_router_default_route__: any; // dummy
+    }
+    interface DefaultRouteClass extends React.ComponentClass<DefaultRouteProp> {
+        __react_router_default_route__: any; // dummy
+    }
+    
+    // Link
+    interface LinkProp {
+        activeClassName?: string;
+        to: string;
+        params?: {};
+        query?: {};
+        onClick?: Function;
+    }
+    interface Link extends React.ReactElement<LinkProp>, Navigation, State {
+        __react_router_link__: any; // dummy
+        
+        getHref(): string;
+        getClassName(): string;
+    }
+    interface LinkClass extends React.ComponentClass<LinkProp> {
+        __react_router_link__: any; // dummy
+    }
+    
+    // NotFoundRoute
+    interface NotFoundRouteProp {
+        name?: string;
+        handler: React.ComponentClass<any>;
+    }
+    interface NotFoundRoute extends React.ReactElement<NotFoundRouteProp> {
+        __react_router_not_found_route__: any; // dummy
+    }
+    interface NotFoundRouteClass extends React.ComponentClass<NotFoundRouteProp> {
+        __react_router_not_found_route__: any; // dummy
+    }
+    
+    // Redirect
+    interface RedirectProp {
+        path?: string;
+        from?: string;
+        to?: string;
+    }
+    interface Redirect extends React.ReactElement<RedirectProp> {
+        __react_router_redirect__: any; // dummy
+    }
+    interface RedirectClass extends React.ComponentClass<RedirectProp> {
+        __react_router_redirect__: any; // dummy
+    }
+    
+    // Route
+    interface RouteProp {
+        name?: string;
+        path?: string;
+        handler?: React.ComponentClass<any>;
+        ignoreScrollBehavior?: boolean;
+    }
+    interface Route extends React.ReactElement<RouteProp> {
+        __react_router_route__: any; // dummy
+    }
+    interface RouteClass extends React.ComponentClass<RouteProp> {
+        __react_router_route__: any; // dummy
+    }
+    
+    // RouteHandler
+    interface RouteHandlerProp {}
+    interface RouteHandler extends React.ReactElement<RouteHandlerProp>, RouteHandlerMixin {
+        __react_router_route_handler__: any; // dummy
+    }
+    interface RouteHandlerClass extends React.ReactElement<RouteHandlerProp> {
+        __react_router_route_handler__: any; // dummy
+    }
+    
+    var DefaultRoute: DefaultRouteClass;
+    var Link: LinkClass;
+    var NotFoundRoute: NotFoundRouteClass;
+    var Redirect: RedirectClass;
+    var Route: RouteClass;
+    var RouteHandler: RouteHandlerClass;
+    
+    
+    //
+    // Location
+    // ----------------------------------------------------------------------
+    interface LocationBase {
+        push(path: string): void;
+        replace(path: string): void;
+        pop(): void;
+        getCurrentPath(): void;
+    }
+    
+    interface LocationListener {
+        addChangeListener(listener: Function): void;
+        removeChangeListener(listener: Function): void;
+    }
+    
+    interface HashLocation extends LocationBase, LocationListener {}
+    interface HistoryLocation extends LocationBase, LocationListener {}
+    interface RefreshLocation extends LocationBase {}
+    
+    var HashLocation: HashLocation;
+    var HistoryLocation: HistoryLocation;
+    var RefreshLocation: RefreshLocation;
+    
+    
+    //
+    // Behavior
+    // ----------------------------------------------------------------------
+    interface ScrollBehaviorBase {
+        updateScrollPosition(position: {x: number; y: number;}, actionType: string): void;
+    }
+    interface ImitateBrowserBehavior extends ScrollBehaviorBase {}
+    interface ScrollToTopBehavior extends ScrollBehaviorBase {}
+    
+    var ImitateBrowserBehavior: ImitateBrowserBehavior;
+    var ScrollToTopBehavior: ScrollToTopBehavior;
+    
+    
+    //
+    // Router
+    // ----------------------------------------------------------------------
+    interface Router extends React.ReactElement<any> {
+        run(callback: RouterRunCallback): void;
+    }
+    
+    interface RouterState {
+        path: string;
+        action: string;
+        pathname: string;
+        params: {};
+        query: {};
+        routes : Route[];
+    }
+    
+    interface RouterCreateOption {
+        routes: React.ReactElement<RouteProp>;
+        location?: LocationBase;
+        scrollBehavior?: ScrollBehaviorBase;
+    }
+    
+    type RouterRunCallback = (Handler: Router, state: RouterState) => void;
+    
+    function create(options: RouterCreateOption): Router;
+    function run(routes: React.ReactElement<RouteProp>, callback: RouterRunCallback): Router;
+    function run(routes: React.ReactElement<RouteProp>, location: LocationBase, callback: RouterRunCallback): Router;
+    
+    
+    //
+    // History
+    // ----------------------------------------------------------------------
+    interface History {
+        back(): void;
+        length: number;
+    }
+    var History: History;
+    
+    
+    //
+    // Transition
+    // ----------------------------------------------------------------------
+    interface Transition {
+        abort(): void;
+        redirect(to: string, params?: {}, query?: {}): void;
+        retry(): void;
+    }
+    
+    interface TransitionStaticLifecycle {
+        willTransitionTo?(
+            transition: Transition,
+            params: {},
+            query: {},
+            callback: Function
+        ): void;
+        
+        willTransitionFrom?(
+            transition: Transition,
+            component: React.ReactElement<any>,
+            callback: Function
+        ): void;
+    }
+}
+
+declare module 'react-router' {
+    import Export = ReactRouter;
+    export = Export;
+}
+
+declare module React {
+    interface TopLevelAPI {
+        // for DefaultRoute
+        createElement(
+            type: ReactRouter.DefaultRouteClass,
+            props: ReactRouter.DefaultRouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.DefaultRoute;
+        
+        // for Link
+        createElement(
+            type: ReactRouter.LinkClass,
+            props: ReactRouter.LinkProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Link;
+        
+        // for NotFoundRoute
+        createElement(
+            type: ReactRouter.NotFoundRouteClass,
+            props: ReactRouter.NotFoundRouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.NotFoundRoute;
+        
+        // for Redirect
+        createElement(
+            type: ReactRouter.RedirectClass,
+            props: ReactRouter.RedirectProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Redirect;
+        
+        // for Route
+        createElement(
+            type: ReactRouter.RouteClass,
+            props: ReactRouter.RouteProp,
+            ...children: ReactNode[]
+        ): ReactRouter.Route;
+        
+        // for RouteHandler
+        createElement(
+            type: ReactRouter.RouteHandlerClass,
+            props: ReactRouter.RouteHandlerProp,
+            ...children: ReactNode[]
+        ): ReactRouter.RouteHandler;
+    }
+}