diff --git a/Actions.js b/Actions.js
new file mode 100644
index 000000000..030b10c38
--- /dev/null
+++ b/Actions.js
@@ -0,0 +1,90 @@
+import Route from './Route';
+import Router from './Router';
+
+function isNumeric(n){
+    return !isNaN(parseFloat(n)) && isFinite(n);
+}
+
+function filterParam(data){
+    if (data.toString()!='[object Object]')
+        return data;
+    if (!data){
+        return;
+    }
+    var proto = (data||{}).constructor.name;
+    // avoid passing React Native parameters
+    if (proto != 'Object'){
+        data = {};
+    }
+    if (data.data){
+        data.data = filterParam(data.data);
+    }
+    return data;
+}
+
+class Actions {
+    currentRouter: ?Router;
+
+    constructor(){
+        this.pop = this.pop.bind(this);
+        this.route = this.route.bind(this);
+    }
+
+    route(name: string, props: { [key: string]: any} = {}){
+        if (!this.currentRouter){
+            throw new Error("No current router is set");
+        }
+        if (props.toString()!='[object Object]')
+            props = {data : props};
+
+        props = filterParam(props);
+        // check if route is in children, current or parent routers
+        let router: Router = this.currentRouter;
+        // deep into child router
+        while (router.currentRoute.childRouter){
+            router = router.currentRoute.childRouter;
+        }
+        while (!router.routes[name]){
+            const route = router.parentRoute;
+            if (!route || !route.parent){
+                throw new Error("Cannot find router for route="+name);
+            }
+            router = route.parent;
+        }
+        if (router.route(name, props)){
+            this.currentRouter = router;
+            return true;
+        }
+        return false;
+    }
+    pop(num: number = 1){
+        if (!isNumeric(num)){
+            num = 1;
+        }
+        if (!this.currentRouter){
+            throw new Error("No current router is set");
+        }
+        if (num > 1){
+            for (let i=0;i<num;i++){
+                if (!Actions.pop()){
+                    return false;
+                }
+            }
+            return true;
+        } else {
+            let router: Router = this.currentRouter;
+            while (router.stack.length <= 1 || router.currentRoute.type === 'switch'){
+                router = router.parentRoute.parent;
+            }
+            if (router.pop()){
+                this.currentRouter = router;
+                return true;
+            } else {
+                return false;
+            }
+
+        }
+    }
+}
+
+export default new Actions();
diff --git a/Common.js b/Common.js
new file mode 100644
index 000000000..ce4285719
--- /dev/null
+++ b/Common.js
@@ -0,0 +1,23 @@
+import React from 'react-native';
+
+// schema class represents schema for routes and it is processed inside Router component
+export class Schema extends React.Component {
+    className(){
+        return "Schema";
+    }
+    render(){
+        return null;
+    }
+}
+
+// route class processed inside Router component
+export class Route extends React.Component {
+    className(){
+        return "Route";
+    }
+    render(){
+        return null;
+    }
+
+}
+
diff --git a/ExRouter.js b/ExRouter.js
new file mode 100644
index 000000000..ef70ec104
--- /dev/null
+++ b/ExRouter.js
@@ -0,0 +1,195 @@
+import React from 'react-native';
+import Router from './Router';
+import Route from './Route';
+import * as Components from './Common';
+import ExNavigator from '@exponent/react-native-navigator';
+import Animations from './Animations';
+const {TouchableOpacity, StyleSheet, View, Text} = React;
+import ReactRouter from './ReactRouter';
+
+export class ExRoute {
+    name: string;
+    navigator: ExNavigator;
+    route: Route;
+    props: { [key: string]: any};
+
+    constructor(route: Route, props:{ [key: string]: any} = {}){
+        if (!route){
+            throw new Error("route is not defined ");
+        }
+        this.route = route;
+        this.name = route.name;
+        if (!this.name){
+            throw new Error("name is not defined for route");
+        }
+        this.props = props;
+        this.renderScene = this.renderScene.bind(this);
+    }
+
+    configureScene() {
+        return this.route.type === 'switch' ? Animations.None : this.route.props.sceneConfig || Animations.None;
+    }
+
+    renderScene(navigator) {
+        const Component = this.route.component;
+        const child = Component ?
+            !this.route.wrapRouter ? <Component key={this.route.name} name={this.route.name} {...this.route.props} {...this.props} route={this.route}/>:
+                <ReactRouter name={this.route.name+"Router"} {...this.route.props} {...this.props} route={this.route} router={ExRouter} >
+                    <Components.Route {...this.route.props}  {...this.props} component={Component} name={"_"+this.route.name} type="push" wrapRouter={false}/>
+                </ReactRouter>
+            :
+            React.cloneElement(React.Children.only(this.route.children), {...this.route.props, data:this.props, route:this.route});
+        return child;
+    }
+
+    getName(){
+        return this.route.name;
+    }
+
+    getTitle() {
+        return this.route.title || "";
+    }
+
+    getBackButtonTitle(navigator, index, state){
+        let previousIndex = index - 1;
+        let previousRoute = state.routeStack[previousIndex];
+        let title = previousRoute.getTitle(navigator, previousIndex, state);
+        return title.length>10 ? null : title;
+    }
+
+    renderRightButton() {
+        if (this.route.onRight && this.route.rightTitle){
+            return (<TouchableOpacity
+                touchRetentionOffset={ExNavigator.Styles.barButtonTouchRetentionOffset}
+                onPress={() => this.route.onRight({...this.route.props, ...this.props})}
+                style={[ExNavigator.Styles.barRightButton, this.route.rightButtonStyle]}>
+                <Text style={[ExNavigator.Styles.barRightButtonText, this.route.rightButtonTextStyle]}>{this.route.rightTitle}</Text>
+            </TouchableOpacity>);
+        } else {
+            return null;
+        }
+    }
+}
+
+const defaultCreateRoute = function(route, data){
+    return new ExRoute(route, data);
+};
+
+export default class ExRouter extends React.Component {
+    router: Router;
+
+    constructor(props){
+        super(props);
+        this.onPop = this.onPop.bind(this);
+        this.onPush = this.onPush.bind(this);
+        this.onPop = this.onPop.bind(this);
+        this.onPush = this.onPush.bind(this);
+        this.onReplace = this.onReplace.bind(this);
+        this.onJump = this.onJump.bind(this);
+    }
+
+    onPush(route: Route, props:{ [key: string]: any}):boolean {
+        if (this.props.onPush){
+            const res = this.props.onPush(route, props);
+            if (!res){
+                return false;
+            }
+        }
+        this.refs.nav.push(new ExRoute(route, props));
+        return true;
+    }
+
+    onReplace(route: Route, props:{ [key: string]: any}):boolean {
+        if (this.props.onReplace){
+            const res = this.props.onReplace(route, props);
+            if (!res){
+                return false;
+            }
+        }
+        this.refs.nav.replace(new ExRoute(route, props));
+        return true;
+    }
+
+    onJump(route: Route, props:{ [key: string]: any}):boolean {
+        if (this.props.onJump){
+            const res = this.props.onJump(route, props);
+            if (!res){
+                return false;
+            }
+        }
+        const navigator = this.refs.nav;
+        const routes = navigator.getCurrentRoutes();
+        const exist = routes.filter(el=>el.getName()==route.name);
+        if (exist.length){
+            navigator.jumpTo(exist[0]);
+        } else {
+            navigator.push(new ExRoute(route, props));
+
+        }
+        this.setState({selected: route.name});
+        return true;
+    }
+
+    onPop(num: number){
+        if (this.props.onPop){
+            const res = this.props.onPop(num);
+            if (!res){
+                return false;
+            }
+        }
+        this.refs.nav.pop();
+        return true;
+    }
+
+    render() {
+        const router = this.props.router;
+        if (!router){
+            throw new Error("No router is defined");
+        }
+        const Header = this.props.header;
+        const header = Header ? <Header {...this.props} {...this.state}/> : null;
+
+        const Footer = this.props.footer;
+        const footer = Footer ? <Footer {...this.props} {...this.state}/> : null;
+
+        return (
+            <View style={styles.transparent}>
+                {header}
+                <ExNavigator ref="nav" initialRouteStack={router.stack.map(route => new ExRoute(router.routes[route]))}
+                         style={styles.transparent}
+                         sceneStyle={{ paddingTop: 0 }}
+                         showNavigationBar={!this.props.hideNavBar}
+                    {...this.props}
+                />
+                {footer}
+            </View>
+        );
+    }
+
+
+}
+
+
+var styles = StyleSheet.create({
+    container: {
+        position: 'absolute',
+        top:0,
+        bottom:0,
+        left:0,
+        right:0,
+        backgroundColor:'transparent',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    transparent: {
+        flex:1,
+        backgroundColor: "transparent"
+    },
+    barTitleText: {
+        fontFamily: '.HelveticaNeueInterface-MediumP4',
+        fontSize: 17,
+        marginTop: 11,
+    },
+
+});
+
diff --git a/ReactRouter.js b/ReactRouter.js
new file mode 100644
index 000000000..1ac7cb2b1
--- /dev/null
+++ b/ReactRouter.js
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2015-present, Pavel Aksonov
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import React from 'react-native'
+import Router from './Router';
+import ExRouter from './ExRouter';
+const {StyleSheet, View} = React;
+import Actions from './Actions';
+export default class extends React.Component {
+
+    constructor(props){
+        super(props);
+        const createRouter = props.createRouter || this.createRouter;
+        this.router = createRouter(props);
+    }
+
+    createRouter(props){
+        const schemas = React.Children.map(props.children, child=>child).filter(child=>child.type.prototype.className() === "Schema").map(child=>child.props);
+        const routes = React.Children.map(props.children, child=>child).filter(child=>child.type.prototype.className() === "Route").map(child=>child.props);
+        return new Router(routes, schemas, props.initialRoutes || (props.initial && [props.initial]), props);
+    }
+
+    componentDidMount(){
+        this.router.delegate = this.refs.router;
+    }
+
+    render(){
+        const Component = this.props.router || ExRouter;
+        return (<Component ref="router" {...this.props} router={this.router} />);
+    }
+}
diff --git a/Route.js b/Route.js
new file mode 100644
index 000000000..b87180069
--- /dev/null
+++ b/Route.js
@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2015-present, Pavel Aksonov
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type Router from './Router';
+export default class Route {
+    name: string;
+    type: string;
+    title: string;
+    header: any;
+    footer: any;
+    component: any;
+    children: any;
+    props: { [key: string]: any};
+    parent: Router;
+    navigator: any;
+    childRouter: ?Router;
+
+    constructor({name, type, component, children, header, footer, wrapRouter, ...props}: { [key: string]: any} = {}, parent: Router = null) {
+        if (!name) {
+            throw new Error("no name is defined for Route=" + name);
+        }
+        if (!props) {
+            throw new Error("no props is defined for Route=" + name);
+        }
+        this.name = name;
+        this.type = type || 'push';
+        this.component = component;
+        this.children = children;
+        if (!this.component && !this.children) {
+            throw new Error("component or children should be defined for route=" + name);
+        }
+        if (!parent) {
+            throw new Error("Parent router is not set!");
+        }
+        this.title = props.title;
+        this.parent = parent;
+        this.header = header;
+        this.footer = footer;
+        this.props = props;
+        this.wrapRouter = wrapRouter || this.type == 'switch';
+
+    }
+
+}
\ No newline at end of file
diff --git a/Router.js b/Router.js
new file mode 100644
index 000000000..2b70afba6
--- /dev/null
+++ b/Router.js
@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) 2015-present, Pavel Aksonov
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import Route from './Route';
+import Actions from './Actions';
+
+export class RouterDelegate {
+    onPush(name:string, props:{ [key: string]: any}):boolean {
+        return true;
+    }
+    onPop(name:string, props:{ [key: string]: any}): boolean {
+        return true;
+    }
+    onReplace(name:string, props:{ [key: string]: any}):boolean {
+        return true;
+    }
+    onSwitch(name:string, props:{ [key: string]: any}):boolean {
+        return true;
+    }
+}
+
+export default class Router {
+    name:string;
+    routes: {[key: string]: Route };
+    schemas: {[key: string]: {[key:string]:any } };
+    props: { [key: string]: any};
+    parentRoute: ?Route;
+    _stack: Array<string>;
+    delegate:RouterDelegate;
+
+    set stack(stack:Array<string>) {
+        if (!stack || !stack.length) {
+            throw new Error("Cannot be set to empty stack");
+        }
+        this._stack = stack;
+    }
+
+    get stack():Array<string> {
+        return this._stack;
+    }
+
+    get currentRoute():Route {
+        return this.routes[this._stack[this._stack.length-1]];
+    }
+
+    get previousRoute():Route {
+        if (this._stack.length > 1){
+            return this.routes[this._stack[this._stack.length-2]];
+        } else {
+            return null;
+        }
+    }
+
+    constructor(routes: Array<{ [key: string]: any}>,
+                schemas:Array<{ [key: string]: any}> = [],
+                stack:Array<string> = null, props:{ [key: string]: any} = {}){
+        this.schemas = {};
+        this.routes = {};
+        this.delegate = new RouterDelegate();
+        if (!routes || !routes.length){
+            throw new Error("routes is not defined");
+        }
+        this.props = props;
+        this.name = props && props.name;
+        this.parentRoute = props && props.route;
+        if (this.parentRoute){
+            if (this.parentRoute.parent){
+                // copy parent schemas
+                Object.keys(this.parentRoute.parent.schemas).forEach(el=>
+                    this._addSchema(this.parentRoute.parent.schemas[el].name, this.parentRoute.parent.schemas[el]));
+            }
+            this.parentRoute.childRouter = this;
+        }
+
+
+        schemas.forEach(el=>this._addSchema(el.name, el));
+        routes.forEach(el=>this._addRoute(el.name, el));
+
+        // select first one as initial
+        if (!stack || !stack.length){
+            stack = [routes[0].name];
+        }
+        this.stack = stack;
+        // add actions
+        this._addActions();
+    }
+
+    _addSchema(name: string, props:{ [key: string]: any}){
+        if (!name){
+            throw new Error("Schema name is not defined");
+        }
+        if (this.schemas[name]){
+            throw new Error("Schema="+name+" is not unique!");
+        }
+        this.schemas[name] = props;
+    }
+
+    _addRoute(name: string, props:{ [key: string]: any}){
+        if (!name){
+            throw new Error("Route name is not defined");
+        }
+        const schemaName: string = props.schema || 'default';
+        const schema = this.schemas[schemaName] || {};
+        // pass router data to inner routes
+        const {children, data, ...routerProps}  = this.props;
+        const routeProps = Object.assign({}, data, schema, props);
+
+        if (this.routes[name]){
+            throw new Error("Route="+name+" is not unique!");
+        }
+
+        this.routes[name] = new Route(routeProps, this);
+
+    }
+
+    _addActions(){
+        if (!Actions.currentRouter){
+            Actions.currentRouter = this;
+        }
+        Object.keys(this.routes).forEach(name=>{
+            if (!Actions[name]){
+                Actions[name] = function(data){
+                    return Actions.route(name, data);
+                }
+            }
+        });
+    }
+
+    route(name: string, props:{ [key: string]: any} = {}){
+        if (!this.routes[name]){
+            throw new Error("No route is defined for name="+name);
+        }
+        const action = this.routes[name].type === "switch" ? "jump": this.routes[name].type;
+        if (!action){
+            throw new Error("No type is defined for name="+name);
+        }
+        if (!this["_"+action]){
+            throw new Error("No type="+action+" is supported");
+        }
+
+        const handler = "on"+capitalizeFirstLetter(action);
+        if (this.delegate[handler]) {
+            console.log("Run handler "+handler);
+            const res:boolean = this.delegate[handler](this.routes[name], props);
+            if (!res) {
+                console.log("Ignore push, handler returns false");
+                return false;
+            }
+        } else {
+            throw new Error("No handler "+handler+" for route="+name);
+        }
+        this["_"+action](name, props);
+        return true;
+    }
+
+    _push(name:string, props:{ [key: string]: any} ){
+        this._stack.push(name);
+    }
+
+    _replace(name:string, props:{ [key: string]: any} ) {
+        this._stack[this._stack.length - 1] = name;
+    }
+
+    _jump(name:string, props:{ [key: string]: any} ) {
+        if (this._stack.indexOf(name) != -1){
+            const pos = this._stack.indexOf(name);
+            // swap latest with found element (because currentRoute always points to latest)
+            this._stack[pos] = this._stack[this._stack.length - 1];
+            this._stack[this._stack.length - 1] = name;
+        } else {
+            this._stack.push(name);
+        }
+    }
+
+    pop(num: number = 1){
+        if (this._stack.length <= num){
+            throw new Error("Cannot pop(), stack=["+this._stack+"]");
+        }
+        if (this.delegate.onPop && this.delegate.onPop(num)){
+            const routes = this._stack.splice(-num, num);
+            return true;
+        }
+        return false;
+    }
+}
+
+function capitalizeFirstLetter(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
\ No newline at end of file
diff --git a/RouterIOS.js b/RouterIOS.js
new file mode 100644
index 000000000..1eae6a6fd
--- /dev/null
+++ b/RouterIOS.js
@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2015-present, Pavel Aksonov
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import React from 'react-native';
+import Router from './Router';
+import Route from './Route';
+import * as Components from './Common';
+import ExNavigator from '@exponent/react-native-navigator';
+import Animations from './Animations';
+const {TouchableOpacity, NavigatorIOS, StyleSheet, View, Text} = React;
+import ReactRouter from './ReactRouter';
+
+class RouteIOS extends React.Component {
+    constructor(props){
+        super(props);
+        this.route = this.props.route;
+    }
+    render(){
+        const Component = this.route.component;
+        const child = Component ?
+            !this.route.wrapRouter ? <Component key={this.route.name} name={this.route.name} {...this.route.props} {...this.props} route={this.route}/>:
+                <ReactRouter name={this.route.name+"Router"} {...this.route.props} {...this.props} route={this.route} router={RouterIOS} >
+                    <Components.Route {...this.route.props}  {...this.props} component={Component} name={"_"+this.route.name} type="push" wrapRouter={false}/>
+                </ReactRouter>
+            :
+            React.cloneElement(React.Children.only(this.route.children), {...this.route.props, data:this.props, route:this.route});
+
+        if (!child){
+            throw new Error("Cannot render route="+this.route.name);
+        }
+        return child;
+    }
+}
+export default class RouterIOS extends React.Component {
+    router: Router;
+
+    constructor(props){
+        super(props);
+        this.onPop = this.onPop.bind(this);
+        this.onPush = this.onPush.bind(this);
+        this.onReplace = this.onReplace.bind(this);
+        this.onJump = this.onJump.bind(this);
+    }
+
+    onPush(route: Route, props:{ [key: string]: any}):boolean {
+        this.refs.nav.push({...route, component:RouteIOS, passProps:{...props, route: route}});
+        return true;
+    }
+
+    onReplace(route: Route, props:{ [key: string]: any}):boolean {
+        this.refs.nav.replace({...route, component:RouteIOS, passProps:{...props, route: route}});
+        return true;
+    }
+
+    onJump(route: Route, props:{ [key: string]: any}):boolean {
+        const navigator = this.refs.nav;
+        const routes = navigator.getCurrentRoutes();
+        const exist = routes.filter(el=>el.getName()==route.name);
+        if (exist.length){
+            navigator.jumpTo(exist[0]);
+        } else {
+            navigator.push({...route, component:RouteIOS, passProps:{...props, route: route}});
+
+        }
+        this.setState({selected: route.name});
+        return true;
+    }
+
+    onPop(num: number){
+        this.refs.nav.pop();
+        return true;
+    }
+
+    render() {
+        const router = this.props.router;
+        const Header = this.props.header;
+        const header = Header ? <Header {...this.props} {...this.state}/> : null;
+
+        const Footer = this.props.footer;
+        const footer = Footer ? <Footer {...this.props} {...this.state}/> : null;
+
+        return (
+                <NavigatorIOS ref="nav" initialRoute={router.currentRoute}
+                             style={styles.transparent}
+                             sceneStyle={{ paddingTop: 0 }}
+                              navigationBarHidden={this.props.hideNavBar}
+                    {...this.props}
+                />
+        );
+    }
+
+
+}
+
+
+var styles = StyleSheet.create({
+    container: {
+        position: 'absolute',
+        top:0,
+        bottom:0,
+        left:0,
+        right:0,
+        backgroundColor:'transparent',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    transparent: {
+        flex:1,
+        backgroundColor: "transparent"
+    },
+    barTitleText: {
+        fontFamily: '.HelveticaNeueInterface-MediumP4',
+        fontSize: 17,
+        marginTop: 11,
+    },
+
+});
+
diff --git a/TabBar.js b/TabBar.js
new file mode 100644
index 000000000..dfcef38b3
--- /dev/null
+++ b/TabBar.js
@@ -0,0 +1,68 @@
+import React from 'react-native'
+const {View, InteractionManager} = React;
+import Tabs from 'react-native-tabs';
+
+import Actions from './Actions';
+export default class TabBar extends React.Component {
+    constructor(props){
+        super(props);
+    }
+    onSelect(el){
+        if (!Actions[el.props.name]){
+            throw new Error("No action is defined for name="+el.props.name+" actions:"+JSON.stringify(Object.keys(Actions)));
+        }
+        Actions[el.props.name](el.props);
+        InteractionManager.runAfterInteractions(() =>
+            this.setState({hideTabBar: el.props.hideTabBar}));
+        return {selected: true};
+    }
+    getChildrenState(selectedRoute){
+        var self = this;
+        let selected = false;
+        var children = [];
+        React.Children.forEach(this.props.children, function(el, index){
+            const schema = self.props.router && self.props.router.schemas[el.props.schema] ? self.props.router.schemas[el.props.schema] : {};
+            let props = {...schema, ...el.props};
+            if (!el.props.name)
+                console.error("No name is defined for element");
+            if (selectedRoute){
+                if (selectedRoute == el.props.name){
+                    props.selected = true;
+                } else {
+                    props.selected = false;
+                }
+            }
+
+            var Icon = props.icon || console.error("No icon class is defined for "+el.name);
+            children.push(<Icon key={el.props.name} {...props}/>);
+            if (props.selected || index === 0){
+                selected = el;
+            }
+        });
+        return {children, hideTabBar: selected.props.hideTabBar};
+    }
+    componentWillMount(){
+        if (!this.props.children){
+            return;
+        }
+        this.state = this.getChildrenState(this.props.selected);
+
+    }
+
+    componentWillReceiveProps({selected}){
+        //console.log("TABBAR "+selected);
+        InteractionManager.runAfterInteractions(() =>
+            this.setState(this.getChildrenState(selected)));
+    }
+    render(){
+        if (this.state.hideTabBar){
+            return <View/>
+        }
+        return (
+            <Tabs style={{backgroundColor:'white'}} onSelect={this.onSelect.bind(this)} {...this.props}>
+                {this.state.children}
+            </Tabs>
+        );
+    }
+}
+
diff --git a/index.js b/index.js
index 555497ebf..56579ac3d 100644
--- a/index.js
+++ b/index.js
@@ -1,586 +1,6 @@
-/**
- * Copyright (c) 2015-present, Pavel Aksonov
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
+import {Schema, Route} from './Common';
+import TabBar from './TabBar';
+import Actions from './Actions';
+import Router from './ReactRouter';
 
-import React from 'react-native';
-const {View, Navigator, Text, StyleSheet, TouchableOpacity, InteractionManager} = React;
-import ExNavigator from '@exponent/react-native-navigator';
-import Animations from './Animations';
-import Tabs from 'react-native-tabs';
-function filterParam(data){
-    if (typeof(data)!='object')
-        return data;
-    if (!data){
-        return;
-    }
-    var proto = (data||{}).constructor.name;
-    // avoid passing React Native parameters
-    if (proto != 'Object'){
-        data = {};
-    }
-    if (data.data){
-        data.data = filterParam(data.data);
-    }
-    return data;
-}
-
-function isNumeric(n){
-    return !isNaN(parseFloat(n)) && isFinite(n);
-}
-
-/***
- * Class represents navigation 'actions' (push, pop, replace, switch) and also allows to add custom actions
- */
-class ActionContainer {
-    constructor(){
-        this.onPush = null;
-        this.onPop = null;
-        this.onReplace = null;
-        this.onSwitch = null;
-        this.navs = {};
-        this.push = this.push.bind(this);
-        this.pop = this.pop.bind(this);
-        this.replace = this.replace.bind(this);
-        this.currentRoute = null;
-        this.navsParent = {};
-    }
-
-    onDidFocus(name, isLeaf) {
-        let routeName = name;
-        while (this.navsParent[routeName]) {
-            //console.log("GETTING LATEST SCENE FOR " + name);
-            const routes = this.navsParent[routeName].getCurrentRoutes();
-            routeName = routes[routes.length - 1].getName();
-        }
-
-        //console.log("SETTING CURRENT ROUTE TO "+routeName);
-        this.currentRoute = routeName;
-    }
-
-    /***
-     * Sets navigator instance for action with given name
-     * @param name action name
-     * @param nav navigator instance
-     */
-    setNavigator(name, nav){
-        //console.log("SETTING NAV "+nav.props._parent+" TO NAME="+name);
-        this.navs[name] = nav;
-        this.navsParent[nav.props._parent || 'root'] = nav;
-    }
-
-    /**
-     * Add new action with given name, props and schemas
-     * @param name action name
-     * @param props route props
-     * @param schemas route schemas
-     */
-    addAction(name, props, schemas, router){
-        if (!name) {
-            throw Error("No name is defined for the router");
-        }
-        if (!props) {
-            throw Error("No props is defined for the route=" + name);
-        }
-        const self = this;
-        this[name] = function(data) {
-            if (typeof(data) != 'object') {
-                data = {data: data};
-            }
-            data = filterParam(data);
-            const route = new ExRoute({...props, ...data, name}, schemas);
-            var action = route.getType();
-            if (!self[action]){
-                throw Error("No action="+action+" exist for route="+route.getName());
-            }
-            self[action](route, router);
-
-        }
-    }
-
-    isFocused(navigator){
-        // get current route
-        const routes = navigator.getCurrentRoutes();
-        const curRoute = routes[routes.length - 1];
-        return curRoute.focused;
-    }
-
-    /***
-     * Push new route to current nav stack
-     * @param route defined route
-     */
-    push(route){
-        const name = route.getName();
-        let navigator = this.navs[name];
-        //console.log("PUSH TO"+name+" "+route.isLeaf());
-        // if route is leaf, push it from latest route navigator, not from root navigator
-        if (route.isLeaf()){
-            navigator = this.navs[this.currentRoute];
-            this.navs[name] = navigator;// save it for future pop()
-
-        }
-
-        if (!this.isFocused(navigator)){
-            return;
-        }
-
-        if (this.onPush){
-            // don't do action if it is not allowed (onPush returned false)
-            if (!this.onPush(navigator, route)){
-                return;
-            }
-        }
-        if (route.onEnter){
-            if (!route.onEnter(route)){
-                return;
-            }
-        }
-
-        navigator.push(route);
-    }
-
-    /***
-     * Replace current route with defined route
-     * @param route defined route
-     */
-    replace(route){
-        const name = route.getName();
-        let navigator = this.navs[name];
-        // if route is leaf, push it from latest route navigator, not from root navigator
-        if (route.isLeaf()){
-            navigator = this.navs[this.currentRoute];
-            this.navs[name] = navigator;// save it for future pop()
-        }
-
-        if (!this.isFocused(navigator)){
-            return;
-        }
-
-        if (this.onReplace){
-            // don't do action if it is not allowed (onReplace returned false)
-            if (!this.onReplace(navigator, route)){
-                return;
-            }
-        }
-        navigator.replace(route);
-    }
-
-    /***
-     * Switch to defined route (so it will jump to existing route if it exists within nav stack or push otherwise), usable for tab bar.
-     * @param route defined route
-     */
-    switch(route, router){
-        const name = route.getName();
-        const navigator = this.navs[name];
-
-        if (this.onSwitch){
-            // don't do action if it is not allowed (onSwitch returned false)
-            if (!this.onSwitch(navigator, route)){
-                return;
-            }
-        }
-        if (router && router.onSwitch){
-            router.onSwitch(route);
-        }
-
-        const routes = navigator.getCurrentRoutes();
-        const exist = routes.filter(el=>el.getName()==route.getName());
-        if (exist.length){
-            navigator.jumpTo(exist[0]);
-        } else {
-            navigator.push(route);
-
-        }
-    }
-
-    /***
-     * Pop current scene from navigator, data could be number indicates number of screens to pop
-     * @param data
-     */
-    pop(data){
-        data = filterParam(data);
-        const number = isNumeric(data) ? data : 1;
-        let navigator = this.navs[this.currentRoute];
-        //console.log("LATEST NAV:"+this.navs[this.currentRoute].props._parent);
-        let routes = navigator.getCurrentRoutes();
-        //console.log("NAV LATEST SCENE:"+routes[routes.length-1].getName()+" "+routes.length);
-        while (routes.length <= number || routes[routes.length-1].getType() === 'switch'){
-            // try parent navigator if we cannot pop current one
-            if (navigator.parentNavigator){
-                //console.log("pop to parent navigator");
-                navigator = navigator.parentNavigator;
-                routes = navigator.getCurrentRoutes();
-            } else {
-                throw new Error("Cannot pop navigator with less than "+number+" screens");
-            }
-        }
-        const route = routes[routes.length-number-1];
-        if (this.onPop){
-            // don't do action if it is not allowed (onPop returned false)
-            if (!this.onPop(navigator, route)){
-                return;
-            }
-        }
-        const name = route.getName();// name of route
-        navigator.popToRoute(routes[routes.length-number-1]);
-    }
-}
-
-const Actions = new ActionContainer();
-class Container extends React.Component {
-    render(){
-        return <View {...this.props}/>;
-    }
-}
-class ExRoute {
-    /**
-     * All properties for this route. name field is required and should be unique for the route
-     * 'title' represents title
-     *
-     * @param name
-     * @param title
-     * @param onRightButton
-     * @param rightButtonTitle
-     * @param header
-     * @param footer
-     * @param component
-     * @param child
-     * @param props
-     * @param schemas
-     */
-    constructor(props, schemas) {
-        if (!props) {
-            throw new Error("No props is defined for this Route");
-        }
-        if (!props.name) {
-            throw new Error("No name is defined for this Route");
-        }
-        if (props.schema && (!schemas || !schemas[props.schema])) {
-            throw new Error("No schema=" + props.schema + " is defined for route=" + props.name);
-        }
-        const schema = schemas ? schemas[props.schema || 'default'] || {} : {};
-        const {name, type, title, hideNavBar, navigationBarStyle, backButtonStyle, rightButtonStyle, rightButtonTextStyle,
-            onEnter, onLeave, wrapRouter, sceneConfig, renderLeftButton, renderTitle,
-            onRight, rightTitle, header, renderRightButton, renderBackButton, footer, component, children} = {...schema, ...props};
-        if (!component && !children) {
-            throw new Error("Component class or scene instance (child) should be passed");
-        }
-        this.title = title;
-        this.onRight = onRight;
-        this.rightTitle = rightTitle;
-        this.sceneConfig = sceneConfig;
-        this.wrapRouter = wrapRouter;
-        this.props = props;
-        this.type = type;
-        this.focused = false;
-        this.name = name;
-        this.header = header;
-        this.footer = footer;
-        this.hideNavBar = hideNavBar;
-        this.schemas = schemas;
-        this.component = component;
-        this.children = children;
-        this.onEnter = onEnter;
-        this.onLeave = onLeave;
-        this.backButtonStyle = backButtonStyle;
-        this.rightButtonStyle = rightButtonStyle;
-        this.rightButtonTextStyle = rightButtonTextStyle;
-        this.navigationBarStyle = navigationBarStyle;
-        if (renderRightButton){
-            this.renderRightButton = renderRightButton.bind(this, this);
-        }
-        if (renderBackButton){
-            this.renderBackButton = renderBackButton.bind(this, this);
-        }
-        if (renderLeftButton){
-            this.renderLeftButton = renderLeftButton.bind(this, this);
-        }
-        if (renderTitle){
-            this.renderTitle = renderTitle.bind(this, this);
-        }
-        this.leaf = this.component && !(this.getType() === 'switch' || this.wrapRouter);
-    }
-
-    onDidFocus(event){
-        this.focused = true;
-//        console.log("FOCUS "+this.getName());
-        Actions.onDidFocus(this.getName(), this.isLeaf());
-    }
-
-    onWillBlur(event){
-        this.focused = false;
-        if (this.onLeave){
-            this.onLeave(this, event);
-        }
-        //console.log("LOSE FOCUS!"+this.getName());
-    }
-
-    isLeaf(){
-        return this.leaf;
-    }
-
-    configureScene() {
-        return this.getType() === 'switch' ? Animations.None : this.sceneConfig || Animations.None;
-    }
-
-    renderScene(navigator) {
-        const Component = this.component;
-        const Header = this.header;
-        const Footer = this.footer;
-        let child;
-        if (Component){
-            // separate processing for 'switch' routes - they should be wrapped into separate Router
-            if (!this.isLeaf()){
-                child = (<Router _parent={this.props.name} {...this.props} navigator={navigator} schemas={this.schemas} >
-                    <Route {...this.props} name={"_"+this.props.name} type="push" wrapRouter={false}/>
-                </Router>);
-            } else {
-                child = <Component key={this.name} {...this.props} navigator={navigator} schemas={this.schemas} _parent={this.props.name}/>
-                this.leaf = true;
-            }
-        } else {
-            child = React.Children.only(this.children);
-            child = React.cloneElement(child, {navigator, schemas: this.schemas, _parent:this.props.name});
-        }
-        return (
-            <Container style={styles.transparent} route={this.getName()}>
-                {Header && <Header navigator={navigator} {...this.props}/>}
-                {child}
-                {Footer && <Footer navigator={navigator} {...this.props}/>}
-            </Container>
-        )
-    }
-
-    getName(){
-        return this.name;
-    }
-
-    getTitle() {
-        return this.title || "";
-    }
-
-    getType() {
-        return this.type || "push";
-    }
-
-    getBackButtonTitle(navigator, index, state){
-        let previousIndex = index - 1;
-        let previousRoute = state.routeStack[previousIndex];
-        let title = previousRoute.getTitle(navigator, previousIndex, state);
-        return title.length>10 ? null : title;
-    }
-
-    renderRightButton() {
-        if (this.onRight && this.rightTitle){
-            return (<TouchableOpacity
-                touchRetentionOffset={ExNavigator.Styles.barButtonTouchRetentionOffset}
-                onPress={() => this.onRight(this.props)}
-                style={[ExNavigator.Styles.barRightButton, this.rightButtonStyle]}>
-                <Text style={[ExNavigator.Styles.barRightButtonText, this.rightButtonTextStyle]}>{this.rightTitle}</Text>
-            </TouchableOpacity>);
-        } else {
-            return null;
-        }
-    }
-}
-
-class TabBar extends React.Component {
-    constructor(props){
-        super(props);
-    }
-    onSelect(el){
-        if (!Actions[el.props.name]){
-            throw new Error("No action is defined for name="+el.props.name+" actions:"+JSON.stringify(Object.keys(Actions)));
-        }
-        Actions[el.props.name](el.props);
-        InteractionManager.runAfterInteractions(() =>
-                        this.setState({hideTabBar: el.props.hideTabBar}));
-        return {selected: true};
-    }
-    getChildrenState(selectedRoute){
-        var self = this;
-        let selected = false;
-        var children = [];
-        React.Children.forEach(this.props.children, function(el, index){
-            const schema = self.props.schemas && el.props.schema && self.props.schemas[el.props.schema] ? self.props.schemas[el.props.schema] : {};
-            let props = {...schema, ...el.props};
-            if (!el.props.name)
-                console.error("No name is defined for element");
-            if (selectedRoute){
-                if (selectedRoute == el.props.name){
-                    props.selected = true;
-                } else {
-                    props.selected = false;
-                }
-            }
-
-            var Icon = props.icon || console.error("No icon class is defined for "+el.name);
-            children.push(<Icon key={el.props.name} {...props}/>);
-            if (props.selected || index === 0){
-                selected = el;
-            }
-        });
-        return {children, hideTabBar: selected.props.hideTabBar};
-    }
-    componentWillMount(){
-        if (!this.props.children){
-            return;
-        }
-        this.state = this.getChildrenState(this.props.selected);
-
-    }
-
-    componentWillReceiveProps({selected}){
-        //console.log("TABBAR "+selected);
-        InteractionManager.runAfterInteractions(() =>
-            this.setState(this.getChildrenState(selected)));
-    }
-    render(){
-        if (this.state.hideTabBar){
-            return <View/>
-        }
-        return (
-            <Tabs style={{backgroundColor:'white'}} onSelect={this.onSelect.bind(this)} {...this.props}>
-                {this.state.children}
-            </Tabs>
-        );
-    }
-}
-
-
-
-// schema class represents schema for routes and it is processed inside Router component
-class Schema extends React.Component {
-    className(){
-        return "Schema";
-    }
-    render(){
-        return null;
-    }
-}
-
-// route class processed inside Router component
-class Route extends React.Component {
-    className(){
-        return "Route";
-    }
-    render(){
-        return null;
-    }
-
-}
-
-class Router extends React.Component {
-    constructor(props) {
-        super(props);
-        this.routes = {};
-        this.schemas = {...props.schemas};
-        this.initial = this.props.initialRoutes || []; // Initial names array
-
-        const self = this;
-        React.Children.forEach(this.props.children, function (child, index) {
-            const name = child.props.name;
-            if (child.type.prototype.className() === "Schema") {
-                self.schemas[name] = child.props;
-            }
-        });
-        this.first = null;
-        React.Children.forEach(this.props.children, function (child, index) {
-            const name = child.props.name;
-            if (child.type.prototype.className() === "Route") {
-                if (!self.first){
-                    self.first = name;
-                }
-                if (child.props.initial) {
-                    self.initial.push(name);
-                }
-                // declare function with null navigator to avoid undefined Actions
-                Actions.addAction(name, child.props, self.schemas, self)
-                self.routes[name] = child.props;
-            }
-        });
-        // add first route as initial if no initial attribute set
-        if (!this.initial.length && this.first){
-            this.initial.push(this.first);
-        }
-        this.state = {initial: this.initial};
-    }
-
-    onSwitch(route){
-        //console.log("SWITCHED TO"+route.getName());
-        this.setState({selected: route.getName()});
-    }
-
-    componentDidMount() {
-        const self = this;
-        React.Children.forEach(this.props.children, function (child, index) {
-            const name = child.props.name;
-            if (child.type.prototype.className() === "Route") {
-                    Actions.setNavigator(name, self.refs.nav);
-
-            }
-        });
-    }
-
-    render(){
-        if (!this.state.initial.length){
-            console.error("No initial attribute!");
-        }
-        const initialRoutes =  this.state.initial.map((name) => this.routes[name]);
-        if (!initialRoutes.length) {
-            console.error("No initial routes!"+JSON.stringify(this.routes));
-        }
-
-        const Header = this.props.header;
-        const header = Header ? <Header {...this.props} {...this.state}/> : null;
-
-        const Footer = this.props.footer;
-        const footer = Footer ? <Footer {...this.props} {...this.state}/> : null;
-
-        return (
-            <View style={styles.transparent}>
-                {header}
-                <ExNavigator ref="nav"
-                             initialRouteStack={initialRoutes.map((route) => new ExRoute(route, this.schemas))}
-                             style={styles.transparent}
-                             sceneStyle={{ paddingTop: 0 }}
-                             showNavigationBar={!this.props.hideNavBar}
-                    {...this.props}
-
-                />
-                {footer}
-            </View>
-        );
-
-    }
-
-}
-
-var styles = StyleSheet.create({
-    container: {
-        position: 'absolute',
-        top:0,
-        bottom:0,
-        left:0,
-        right:0,
-        backgroundColor:'transparent',
-        justifyContent: 'center',
-        alignItems: 'center',
-    },
-    transparent: {
-        flex:1,
-        backgroundColor: "transparent"
-    },
-    barTitleText: {
-        fontFamily: '.HelveticaNeueInterface-MediumP4',
-        fontSize: 17,
-        marginTop: 11,
-    },
-
-});
-
-module.exports = {Router, Actions, Route, Schema, TabBar, ExNavigator, Animations}
+module.exports = {Schema, Route, TabBar, Actions, Router};
\ No newline at end of file