@ohos-ports/react-native-navigation 8.9.0-beta.0

package/lib/typescript/typescript/Mock/Components/ComponentScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentScreen.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/ComponentScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAGzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAanD,eAAO,MAAM,eAAe;gBAEL,cAAc;;qBAQpB,OAAO;;;;;;;;;;;;;;;;;;;;;;CAgFvB,CAAC"}

package/lib/typescript/typescript/Mock/Components/LayoutComponent.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const LayoutComponent: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=LayoutComponent.d.ts.map

package/lib/typescript/typescript/Mock/Components/LayoutComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutComponent.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/LayoutComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAGzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKnD,eAAO,MAAM,eAAe;;;iCAqBD,KAAK,aAAa,KAAK,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;iCAAjC,KAAK,aAAa,KAAK,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;CAO3D,CAAC"}

package/lib/typescript/typescript/Mock/Components/Modals.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const Modals: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=Modals.d.ts.map

package/lib/typescript/typescript/Mock/Components/Modals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Modals.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/Modals.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAMnD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAalB,CAAC"}

package/lib/typescript/typescript/Mock/Components/NavigationButton.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+import { OptionsTopBarButton } from 'react-native-navigation';
+interface ButtonProps {
+    button: OptionsTopBarButton;
+    componentId: string;
+}
+export declare const NavigationButton: {
+    new (props: ButtonProps): {
+        ref: undefined;
+        render(): React.JSX.Element;
+        renderButtonComponent(): React.JSX.Element;
+        invokeOnClick(stateNode: any): void;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ButtonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ButtonProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ButtonProps, context: any): {
+        ref: undefined;
+        render(): React.JSX.Element;
+        renderButtonComponent(): React.JSX.Element;
+        invokeOnClick(stateNode: any): void;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ButtonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ButtonProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+export {};
+//# sourceMappingURL=NavigationButton.d.ts.map

package/lib/typescript/typescript/Mock/Components/NavigationButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationButton.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/NavigationButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,OAAO,EAAc,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAG1E,UAAU,WAAW;IACnB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,gBAAgB;;;;;iCA4DF,GAAG;;;;;;;;;;;;;;;;;;;;;;;iCAAH,GAAG;;;;;;;;;;;;;;;;;;;;;CAe7B,CAAC"}

package/lib/typescript/typescript/Mock/Components/Overlays.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const Overlays: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=Overlays.d.ts.map

package/lib/typescript/typescript/Mock/Components/Overlays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Overlays.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/Overlays.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAOnD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAapB,CAAC"}

package/lib/typescript/typescript/Mock/Components/SideMenu.d.ts

@@ -0,0 +1,179 @@
+import React from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const SideMenuRoot: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+export declare const SideMenuLeft: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+export declare const SideMenuCenter: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+export declare const SideMenuRight: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=SideMenu.d.ts.map

package/lib/typescript/typescript/Mock/Components/SideMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SideMenu.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/SideMenu.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAInD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASxB,CAAC;AASF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC;AAC9C,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC;AAChD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC"}

package/lib/typescript/typescript/Mock/Components/Stack.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { ComponentProps } from '../ComponentProps';
+export declare const Stack: {
+    new (props: ComponentProps): {
+        render(): React.JSX.Element[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: ComponentProps, context: any): {
+        render(): React.JSX.Element[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ComponentProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<ComponentProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=Stack.d.ts.map

package/lib/typescript/typescript/Mock/Components/Stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/Stack.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKnD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASjB,CAAC"}

package/lib/typescript/typescript/Mock/Components/TopBar.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { OptionsTopBar, OptionsTopBarBackButton, OptionsTopBarButton } from 'react-native-navigation';
+import ParentNode from '../Layouts/ParentNode';
+export interface TopBarProps {
+    layoutNode: ParentNode;
+    topBarOptions?: OptionsTopBar;
+    backButtonOptions?: OptionsTopBarBackButton;
+}
+export declare const TopBar: {
+    new (props: TopBarProps): {
+        render(): React.JSX.Element | null;
+        shouldRenderBackButton(layoutNode: ParentNode): boolean;
+        renderButtons(buttons?: OptionsTopBarButton[]): React.JSX.Element[];
+        renderBackButton(): React.JSX.Element;
+        renderComponent(id: string, name: string, testID?: string): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TopBarProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<TopBarProps>;
+        state: Readonly<{}>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<TopBarProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TopBarProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<TopBarProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TopBarProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TopBarProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TopBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TopBarProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};
+//# sourceMappingURL=TopBar.d.ts.map

package/lib/typescript/typescript/Mock/Components/TopBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TopBar.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Components/TopBar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAEzC,OAAO,EAEL,aAAa,EACb,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAO/C,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CAC7C;AAED,eAAO,MAAM,MAAM;gBACE,WAAW;;2CA2BK,UAAU;gCAKtB,mBAAmB,EAAE;;4BAgCxB,MAAM,QAAQ,MAAM,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;CAS1D,CAAC"}

package/lib/typescript/typescript/Mock/Layouts/BottomTabsNode.d.ts

@@ -0,0 +1,9 @@
+import { Options } from '../../index';
+import ParentNode from './ParentNode';
+export default class BottomTabsNode extends ParentNode {
+    selectedIndex: number;
+    constructor(layout: any, parentNode?: ParentNode);
+    mergeOptions(_options: Options): void;
+    getVisibleLayout(): import("./ComponentNode").default;
+}
+//# sourceMappingURL=BottomTabsNode.d.ts.map

package/lib/typescript/typescript/Mock/Layouts/BottomTabsNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BottomTabsNode.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Layouts/BottomTabsNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU;IACpD,aAAa,EAAE,MAAM,CAAC;gBACV,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,UAAU;IAKhD,YAAY,CAAC,QAAQ,EAAE,OAAO;IAkB9B,gBAAgB;CAGjB"}

package/lib/typescript/typescript/Mock/Layouts/ComponentNode.d.ts

@@ -0,0 +1,16 @@
+import { OptionsTopBarButton } from '../../index';
+import ParentNode from './ParentNode';
+export default class ComponentNode extends ParentNode {
+    componentDidMountOnce: boolean;
+    componentDidAppearPending: boolean;
+    constructor(layout: any, parentNode?: ParentNode);
+    componentDidMount(): void;
+    componentDidAppear(): void;
+    componentDidDisappear(): void;
+    titleChanged(oldTitle: any, newTitle?: any): void;
+    buttonsChanged(oldButtons: OptionsTopBarButton[], newButtons: OptionsTopBarButton[]): void;
+    buttonsDidAppear(buttons?: OptionsTopBarButton[]): void;
+    buttonsDidDisappear(buttons?: OptionsTopBarButton[]): void;
+    getVisibleLayout(): this;
+}
+//# sourceMappingURL=ComponentNode.d.ts.map

package/lib/typescript/typescript/Mock/Layouts/ComponentNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentNode.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Layouts/ComponentNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU;IACnD,qBAAqB,UAAS;IAC9B,yBAAyB,UAAS;gBAEtB,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,UAAU;IAIzC,iBAAiB;IAKjB,kBAAkB;IAyBlB,qBAAqB;IAgB5B,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG;IAuB1C,cAAc,CAAC,UAAU,EAAE,mBAAmB,EAAE,EAAE,UAAU,EAAE,mBAAmB,EAAE;IAKnF,gBAAgB,CAAC,OAAO,GAAE,mBAAmB,EAAO;IAoBpD,mBAAmB,CAAC,OAAO,GAAE,mBAAmB,EAAO;IAavD,gBAAgB;CAGjB"}

package/lib/typescript/typescript/Mock/Layouts/LayoutNodeFactory.d.ts

@@ -0,0 +1,9 @@
+import BottomTabs from './BottomTabsNode';
+import ComponentNode from './ComponentNode';
+import Stack from './StackNode';
+import ParentNode from './ParentNode';
+import SideMenuRootNode, { SideMenuLeftNode, SideMenuRightNode, SideMenuCenterNode } from './SideMenu';
+export default class LayoutNodeFactory {
+    static create(layout: any, parentNode?: ParentNode): ComponentNode | SideMenuRootNode | SideMenuLeftNode | SideMenuRightNode | SideMenuCenterNode | Stack | BottomTabs;
+}
+//# sourceMappingURL=LayoutNodeFactory.d.ts.map

package/lib/typescript/typescript/Mock/Layouts/LayoutNodeFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutNodeFactory.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Layouts/LayoutNodeFactory.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,gBAAgB,EAAE,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,EAAE,UAAU;CAmBnD"}

package/lib/typescript/typescript/Mock/Layouts/Node.d.ts

@@ -0,0 +1,16 @@
+import { Options } from '../../index';
+import ParentNode from './ParentNode';
+interface Data {
+    name: string;
+    options: Options;
+}
+export type NodeType = 'Component' | 'ExternalComponent' | 'Stack' | 'BottomTabs' | 'TopTabs' | 'SideMenuRoot' | 'SideMenuLeft' | 'SideMenuRight' | 'SideMenuCenter' | 'SplitView';
+export default class Node {
+    readonly nodeId: string;
+    readonly data: Data;
+    readonly type: NodeType;
+    parentNode?: ParentNode;
+    constructor(layout: any, type: NodeType, parentNode?: ParentNode);
+}
+export {};
+//# sourceMappingURL=Node.d.ts.map

package/lib/typescript/typescript/Mock/Layouts/Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Layouts/Node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,QAAQ,GAChB,WAAW,GACX,mBAAmB,GACnB,OAAO,GACP,YAAY,GACZ,SAAS,GACT,cAAc,GACd,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,WAAW,CAAC;AAEhB,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAExB,UAAU,CAAC,EAAE,UAAU,CAAC;gBAEZ,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,UAAU;CAOjE"}

package/lib/typescript/typescript/Mock/Layouts/ParentNode.d.ts

@@ -0,0 +1,21 @@
+import { OptionsTopBarButton } from '../../interfaces/Options';
+import { Options } from '../../index';
+import ComponentNode from './ComponentNode';
+import Node, { NodeType } from './Node';
+export default class ParentNode extends Node {
+    children: ParentNode[];
+    constructor(layout: any, type: NodeType, parentNode?: ParentNode);
+    componentDidMount(): void;
+    componentDidAppear(): void;
+    componentDidDisappear(): void;
+    getVisibleLayout(): ComponentNode;
+    getTopParent(): Node;
+    applyOptions(_options: Options): void;
+    mergeOptions(options: Options): void;
+    buttonsChanged(_oldButtons: OptionsTopBarButton[], _newButtons: OptionsTopBarButton[]): void;
+    titleChanged(_oldComponent: any, _newComponent: any): void;
+    resolveOptions(): Options;
+    getStack(): ParentNode | undefined;
+    getBottomTabs(): ParentNode | undefined;
+}
+//# sourceMappingURL=ParentNode.d.ts.map

package/lib/typescript/typescript/Mock/Layouts/ParentNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParentNode.d.ts","sourceRoot":"","sources":["../../../../src/Mock/Layouts/ParentNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAE5C,OAAO,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAExC,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,IAAI;IAC1C,QAAQ,EAAE,UAAU,EAAE,CAAC;gBAEX,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,UAAU;IAOhE,iBAAiB;IAEjB,kBAAkB;IAIlB,qBAAqB;IAIrB,gBAAgB,IAAI,aAAa;IAIjC,YAAY,IAAI,IAAI;IAKpB,YAAY,CAAC,QAAQ,EAAE,OAAO;IAI9B,YAAY,CAAC,OAAO,EAAE,OAAO;IAgB7B,cAAc,CAAC,WAAW,EAAE,mBAAmB,EAAE,EAAE,WAAW,EAAE,mBAAmB,EAAE;IAErF,YAAY,CAAC,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG;IAEnD,cAAc,IAAI,OAAO;IAKlB,QAAQ,IAAI,UAAU,GAAG,SAAS;IAUlC,aAAa,IAAI,UAAU,GAAG,SAAS;CAS/C"}