import type { Component, View } from "ilha";
import type { SerializedHead } from "./head";
import type { HttpResponseOptions } from "./http";
export { setHistoryMode, getHistoryMode } from "./hash";
export type { HistoryMode } from "./hash";
export { head, serializeHead } from "./head";
export type { HeadInput, SerializedHead } from "./head";
export { httpResponse, EMPTY_HEAD } from "./http";
export type { HttpResponseOptions } from "./http";
export { RouteError } from "./route-error";
export type Page = Component;
export interface RouteRecord {
    pattern: string;
    page: Page;
}
export interface RouteSnapshot {
    path: string;
    params: Record<string, string>;
    search: string;
    hash: string;
}
export interface AppError {
    message: string;
    status?: number;
    stack?: string;
}
export interface IslandContext {
    request?: Request;
}
export type LayoutProps = {
    children?: View;
} & SnapshotPropBag;
export interface SnapshotPropBag {
    readonly [key: string]: SnapshotPropValue | undefined;
}
export type SnapshotPropValue = string | number | boolean | null | View | SnapshotPropValue[] | SnapshotPropBag;
export type LayoutHandler = (props: LayoutProps) => View | Promise<View>;
export type ErrorHandler = (error: AppError, route: RouteSnapshot) => Page | View;
export declare class Redirect {
    readonly __ilhaRedirect: true;
    readonly to: string;
    readonly status: number;
    constructor(to: string, status?: number);
}
export declare const redirect: (to: string, status?: number) => never;
declare const throwAppError: (status: number, message: string) => never;
export { throwAppError as error };
export declare const defineLayout: (layout: LayoutHandler) => LayoutHandler;
export interface NavigateOptions {
    replace?: boolean;
    scroll?: boolean;
}
export type RouterMode = "spa" | "static";
export interface RouterOptions {
    mode?: RouterMode;
    interceptLinks?: boolean;
    allowExternalRedirects?: boolean;
    viewTransitions?: boolean;
    notFound?: Page;
}
export interface MountOptions {
    hydrate?: boolean;
    interceptLinks?: boolean;
}
export type RenderResponse = {
    kind: "html";
    html: string;
    status?: number;
    head?: SerializedHead;
} | {
    kind: "redirect";
    to: string;
    status: number;
} | {
    kind: "error";
    status: number;
    message: string;
    html: string;
    head?: SerializedHead;
};
export interface RespondOptions extends HttpResponseOptions {
    timeout?: number;
    snapshot?: boolean;
    markers?: boolean;
    shell?: (head: SerializedHead, html: string) => string;
}
export interface RenderPageOptions {
    timeout?: number;
    snapshot?: boolean;
    markers?: boolean;
}
export interface RouterBuilder {
    route: (pattern: string, page: Page) => RouterBuilder;
    errorBoundary: (pattern: string, handler: ErrorHandler) => RouterBuilder;
    routes: () => RouteRecord[];
    prime: () => void;
    mount: (target: string | Element, options?: MountOptions) => () => void;
    render: (url: string | URL | Request, options?: RenderPageOptions) => Promise<string>;
    renderResponse: (url: string | URL | Request, options?: RenderPageOptions) => Promise<RenderResponse>;
    respond: (url: string | URL | Request, options?: RespondOptions) => Promise<Response>;
    hydrate: (options?: {
        root?: Element;
        interceptLinks?: boolean;
    }) => () => void;
}
export interface Navigation {
    from: string;
    to: string;
    type: "push" | "replace" | "pop";
    cancel?: () => void;
}
type BeforeNavigateHook = (nav: Navigation & {
    cancel: () => void;
}) => void;
type AfterNavigateHook = (nav: Navigation) => void;
export declare const wrapLayout: (layout: LayoutHandler, page: Page) => Page;
export declare const wrapError: (handler: ErrorHandler, page: Page) => Page;
export declare const routePath: () => string;
export declare const routeParams: () => Record<string, string>;
export declare const routeSearch: () => string;
export declare const routeHash: () => string;
export declare const navigating: () => boolean;
export declare const useRoute: () => {
    hash: () => string;
    navigating: () => boolean;
    params: () => Record<string, string>;
    path: () => string;
    search: () => string;
};
export declare const useContext: () => {
    request: Request | undefined;
};
export declare const prime: () => void;
export declare const beforeNavigate: (fn: BeforeNavigateHook) => (() => void);
export declare const afterNavigate: (fn: AfterNavigateHook) => (() => void);
export declare const navigate: (to: string, opts?: NavigateOptions) => void;
export type LinkInterceptionOptions = Record<string, never>;
export declare const enableLinkInterception: (root?: Element | Document, _options?: LinkInterceptionOptions) => (() => void);
export interface IsActiveOptions {
    end?: boolean;
}
export declare const isActive: (pattern: string, options?: IsActiveOptions) => boolean;
export declare const resolveRedirectTarget: (to: string, base: URL, allowExternal: boolean) => {
    ok: true;
    to: string;
} | {
    ok: false;
};
export declare const router: (options?: RouterOptions) => RouterBuilder;