import { R as RouteLocationRaw, a as RouterHistory, L as LazyRouteComponent, b as RouteLocationNormalized, c as RouterOptions, d as Router } from './types-BURmCFnX.js';
export { A as App, H as HydrationOptions, N as NavigationGuard, e as NavigationGuardResult, P as Plugin, f as PluginInstall, g as PluginObject, h as RouteComponent, i as RouteRecord, j as createApp, k as inject, p as provide, r as ref, l as render } from './types-BURmCFnX.js';
import { V as VNodeProps, a as VNodeChildren, b as VNode, F as Fragment, C as ComponentType, c as ComponentVNodeChildren, d as VNodeType, e as ComponentRender, f as ComponentSetupContext } from './vnode-B_CmIoCi.js';
export { g as ComponentProps, E as EmitFn, h as FragmentType, S as Slot, i as SlotProps, j as Slots, k as VNodeChild, l as VNodeSlots } from './vnode-B_CmIoCi.js';

interface ComputedRef<T> {
    readonly value: T;
}
declare function computed<T>(getter: () => T): ComputedRef<T>;

declare function effect<T>(fn: () => T): () => T;

type LifecycleHook = () => void;
declare function onMounted(hook: LifecycleHook): void;
declare function onUpdated(hook: LifecycleHook): void;
declare function onUnmounted(hook: LifecycleHook): void;

declare function reactive<T extends object>(target: T): T;

type WatchSource<T> = () => T;
type WatchCallback<T> = (newValue: T, oldValue: T) => void;
type WatchEffect = () => void;
type WatchStopHandle = () => void;
declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>): WatchStopHandle;
declare function watchEffect(effect: WatchEffect): WatchStopHandle;

declare function nextTick<T = void>(callback?: () => T): Promise<T | void>;

declare function h(type: string, props?: VNodeProps | null, children?: VNodeChildren): VNode;
declare function h(type: typeof Fragment, props?: VNodeProps | null, children?: VNodeChildren): VNode;
declare function h<Props extends object>(type: ComponentType<Props>, props?: Props | null, children?: ComponentVNodeChildren): VNode;
declare function h(type: VNodeType, props?: VNodeProps | null, children?: ComponentVNodeChildren): VNode;

type AsyncComponentLoader<Props extends object> = () => Promise<ComponentType<Props>>;
interface AsyncComponentOptions<Props extends object> {
    loader: AsyncComponentLoader<Props>;
    loadingComponent?: ComponentType<Props>;
    errorComponent?: ComponentType<Props>;
    delay?: number;
    timeout?: number;
    retry?: number;
    retryDelay?: number;
}
type AsyncComponentSource<Props extends object> = AsyncComponentLoader<Props> | AsyncComponentOptions<Props>;
declare function defineAsyncComponent<Props extends object>(source: AsyncComponentSource<Props>): ComponentType<Props>;

declare function defineComponent<Props extends object, Result extends ComponentRender | VNode>(component: (props: Props, context: ComponentSetupContext) => Result): (props: Props, context: ComponentSetupContext) => Result;

type StateFactory<State extends object> = () => State;
type ActionTree<State extends object, GetterValues extends Record<string, unknown>> = Record<string, (context: StoreContext<State, GetterValues>, ...args: never[]) => unknown>;
interface StoreGetterContext<State extends object> {
    state: State;
}
type StoreGetters<State extends object, GetterValues extends Record<string, unknown>> = {
    [Key in keyof GetterValues]: (context: StoreGetterContext<State>) => GetterValues[Key];
};
type StoreActionsInput<State extends object, GetterValues extends Record<string, unknown>> = ActionTree<State, GetterValues>;
type StoreActionMethods<Actions> = {
    [Key in keyof Actions]: Actions[Key] extends (context: never, ...args: infer Args) => infer Result ? (...args: Args) => Result : never;
};
interface StoreContext<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>> {
    state: State;
    getters: Readonly<GetterValues>;
}
interface Store<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>, Actions extends ActionTree<State, GetterValues> = Record<string, never>> extends StoreContext<State, GetterValues> {
    actions: StoreActionMethods<Actions>;
}
interface StoreOptions<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>, Actions extends ActionTree<State, GetterValues> = Record<string, never>> {
    state: StateFactory<State>;
    getters?: StoreGetters<State, GetterValues>;
    actions?: Actions & StoreActionsInput<State, GetterValues>;
}
declare function createStore<State extends object>(options: {
    state: StateFactory<State>;
}): Store<State>;
declare function createStore<State extends object, GetterValues extends Record<string, unknown>>(options: {
    state: StateFactory<State>;
    getters: StoreGetters<State, GetterValues>;
}): Store<State, GetterValues>;
declare function createStore<State extends object, Actions extends ActionTree<State, Record<string, never>>>(options: {
    state: StateFactory<State>;
    actions: Actions & StoreActionsInput<State, Record<string, never>>;
}): Store<State, Record<string, never>, Actions>;
declare function createStore<State extends object, GetterValues extends Record<string, unknown>, Actions extends ActionTree<State, GetterValues>>(options: {
    state: StateFactory<State>;
    getters: StoreGetters<State, GetterValues>;
    actions: Actions & StoreActionsInput<State, GetterValues>;
}): Store<State, GetterValues, Actions>;

declare function useStyle(scopeId: string, css: string): void;

interface RouterLinkProps extends VNodeProps {
    to: RouteLocationRaw;
    replace?: boolean;
}
declare function RouterLink(props: RouterLinkProps, { slots }: {
    slots: {
        default?: () => unknown;
    };
}): ComponentRender;
declare function RouterView(): ComponentRender;

declare function createWebHistory(): RouterHistory;
declare function createWebHashHistory(): RouterHistory;

declare function lazyRoute(load: () => Promise<{
    default: ComponentType;
} | ComponentType>): LazyRouteComponent;

declare class RouterNavigationError extends Error {
    readonly type: "redirect-loop" | "redirect-rejected" | "guard-rejected" | "lazy-load-failed";
    readonly from: RouteLocationNormalized;
    readonly to: RouteLocationNormalized;
    constructor(message: string, type: "redirect-loop" | "redirect-rejected" | "guard-rejected" | "lazy-load-failed", from: RouteLocationNormalized, to: RouteLocationNormalized);
}
declare function createRouter(options: RouterOptions): Router;
declare function useRouter(): Router;
declare function useRoute(): Router["currentRoute"];

export { ComponentRender, ComponentSetupContext, ComponentType, ComponentVNodeChildren, Fragment, LazyRouteComponent, RouteLocationNormalized, RouteLocationRaw, Router, RouterHistory, RouterLink, RouterNavigationError, RouterOptions, RouterView, VNode, VNodeChildren, VNodeProps, VNodeType, computed, createRouter, createStore, createWebHashHistory, createWebHistory, defineAsyncComponent, defineComponent, effect, h, lazyRoute, nextTick, onMounted, onUnmounted, onUpdated, reactive, useRoute, useRouter, useStyle, watch, watchEffect };
export type { AsyncComponentLoader, AsyncComponentOptions, AsyncComponentSource, RouterLinkProps, Store, StoreActionsInput, StoreContext, StoreGetterContext, StoreGetters, StoreOptions };