@react-navigation/native

const DarkTheme: NativeTheme;

const DefaultTheme: NativeTheme;

const LinkingContext: React.Context<{ options?: LinkingOptions<ParamListBase> }>;

const LocaleDirContext: React.Context<LocaleDirection>;

const ServerContainer: React.ForwardRefExoticComponent<any>;

const UNSTABLE_UnhandledLinkingContext: React.Context<{
    lastUnhandledLink: string | undefined;
    setLastUnhandledLink: (lastUnhandledUrl: string | undefined) => void;
}>;

createStaticNavigation: (
    tree: StaticNavigation<any, any, any>
) => React.ForwardRefExoticComponent<any>;

Link: <ParamList extends ReactNavigation.RootParamList>({
    screen,
    params,
    action,
    href,
    style,
    ...rest
}: Props<ParamList>) => React.CElement<TextProps, Text>;

NavigationContainer: <RootParamList extends {} = ReactNavigation.RootParamList>(
    props: any
) => React.ReactElement;

useLinkBuilder: () => {
    buildHref: (name: string, params?: object) => string | undefined;
    buildAction: (
        href: string
    ) =>
        | {
              type: 'NAVIGATE';
              payload: {
                  name: string;
                  params?: import('@react-navigation/core').NavigatorScreenParams<
                      Readonly<{
                          key: string;
                          index: number;
                          routeNames: string[];
                          history?: unknown[];
                          routes: import('@react-navigation/routers').NavigationRoute<
                              import('@react-navigation/routers').ParamListBase,
                              string
                          >[];
                          type: string;
                          stale: false;
                      }>
                  >;
                  path?: string;
              };
          }
        | CommonActions.Action;
};

useLinkProps: <ParamList extends ReactNavigation.RootParamList>({
    screen,
    params,
    href,
    action,
}: LinkProps<ParamList>) => {
    href: string | undefined;
    role: 'link';
    onPress: (
        e?: React.MouseEvent<HTMLAnchorElement, MouseEvent> | GestureResponderEvent
    ) => void;
};

useLinkTo: () => (href: string) => void;

useLocale: () => { direction: import('./types').LocaleDirection };

useScrollToTop: (ref: React.RefObject<ScrollableWrapper>) => void;

type DocumentTitleOptions = {
    enabled?: boolean;
    formatter?: (
        options: Record<string, any> | undefined,
        route: Route<string> | undefined
    ) => string;
};

type LinkingOptions<ParamList extends {}> = {
    /**
     * Whether deep link handling should be enabled.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * The prefixes are stripped from the URL before parsing them.
     * Usually they are the `scheme` + `host` (e.g. `myapp://chat?user=jane`)
     *
     * This is not supported on Web.
     *
     * @example
     * ```js
     * {
     *    prefixes: [
     *      "myapp://", // App-specific scheme
     *      "https://example.com", // Prefix for universal links
     *      "https://*.example.com" // Prefix which matches any subdomain
     *    ]
     * }
     * ```
     */
    prefixes: string[];
    /**
     * Optional function which takes an incoming URL returns a boolean
     * indicating whether React Navigation should handle it.
     *
     * This can be used to disable deep linking for specific URLs.
     * e.g. URLs used for authentication, and not for deep linking to screens.
     *
     * This is not supported on Web.
     *
     * @example
     * ```js
     * {
     *   // Filter out URLs used by expo-auth-session
     *   filter: (url) => !url.includes('+expo-auth-session')
     * }
     * ```
     */
    filter?: (url: string) => boolean;
    /**
     * Config to fine-tune how to parse the path.
     *
     * @example
     * ```js
     * {
     *   Chat: {
     *     path: 'chat/:author/:id',
     *     parse: { id: Number }
     *   }
     * }
     * ```
     */
    config?: {
        /**
         * Path string to match against for the whole navigation tree.
         * It's not possible to specify params here since this doesn't belong to a screen.
         * This is useful when the whole app is under a specific path.
         * e.g. all of the screens are under `/admin` in `https://example.com/admin`
         */
        path?: string;
        /**
         * Path configuration for child screens.
         */
        screens: PathConfigMap<ParamList>;
        /**
         * Name of the initial route to use for the root navigator.
         */
        initialRouteName?: keyof ParamList;
    };
    /**
     * Custom function to get the initial URL used for linking.
     * Uses `Linking.getInitialURL()` by default.
     *
     * This is not supported on Web.
     *
     * @example
     * ```js
     * {
     *    getInitialURL () => Linking.getInitialURL(),
     * }
     * ```
     */
    getInitialURL?: () =>
        | string
        | null
        | undefined
        | Promise<string | null | undefined>;
    /**
     * Custom function to get subscribe to URL updates.
     * Uses `Linking.addEventListener('url', callback)` by default.
     *
     * This is not supported on Web.
     *
     * @example
     * ```js
     * {
     *    subscribe: (listener) => {
     *      const onReceiveURL = ({ url }) => listener(url);
     *
     *      Linking.addEventListener('url', onReceiveURL);
     *
     *      return () => Linking.removeEventListener('url', onReceiveURL);
     *   }
     * }
     * ```
     */
    subscribe?: (listener: (url: string) => void) => undefined | void | (() => void);
    /**
     * Custom function to parse the URL to a valid navigation state (advanced).
     */
    getStateFromPath?: typeof getStateFromPathDefault;
    /**
     * Custom function to convert the state object to a valid URL (advanced).
     * Only applicable on Web.
     */
    getPathFromState?: typeof getPathFromStateDefault;
    /**
     * Custom function to convert the state object to a valid action (advanced).
     */
    getActionFromState?: typeof getActionFromStateDefault;
};

type LinkProps<
    ParamList extends ReactNavigation.RootParamList,
    RouteName extends keyof ParamList = keyof ParamList
> =
    | ({
          href?: string;
          action?: NavigationAction;
      } & (RouteName extends unknown
          ? undefined extends ParamList[RouteName]
              ? {
                    screen: RouteName;
                    params?: ParamList[RouteName];
                }
              : {
                    screen: RouteName;
                    params: ParamList[RouteName];
                }
          : never))
    | {
          href?: string;
          action: NavigationAction;
          screen?: undefined;
          params?: undefined;
      };

type LocaleDirection = 'ltr' | 'rtl';

type ServerContainerRef = {
    getCurrentOptions(): Record<string, any> | undefined;
};

type Theme = NativeTheme;