import React, { PropsWithChildren } from 'react';
import { BottomTabNavigationOptions } from '@react-navigation/bottom-tabs';
import { NativeStackNavigationOptions } from '@react-navigation/native-stack';
import { NavigationContainer, ParamListBase, RouteProp } from '@react-navigation/native';
import { DrawerNavigationOptions } from '@react-navigation/drawer';
import { NativeStackNavigatorProps } from '@react-navigation/native-stack/lib/typescript/src/types';
export declare type Keys<T> = keyof T;
export declare type ContainerLayoutKeys<T extends {
    layout: any;
}> = Keys<T['layout']>;
export declare type RootSetAs = keyof Pick<Layout, 'stacks' | 'tabs' | 'drawers'>;
export declare type BaseOptionsProps = {
    route?: RouteProp<ParamListBase, string>;
    navigation?: any;
} | undefined;
export declare type BaseOptions<Return = NativeStackNavigationOptions> = Return | ((props?: BaseOptionsProps) => Return);
declare type ScreenOptions = BaseOptions<NativeStackNavigationOptions>;
export declare type StackScreenOptions = ScreenOptions;
export declare type ModalScreenOptions = StackScreenOptions;
export declare type TabScreenOptions = BaseOptions<BottomTabNavigationOptions>;
export declare type DrawerScreenOptions = BaseOptions<DrawerNavigationOptions>;
declare type StackNavigatorProps = Omit<NativeStackNavigatorProps, 'children'>;
declare type TabNavigatorProps = any;
declare type DrawerNavigatorProps = any;
export declare type TStackDefinition<ScreenName, StackName> = StackName | ScreenName[] | TStackDataObj<ScreenName>;
export declare type TDrawerDefinition<DrawerName> = DrawerName;
export declare type TTabsDefinition<TabName> = TabName;
export declare type TModalsDefinition<ModalName> = ModalName;
export declare type TScreenData<Props = {}> = NavioScreen<Props> | {
    component: NavioScreen<Props>;
    options?: ScreenOptions;
};
export declare type TStackDataObj<ScreenName> = {
    screens: ScreenName[];
    options?: StackScreenOptions;
    navigatorProps?: StackNavigatorProps;
};
export declare type TStackData<ScreenName> = ScreenName[] | TStackDataObj<ScreenName>;
export declare type TTabLayoutValue<ScreenName, StackName, DrawersName> = {
    stack?: TStackDefinition<ScreenName, StackName>;
    drawer?: TDrawerDefinition<DrawersName>;
    options?: TabScreenOptions;
};
export declare type TTabsData<ScreenName, StackName, DrawersName> = {
    layout: Record<string, TTabLayoutValue<ScreenName, StackName, DrawersName>>;
    options?: TabScreenOptions;
    navigatorProps?: TabNavigatorProps;
};
export declare type TDrawerLayoutValue<ScreenName, StackName, TabsName> = {
    stack?: TStackDefinition<ScreenName, StackName>;
    tabs?: TTabsDefinition<TabsName>;
    options?: DrawerScreenOptions;
};
export declare type TDrawersData<ScreenName, StackName, TabsName> = {
    layout: Record<string, TDrawerLayoutValue<ScreenName, StackName, TabsName>>;
    options?: DrawerScreenOptions;
    navigatorProps?: DrawerNavigatorProps;
};
export declare type TModalData<ScreenName, StackName> = {
    stack?: TStackDefinition<ScreenName, StackName>;
    options?: ModalScreenOptions;
};
export declare type TRootName<StackName extends string, TabsName extends string, DrawersName extends string> = `tabs.${TabsName}` | `stacks.${StackName}` | `drawers.${DrawersName}`;
export declare type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;
export declare type Layout<Screens = any, Stacks = any, Tabs = any, Modals = any, Drawers = any, RootName = any> = {
    /**
     * `(required)`
     * Screens of the app. Navigate to by using `navio.push('...')` method.
     */
    screens: Screens;
    /**
     * `(optional)`
     * Stacks of the app. Navigate to by using `navio.pushStack('...Stack')` method. Good to use if you want to hide tabs on the specific screens.
     */
    stacks?: Stacks;
    /**
     * `(optional)`
     * Tabs app. Navigate to by using `navio.jumpTo('...Tab')` method.
     */
    tabs?: Tabs;
    /**
     * `(optional)`
     * Modals of the app. Navigate to by using `navio.show('...Modal')` method.
     */
    modals?: Modals;
    /**
     * `(optional)`
     * Drawers of the app. Navigate to by using `navio.drawer.open('...Drawer')` method.
     */
    drawers?: Drawers;
    /**
     * `(optional)`
     * Root name to start the app with. Possible values `any of tabs, stacks, drawers names`.
     */
    root?: RootName;
    /**
     * `(optional)`
     * List of hooks that will be run on each generated stack or tab navigators. Useful for dark mode or language change.
     */
    hooks?: Function[];
    /**
     * `(optional)`
     * Default options to be applied per each stack's, tab's or drawer's screens generated within the app.
     */
    defaultOptions?: DefaultOptions;
};
export declare type DefaultOptions = {
    stacks?: {
        screen?: StackScreenOptions;
        container?: ScreenOptions;
    };
    tabs?: {
        screen?: TabScreenOptions;
        container?: ScreenOptions;
    };
    drawers?: {
        screen?: DrawerScreenOptions;
        container?: ScreenOptions;
    };
    modals?: {
        container?: ScreenOptions;
    };
};
export declare type NavioScreen<Props = {}> = React.FC<PropsWithChildren<Props>> & {
    options?: StackScreenOptions;
};
export declare type RootProps<RootName extends string> = {
    navigationContainerProps?: Omit<ExtractProps<typeof NavigationContainer>, 'children'>;
    root?: RootName;
};
export declare type TunnelEvent$UpdateOptions$Params<Name = string, Options = any> = {
    name: Name;
    options: Options;
};
export declare type TunnelEvent = 'tabs.updateOptions' | 'drawer.updateOptions';
export declare type TunnelParams<T = any> = T;
export declare type TunnelListener = (params: TunnelParams) => void;
export declare type TunnelEvents = Partial<Record<TunnelEvent, TunnelListener[]>>;
export {};