import { b as VNode, C as ComponentType } from './vnode-B_CmIoCi.js';

type ProvideKey = string | symbol;
type Provides = Map<ProvideKey, unknown>;
declare function provide<T>(key: ProvideKey, value: T): void;
declare function inject<T>(key: ProvideKey): T | undefined;
declare function inject<T>(key: ProvideKey, defaultValue: T): T;

type RenderSource = VNode | (() => VNode);
interface HydrationOptions {
    recover?: boolean;
}
declare function render(source: RenderSource, container: Element, appProvides?: Provides | null): void;

type PluginInstall = (app: App, ...options: unknown[]) => void;
interface PluginObject {
    install: PluginInstall;
}
type Plugin = PluginInstall | PluginObject;
interface App {
    mount(container: Element): void;
    hydrate(container: Element, options?: HydrationOptions): void;
    provide<T>(key: ProvideKey, value: T): App;
    use(plugin: Plugin, ...options: unknown[]): App;
}
declare function createApp(rootComponent: ComponentType | VNode): App;

interface Ref<T> {
    value: T;
}
declare function ref<T>(value: T): Ref<T>;

type QueryValue = string | string[];
type Query = Record<string, QueryValue>;
type QueryInputValue = string | number | boolean | null | undefined;
type QueryInput = Record<string, QueryInputValue | QueryInputValue[]>;

type RouteComponent = ComponentType | LazyRouteComponent;
interface LazyRouteComponent {
    readonly __solaceLazyRouteComponent: true;
    load(): Promise<{
        default: ComponentType;
    } | ComponentType>;
}
type NavigationGuardResult = void | boolean | RouteLocationRaw | Promise<void | boolean | RouteLocationRaw>;
type NavigationGuard = (to: RouteLocationNormalized, from: RouteLocationNormalized) => NavigationGuardResult;
interface RouteRecord {
    path: string;
    component?: RouteComponent;
    children?: RouteRecord[];
    redirect?: RouteLocationRaw | ((to: RouteLocationNormalized) => RouteLocationRaw);
    beforeEnter?: NavigationGuard | NavigationGuard[];
    meta?: Record<string, unknown>;
}
interface RouteLocationNormalized {
    path: string;
    fullPath: string;
    query: Query;
    params: Record<string, string>;
    matched: RouteRecord[];
    redirectedFrom?: RouteLocationNormalized;
}
type RouteLocationRaw = string | {
    path: string;
    query?: QueryInput;
};
interface RouterHistory {
    location(): string;
    push(path: string): void;
    replace(path: string): void;
    listen(listener: () => void): () => void;
    back(): void;
    forward(): void;
}
interface RouterOptions {
    history: RouterHistory;
    routes: RouteRecord[];
}
interface Router {
    currentRoute: Ref<RouteLocationNormalized>;
    install(app: App): void;
    push(to: RouteLocationRaw): Promise<RouteLocationNormalized>;
    replace(to: RouteLocationRaw): Promise<RouteLocationNormalized>;
    back(): void;
    forward(): void;
    resolve(to: RouteLocationRaw): RouteLocationNormalized;
    beforeEach(guard: NavigationGuard): () => void;
}

export { createApp as j, inject as k, render as l, provide as p, ref as r };
export type { App as A, HydrationOptions as H, LazyRouteComponent as L, NavigationGuard as N, Plugin as P, RouteLocationRaw as R, RouterHistory as a, RouteLocationNormalized as b, RouterOptions as c, Router as d, NavigationGuardResult as e, PluginInstall as f, PluginObject as g, RouteComponent as h, RouteRecord as i, Provides as m };