@kitbag/router 0.0.1 → 0.0.2

package/dist/kitbag-router.d.ts

@@ -1,32 +1,14 @@
 import { AsyncComponentLoader } from 'vue';
 import { Component } from 'vue';
-import { ComponentOptionsBase } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
-import { ComponentPublicInstance } from 'vue';
-import { ComputedGetter } from 'vue';
-import { ComputedOptions } from 'vue';
-import { ComputedSetter } from 'vue';
-import { DebuggerEvent } from 'vue';
 import { DeepReadonly } from 'vue';
 import { DefineComponent } from 'vue';
-import { DefineSetupFnComponent } from 'vue';
-import { DirectiveBinding } from 'vue';
-import { DirectiveHook } from 'vue';
 import { ExtractPropTypes } from 'vue';
-import { FunctionalComponent } from 'vue';
-import { FunctionDirective } from 'vue';
 import { InjectionKey } from 'vue';
-import { LooseRequired } from '@vue/shared';
-import { MethodOptions } from 'vue';
 import { Plugin as Plugin_2 } from 'vue';
 import { PropType } from 'vue';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
-import { RendererElement } from 'vue';
-import { RendererNode } from 'vue';
-import { Slot } from 'vue';
-import { VNode } from 'vue';
-import { WatchCallback } from 'vue';
 
 declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
 
@@ -51,40 +33,49 @@ declare type __VLS_WithTemplateSlots_2<T, S> = T & {
     };
 };
 
+/**
+ * Adds a hook that is called after a route change. Returns a function to remove the hook.
+ * @param hook - {@link AfterRouteHook} The hook function to add.
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
 export declare type AddAfterRouteHook = (hook: AfterRouteHook) => RouteHookRemove;
 
+/**
+ * Adds a hook that is called before a route change. Returns a function to remove the hook.
+ * @param hook - {@link BeforeRouteHook} The hook function to add.
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
 export declare type AddBeforeRouteHook = (hook: BeforeRouteHook) => RouteHookRemove;
 
-declare type AfterContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute;
-    hooks: RouteHookStore;
-};
-
+/**
+ * Represents a function called after a route change has occurred.
+ * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
+ * @param context - {@link AfterRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
 export declare type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
 
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
 declare type AfterRouteHookContext = RouteHookContext;
 
+/**
+ * Enumerates the lifecycle events for after route hooks.
+ */
 export declare type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
 
-declare type AfterRouteHookRegistration = {
-    timing: RouteHookTiming;
-    lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-    hook: AfterRouteHook;
-    depth: number;
-};
-
-export declare type AfterRouteHookResponse<T extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<T> | RouteHookRejectResponse;
+/**
+ * Type for responses from an after route hook, which may indicate different outcomes such as success, push, or reject.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export declare type AfterRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse;
 
-export declare type AllPropertiesAreOptional<T> = IsEmptyObject<OnlyRequiredProperties<T>>;
+declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
 
-export declare function asArray<T>(value: T | T[]): T[];
-
-export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): string;
-
-declare type AssembleUrlOptions = {
-    params?: Record<string, unknown>;
-    query?: Record<string, string>;
+declare type BaseResolvedRoute = Route & {
+    pathParams: Record<string, unknown>;
+    queryParams: Record<string, unknown>;
 };
 
 declare type BaseRoute = {
@@ -94,38 +85,41 @@ declare type BaseRoute = {
     queryParams: Record<string, unknown>;
 };
 
-declare type BeforeContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute;
-    hooks: RouteHookStore;
-};
-
+/**
+ * Represents a function called before a route change, potentially altering the routing operation.
+ * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
+ * @param context - {@link BeforeRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
 export declare type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<void>;
 
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
+ * as well as aborting current route change.
+ */
 declare type BeforeRouteHookContext = RouteHookContext & {
     abort: RouteHookAbort;
 };
 
+/**
+ * Enumerates the lifecycle events for before route hooks.
+ */
 export declare type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
 
-declare type BeforeRouteHookRegistration = {
-    timing: RouteHookTiming;
-    lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: BeforeRouteHook;
-    depth: number;
-};
+/**
+ * Type for responses from a before route hook, which may indicate different outcomes such as success, push, reject, or abort.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export declare type BeforeRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse | RouteHookAbortResponse;
 
-export declare type BeforeRouteHookResponse<T extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<T> | RouteHookRejectResponse | RouteHookAbortResponse;
+declare const builtInRejections: readonly ["NotFound"];
 
-declare type BuiltInRejectionComponents = Partial<Record<BuiltInRejectionType, RouteComponent>>;
+declare type BuiltInRejectionType = typeof builtInRejections[number];
 
-export declare const builtInRejectionComponents: Record<BuiltInRejectionType, RouteComponent>;
-
-export declare const builtInRejections: readonly ["NotFound"];
-
-export declare type BuiltInRejectionType = typeof builtInRejections[number];
-
-export declare type ChildRouteProps = WithHooks & {
+/**
+ * Represents properties for child routes, including required component, name, and path.
+ */
+declare type ChildRouteProps = WithHooks & {
     name: string;
     disabled?: boolean;
     path: string | Path;
@@ -152,52 +146,58 @@ declare type CombineQuery<TParent extends Query | undefined, TChild extends Quer
     params: infer TChildParams extends Record<string, unknown>;
 } ? MergeParams<TParentParams, TChildParams> extends QueryParams<`${TParentQuery}${TChildQuery}`> ? Query<`${TParentQuery}${TChildQuery}`, MergeParams<TParentParams, TChildParams>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
 
-export declare const component: {
-    template: string;
-};
-
-export declare function countExpectedQueryKeys(route: Route, actualQuery: URLSearchParams): number;
-
-export declare function createCurrentRoute(fallbackRoute: ResolvedRoute): CurrentRoute;
-
-export declare function createMaybeRelativeUrl(value: string): MaybeRelativeUrl;
-
-export declare function createResolvedRouteQuery(query?: string): ResolvedRouteQuery;
-
-export declare function createRouteHookRunners<const T extends Routes>(): RouteHookRunners<T>;
-
+/**
+ * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
+ *
+ * @param routes - {@link Routes} An array of route definitions specifying the configuration of routes in the application.
+ * Use createRoutes method to create the route definitions.
+ * @param options - {@link RouterOptions} for the router, including history mode and initial URL settings.
+ * @returns Router instance
+ *
+ * @example
+ * ```ts
+ * import { createRoutes, createRouter } from '@kitbag/router'
+ *
+ * const Home = { template: '<div>Home</div>' }
+ * const About = { template: '<div>About</div>' }
+ *
+ * export const routes = createRoutes([
+ *   { name: 'home', path: '/', component: Home },
+ *   { name: 'path', path: '/about', component: About },
+ * ])
+ *
+ * const router = createRouter(routes)
+ * ```
+ */
 export declare function createRouter<const T extends Routes>(routes: T, options?: RouterOptions): Router<T>;
 
-export declare function createRouterFind<const TRoutes extends Routes>(routes: TRoutes): RouterFind<TRoutes>;
-
-export declare function createRouterHistory({ mode }?: RouterHistoryOptions): RouterHistory;
-
-export declare function createRouterHooks(): RouterHooks;
-
-export declare type CreateRouterReject = {
-    setRejection: RouterSetReject;
-    rejection: RouterRejection;
-    getRejectionRoute: GetRejectionRoute;
-    isRejectionRoute: IsRejectionRoute;
-};
-
-export declare function createRouterReject({ rejections: customRejectionComponents, }: CreateRouterRejectContext): CreateRouterReject;
-
-declare type CreateRouterRejectContext = {
-    rejections?: RouterRejectionComponents['rejections'];
-};
-
-export declare function createRouterResolve<const TRoutes extends Routes>(routes: TRoutes): RouterResolve<TRoutes>;
-
+/**
+ * Creates an array of Route instances from a defined set of route properties, handling hierarchical route combinations.
+ * This function also validates for duplicate parameter keys across the combined routes.
+ *
+ * @param routesProps - An array of route properties used to configure and create routes.
+ * @returns An array of fully configured Route instances.
+ */
 export declare function createRoutes<const TRoutes extends Readonly<RouteProps[]>>(routes: TRoutes): FlattenRoutes<TRoutes>;
 
-declare type CurrentRoute = {
-    route: ResolvedRoute;
-    updateRoute: ResolvedRouteUpdate;
-};
-
-export declare const depthInjectionKey: InjectionKey<number>;
+/**
+ * An error thrown when duplicate parameters are detected in a route when creating a router.
+ * When defining routes, param names must be unique. This includes params defined in a path
+ * parent and params defined in the query.
+ */
+export declare class DuplicateParamsError extends Error {
+    /**
+     * Constructs a new DuplicateParamsError instance with a message indicating the problematic parameter.
+     * @param paramName - The name of the parameter that was duplicated.
+     */
+    constructor(paramName: string);
+}
 
+/**
+ * Extracts the parameter name from a string, handling optional parameters denoted by a leading '?'.
+ * @template TParam - The string from which to extract the parameter name.
+ * @returns The extracted parameter name, or never if the parameter string is empty.
+ */
 export declare type ExtractParamName<TParam extends string> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
 
 declare type ExtractParamsFromPathString<TPath extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TPath extends `${infer Path}${ParamEnd}` ? ExtractParamsFromPathString<Path, TParams> : TPath extends `${string}:${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
@@ -206,12 +206,28 @@ declare type ExtractParamsFromPathString<TPath extends string, TParams extends R
     [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams>;
 } : Record<never, never>;
 
+/**
+ * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
+ * @template TParam - The parameter type.
+ * @returns The extracted type, or 'string' as a fallback.
+ */
 export declare type ExtractParamType<TParam extends Param | undefined> = TParam extends ParamGetSet<infer Type> ? undefined extends TParam ? Type | undefined : Type : TParam extends ParamGetter ? undefined extends TParam ? ReturnType<TParam> | undefined : ReturnType<TParam> : undefined extends TParam ? undefined : string;
 
+/**
+ * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
+ * @template TParams - The record of parameter types, possibly including undefined.
+ * @returns A new type with the appropriate properties marked as optional.
+ */
 export declare type ExtractParamTypes<TParams extends Record<string, Param | undefined>> = Identity<MakeOptional<{
     [K in keyof TParams]: ExtractParamType<TParams[K]>;
 }>>;
 
+/**
+ * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
+ * @template TParam - The parameter name string.
+ * @template TParams - The record object mapping parameter names to their types.
+ * @returns The type associated with the parameter, or StringConstructor if unspecified; may be undefined for optional parameters.
+ */
 export declare type ExtractPathParamType<TParam extends string, TParams extends Record<string, Param | undefined>> = TParam extends `?${infer OptionalParam}` ? OptionalParam extends keyof TParams ? TParams[OptionalParam] | undefined : StringConstructor | undefined : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
 
 declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TQuery extends `${string}=:${infer Param}&${infer Rest}` ? MergeParams<{
@@ -222,13 +238,18 @@ declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams ex
 
 declare type ExtractRouteChildren<TRoute extends RouteProps> = TRoute extends ParentRouteProps ? TRoute['children'] extends Route[] ? TRoute['children'] : [] : [];
 
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * @template TRoute - The route type from which to extract and merge parameter types.
+ * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
+ */
 export declare type ExtractRouteParamTypes<TRoute extends {
     pathParams: Record<string, unknown>;
     queryParams: Record<string, unknown>;
 }> = TRoute extends {
     pathParams: infer PathParams extends Record<string, Param | undefined>;
     queryParams: infer QueryParams extends Record<string, Param | undefined>;
-} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : never;
+} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
 
 declare type Flatten<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends unknown[] ? Flatten<[...First, ...Flatten<Rest>]> : [First, ...Flatten<Rest>] : [];
 
@@ -245,267 +266,348 @@ declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[]>> = Flatten<[
 }
 ]>;
 
-export declare function generateRoutePathRegexPattern(route: Route): RegExp;
-
-export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
-
-export declare function getAfterRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute): RouteHooks;
-
-export declare function getBeforeRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute): RouteHooks;
-
-export declare function getInitialUrl(initialUrl?: string): string;
-
-export declare function getParam<P extends Record<string, Param | undefined>>(params: P, param: string): Param;
-
-export declare function getParamsForString<TInput extends string, TParams extends Record<string, Param | undefined>>(string: TInput, params: TParams): Record<string, Param>;
-
-export declare function getParamValue<T extends Param>(value: string | undefined, param: T): ExtractParamType<T>;
-
-export declare function getParamValueFromUrl(url: string, path: string, paramName: string): string | undefined;
-
-declare type GetRejectionRoute = (type: RouterRejectionType) => ResolvedRoute;
-
-export declare function getResolvedRouteForUrl(routes: Routes, url: string): ResolvedRoute | undefined;
-
-export declare function getRouteHookCondition(lifecycle: RouteHookLifecycle): RouteHookCondition;
-
-export declare const getRouteParamValues: (route: Route, url: string) => Record<string, unknown>;
-
-export declare function getRouteScoreSortMethod(url: string): RouteSortMethod;
-
-export declare function hasProperty<TSource extends Record<PropertyKey, unknown>, TProperty extends PropertyKey, TType extends () => unknown>(value: TSource, key: TProperty, type?: TType): value is TSource & Record<TProperty, ReturnType<TType>>;
-
-export declare type Identity<T> = T extends object ? {} & {
+declare type Identity<T> = T extends object ? {} & {
     [P in keyof T as T[P] extends never ? never : P]: T[P];
 } : T;
 
-export declare class InvalidRouteParamValueError extends Error {
-}
-
-export declare type IsAny<T> = 0 extends (1 & T) ? true : false;
-
-export declare function isBrowser(): boolean;
-
-export declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
+declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 
+/**
+ * Type guard to check if a value conforms to the ParamGetSet type.
+ * @param value - The value to check.
+ * @returns True if the value is an object with both 'get' and 'set' functions defined.
+ */
 export declare function isParamGetSet(value: Param): value is ParamGetSet;
 
+/**
+ * Type guard to check if a value conforms to the ParamGetter type.
+ * @param value - The value to check.
+ * @returns True if the value is a function that is not a constructor.
+ */
 export declare function isParamGetter(value: Param): value is ParamGetter;
 
-export declare function isParentRoute(value: RouteProps): value is ParentRouteProps;
-
-export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
-
-declare type IsRejectionRoute = (route: ResolvedRoute) => boolean;
-
-export declare const isRouteEnter: RouteHookCondition;
-
-export declare const isRouteLeave: RouteHookCondition;
-
-export declare const isRouteUpdate: RouteHookCondition;
-
-export declare function isUrl(value: unknown): value is Url;
-
 declare type MakeOptional<T> = {
     [P in WithOptionalProperties<T>]?: T[P];
 } & {
     [P in Exclude<keyof T, WithOptionalProperties<T>>]: T[P];
 };
 
-export declare function markRouteRaw(route: RouteProps): RouteProps;
+declare type MaybeArray<T> = T | T[];
 
-export declare type MaybeArray<T> = T | T[];
-
-export declare type MaybeDeepReadonly<T> = T | DeepReadonly<T>;
-
-export declare type MaybePromise<T> = T | Promise<T>;
-
-export declare type MaybeRelativeUrl = {
-    protocol?: string;
-    host?: string;
-    pathname: string;
-    searchParams: URLSearchParams;
-    search: string;
-    hash: string;
-};
+declare type MaybePromise<T> = T | Promise<T>;
 
+/**
+ * Merges two parameter type records, ensuring no overlap in properties.
+ * @template TAlpha - The first record type.
+ * @template TBeta - The second record type.
+ * @returns A new record type combining properties from both inputs without overlaps.
+ */
 export declare type MergeParams<TAlpha extends Record<string, unknown>, TBeta extends Record<string, unknown>> = {
     [K in keyof TAlpha | keyof TBeta]: K extends keyof TAlpha & keyof TBeta ? never : K extends keyof TAlpha ? TAlpha[K] : K extends keyof TBeta ? TBeta[K] : never;
 };
 
 declare type NamedNotDisabled<T> = T extends BaseRoute ? T : never;
 
-declare type NavigationBack = () => void;
-
-declare type NavigationForward = () => void;
-
-declare type NavigationGo = (delta: number) => void;
-
-declare type NavigationPushOptions = {
-    replace?: boolean;
-};
-
-declare type NavigationRefresh = () => void;
-
-declare type NavigationUpdate = (url: string, options?: NavigationPushOptions) => void;
-
-export declare const NotFound: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, PublicProps>;
-
-export declare type OnlyRequiredProperties<T> = {
+/**
+ * Registers a hook that is called after a route has been entered. Must be called during setup.
+ * This allows performing actions right after the component becomes active, such as fetching data or setting up event listeners.
+ *
+ * @param AfterRouteHook - The hook callback function
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+export declare const onAfterRouteEnter: AddAfterRouteHook;
+
+/**
+ * Registers a hook that is called after a route has been left. Must be called during setup.
+ * This can be used for cleanup actions after the component is no longer active, ensuring proper resource management.
+ *
+ * @param AfterRouteHook - The hook callback function
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+export declare const onAfterRouteLeave: AddAfterRouteHook;
+
+/**
+ * Registers a hook that is called after a route has been updated. Must be called during setup.
+ * This is ideal for responding to updates within the same route, such as parameter changes, without full component reloads.
+ *
+ * @param AfterRouteHook - The hook callback function
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+export declare const onAfterRouteUpdate: AddAfterRouteHook;
+
+/**
+ * Registers a hook that is called before a route is left. Must be called from setup.
+ * This is useful for performing actions or cleanups before navigating away from a route component.
+ *
+ * @param BeforeRouteHook - The hook callback function
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+export declare const onBeforeRouteLeave: AddBeforeRouteHook;
+
+/**
+ * Registers a hook that is called before a route is updated. Must be called from setup.
+ * This is particularly useful for handling changes in route parameters or query while staying within the same component.
+ *
+ * @param BeforeRouteHook - The hook callback function
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+export declare const onBeforeRouteUpdate: AddBeforeRouteHook;
+
+declare type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };
 
-export declare function optional<TParam extends Param>(param: TParam): OptionalParamGetSet<TParam>;
-
-declare const optionalKey: unique symbol;
-
-declare type OptionalParamGetSet<TParam extends Param, TValue = ExtractParamType<TParam> | undefined> = ParamGetSet<TValue> & {
-    [optionalKey]: true;
-    get: (value: string | undefined, extras: ParamExtras) => TValue;
-};
-
-export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor;
+declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor;
 
 declare type ParamEnd = '/';
 
-export declare type ParamExtras = {
+declare type ParamExtras = {
     invalid: (message?: string) => never;
 };
 
-export declare type ParamGetSet<T = any> = {
+declare type ParamGetSet<T = any> = {
     get: ParamGetter<T>;
     set: ParamSetter<T>;
 };
 
-export declare type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
+declare type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
 
-declare type ParamRawValue<T> = Extract<T, undefined> extends never ? string : string | undefined;
+declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
 
-export declare type ParamReplace = {
-    name: string;
-    param: Param;
-    value?: unknown;
-};
-
-export declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
-
-export declare type ParentRouteProps = WithHooks & {
+/**
+ * Represents properties common to parent routes in a route configuration, including hooks, path, and optional query parameters.
+ */
+declare type ParentRouteProps = WithHooks & {
     name?: string;
     path: string | Path;
     query?: string | Query;
     disabled?: boolean;
-    children?: Routes;
+    children: Routes;
     component?: RouteComponent;
     meta?: RouteMeta;
 };
 
-export declare type Path<T extends string = any, P extends PathParams<T> = any> = {
+declare type Path<T extends string = any, P extends PathParams<T> = any> = {
     path: T;
     params: Identity<ExtractParamsFromPathString<T, P>>;
     toString: () => string;
 };
 
-export declare function path<T extends string, P extends PathParams<T>>(path: T, params: Identity<P>): Path<T, P>;
-
-export declare type PathParams<T extends string> = {
+/**
+ * Constructs a Path object, which enables assigning types for params.
+ *
+ * @template TPath - The string literal type that represents the path.
+ * @template TParams - The type of the path parameters associated with the path.
+ * @param path - The path string.
+ * @param params - The parameters associated with the path, typically as key-value pairs.
+ * @returns An object representing the path which includes the path string, its parameters,
+ *          and a toString method for getting the path as a string.
+ *
+ * @example
+ * ```ts
+ * import { createRoutes, path } from '@kitbag/router'
+ *
+ * export const routes = createRoutes([
+ *   {
+ *     name: 'home',
+ *     path: path('/:foo', { foo: Number }),
+ *     component: Home
+ *   },
+ * ])
+ * ```
+ */
+export declare function path<TPath extends string, TParams extends PathParams<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
+
+declare type PathParams<T extends string> = {
     [K in keyof ExtractParamsFromPathString<T>]?: Param;
 };
 
-export declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
+declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
     query: T;
     params: Identity<ExtractQueryParamsFromQueryString<T, P>>;
     toString: () => string;
 };
 
-export declare function query<T extends string, P extends QueryParams<T>>(query: T, params: Identity<P>): Query<T, P>;
-
-export declare type QueryParams<T extends string> = {
+/**
+ * Constructs a Query object, which enables assigning types for params.
+ *
+ * @template TQuery - The string literal type that represents the query.
+ * @template TParams - The type of the query parameters associated with the query.
+ * @param query - The query string.
+ * @param params - The parameters associated with the query, typically as key-value pairs.
+ * @returns An object representing the query which includes the query string, its parameters,
+ *          and a toString method for getting the query as a string.
+ *
+ * @example
+ * ```ts
+ * import { createRoutes, query } from '@kitbag/router'
+ *
+ * export const routes = createRoutes([
+ *   {
+ *     name: 'home',
+ *     query: query('?bar=:bar', { bar: Boolean }),
+ *     component: Home
+ *   },
+ * ])
+ * ```
+ */
+export declare function query<TQuery extends string, TParams extends QueryParams<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
+
+declare type QueryParams<T extends string> = {
     [K in keyof ExtractQueryParamsFromQueryString<T>]?: Param;
 };
 
-export declare const random: {
-    number(options?: {
-        min?: number;
-        max?: number;
-    }): number;
-};
-
+/**
+ * Represents the state of currently registered router, and rejections. Used to provide correct type context for
+ * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
+ *
+ * @example
+ * ```ts
+ * declare module '@kitbag/router' {
+ *   interface Register {
+ *     router: typeof router
+ *   }
+ * }
+ * ```
+ */
 export declare interface Register {
 }
 
+/**
+ * Represents the possible Rejections registered within {@link Register}
+ */
 export declare type RegisteredRejectionType = Register extends {
     rejections: infer TRejections extends string[];
 } ? TRejections[number] : never;
 
+/**
+ * Represents the a map of all possible RouteKeys with corresponding Route registered within {@link Register}
+ */
 export declare type RegisteredRouteMap = RoutesMap<RegisteredRoutes>;
 
+/**
+ * Represents the Router property within {@link Register}
+ */
 export declare type RegisteredRouter = Register extends {
     router: infer TRouter;
-} ? TRouter : Router<any>;
+} ? TRouter : Router;
 
+/**
+ * Represents the type for router `push`, with types for routes registered within {@link Register}
+ */
 export declare type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
 
+/**
+ * Represents the type for router `replace`, with types for routes registered within {@link Register}
+ */
 export declare type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
 
+/**
+ * Represents the State property registered within {@link Register}
+ */
 export declare type RegisteredRouterState = Register extends {
     state: infer TState;
 } ? TState : {};
 
+/**
+ * Represents the Router routes property within {@link Register}
+ */
 export declare type RegisteredRoutes = Register extends {
     router: Router<infer TRoutes extends Routes>;
 } ? TRoutes : Route<string, Path<'', {}>, Query<'', {}>, false>[];
 
+/**
+ * Represents the union of all possible RouteKeys registered within {@link Register}
+ */
 export declare type RegisteredRoutesKey = RoutesKey<RegisteredRoutes>;
 
-export declare type ReplaceAll<Input extends string, Search extends string, Replacement extends string> = Input extends `${infer Head}${Search}${infer Tail}` ? `${Head}${Replacement}${ReplaceAll<Tail, Search, Replacement>}` : Input;
-
-export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
-
-export declare type ResolvedRoute<TRoute extends Route = Route> = {
+declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = DeepReadonly<{
     matched: TRoute['matched'];
     matches: RouteProps[];
     key: TRoute['key'];
     query: ResolvedRouteQuery;
     params: ExtractRouteParamTypes<TRoute>;
-};
+}>;
 
-export declare type ResolvedRouteQuery = {
+declare type ResolvedRouteQuery = {
     get: (key: string) => string | null;
     getAll: (key: string) => string[];
 };
 
-declare type ResolvedRouteUpdate = (route: ResolvedRoute) => void;
-
+/**
+ * Represents the structure of a route within the application.
+ * @template TKey - Represents the unique key identifying the route, typically a string.
+ * @template TPath - The type or structure of the route's path.
+ * @template TQuery - The type or structure of the query parameters associated with the route.
+ * @template TDisabled - Indicates whether the route is disabled, which could affect routing logic.
+ */
 export declare type Route<TKey extends string | undefined = any, TPath extends string | Path = Path, TQuery extends string | Query | undefined = Query, TDisabled extends boolean | undefined = boolean> = {
-    matched: RouteProps;
-    matches: RouteProps[];
+    /**
+     * The specific route properties that were matched in the current route.
+     */
+    matched: RoutePropsWithMeta;
+    /**
+     * The specific route properties that were matched in the current route, including any ancestors.
+     * Order of routes will be from greatest ancestor to narrowest matched.
+     */
+    matches: RoutePropsWithMeta[];
+    /**
+     * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
+     */
     key: TKey;
+    /**
+     * Represents the structured path of the route, including path params.
+     */
     path: ToPath<TPath>;
+    /**
+     * Represents the structured query of the route, including query params.
+     */
     query: ToQuery<TQuery>;
+    /**
+     * Extracted path params based on the route's path type.
+     */
     pathParams: ToPath<TPath>['params'];
+    /**
+     * Extracted query params based on the route's query type.
+     */
     queryParams: ToQuery<TQuery>['params'];
+    /**
+     * Represents the depth of the route in the route hierarchy.
+     */
     depth: number;
+    /**
+     * Indicates if the route is disabled.
+     */
     disabled: TDisabled extends boolean ? TDisabled : false;
 };
 
-export declare type RouteComponent = Component | DefineComponent | AsyncComponentLoader;
+/**
+ * Type alias for Vue components, which can be either synchronous or asynchronous components.
+ */
+declare type RouteComponent = Component | DefineComponent | AsyncComponentLoader;
 
-export declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
+declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
 
+/**
+ * Generic type representing a route hook, which can be either before or after a route change.
+ */
 export declare type RouteHook = BeforeRouteHook | AfterRouteHook;
 
+/**
+ * A function that can be called to abort a routing operation.
+ */
 export declare type RouteHookAbort = () => void;
 
+/**
+ * Defines the structure of an aborted route hook response.
+ */
 declare type RouteHookAbortResponse = {
     status: 'ABORT';
 };
 
-declare type RouteHookAfterRunner<T extends Routes> = (context: AfterContext) => Promise<AfterRouteHookResponse<T>>;
-
-declare type RouteHookBeforeRunner<T extends Routes> = (context: BeforeContext) => Promise<BeforeRouteHookResponse<T>>;
-
-export declare type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
-
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
 declare type RouteHookContext = {
     from: ResolvedRoute | null;
     reject: RouterReject;
@@ -513,116 +615,153 @@ declare type RouteHookContext = {
     replace: RegisteredRouterReplace;
 };
 
+/**
+ * Union type for all route hook lifecycle events.
+ */
 export declare type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
 
+/**
+ * Defines the structure of a route hook response that results in a push to a new route.
+ * @template T - The type of the routes configuration.
+ */
 declare type RouteHookPushResponse<T extends Routes> = {
     status: 'PUSH';
     to: Parameters<RouterPush<T>>;
 };
 
+/**
+ * Defines the structure of a route hook response that results in the rejection of a route transition.
+ */
 declare type RouteHookRejectResponse = {
     status: 'REJECT';
     type: RouterRejectionType;
 };
 
+/**
+ * A function to remove a previously registered route hook.
+ */
 export declare type RouteHookRemove = () => void;
 
-export declare type RouteHookResponse<T extends Routes> = BeforeRouteHookResponse<T> | AfterRouteHookResponse<T>;
-
-declare type RouteHookRunners<T extends Routes> = {
-    runBeforeRouteHooks: RouteHookBeforeRunner<T>;
-    runAfterRouteHooks: RouteHookAfterRunner<T>;
-};
-
-declare class RouteHooks {
-    onBeforeRouteEnter: Set<BeforeRouteHook>;
-    onBeforeRouteUpdate: Set<BeforeRouteHook>;
-    onBeforeRouteLeave: Set<BeforeRouteHook>;
-    onAfterRouteEnter: Set<AfterRouteHook>;
-    onAfterRouteUpdate: Set<AfterRouteHook>;
-    onAfterRouteLeave: Set<AfterRouteHook>;
-}
-
-declare class RouteHookStore {
-    global: RouteHooks;
-    component: RouteHooks;
-    addBeforeRouteHook({ lifecycle, timing, depth, hook }: BeforeRouteHookRegistration): RouteHookRemove;
-    addAfterRouteHook({ lifecycle, timing, depth, hook }: AfterRouteHookRegistration): RouteHookRemove;
-}
-
-export declare const routeHookStoreKey: InjectionKey<RouteHookStore>;
+/**
+ * Union type for all possible route hook responses, covering both before and after scenarios.
+ * @template TRoutes - The type of the routes configuration.
+ */
+export declare type RouteHookResponse<TRoutes extends Routes> = BeforeRouteHookResponse<TRoutes> | AfterRouteHookResponse<TRoutes>;
 
+/**
+ * Defines the structure of a successful route hook response.
+ */
 declare type RouteHookSuccessResponse = {
     status: 'SUCCESS';
 };
 
-declare type RouteHookTiming = 'global' | 'component';
-
-export declare type RouteMatchRule = (route: Route, url: string) => boolean;
-
-export declare interface RouteMeta {
+/**
+ * Represents additional metadata associated with a route, customizable via extensions.
+ * @example
+ * ```ts
+ * declare module '@kitbag/router' {
+ *   interface RouteMeta {
+ *     pageTitle?: string
+ *   }
+ * }
+ * ```
+ */
+declare interface RouteMeta extends Record<string, unknown> {
 }
 
-export declare const routeParamsAreValid: RouteMatchRule;
+declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypes<RouteGetByKey<TRoutes, TKey>>;
 
-export declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypes<RouteGetByKey<TRoutes, TKey>>;
+/**
+ * Unifies the properties of both parent and child routes, ensuring type safety and consistency across route configurations.
+ */
+declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
 
-export declare const routePathMatches: RouteMatchRule;
-
-export declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
-
-export declare const routeQueryMatches: RouteMatchRule;
+/**
+ * The Route properties originally provided to `createRoutes`. The only change is normalizing meta to always default to an empty object.
+ */
+declare type RoutePropsWithMeta = RouteProps & {
+    meta: RouteMeta;
+};
 
-export declare type Router<TRoutes extends Routes = []> = {
-    route: DeepReadonly<ResolvedRoute>;
+export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
+    /**
+     * Manages the current route state.
+     */
+    route: RouterRoute;
+    /**
+     * Resolves a URL to a route object.
+     */
     resolve: RouterResolve<TRoutes>;
+    /**
+     * Navigates to a specified path or route object in the history stack, adding a new entry.
+     */
     push: RouterPush<TRoutes>;
+    /**
+     * Replaces the current entry in the history stack with a new one.
+     */
     replace: RouterReplace<TRoutes>;
+    /**
+     * Finds a route object based on the provided lookup parameters.
+     */
     find: RouterFind<TRoutes>;
+    /**
+     * Handles route rejection based on a specified rejection type.
+     */
     reject: RouterReject;
+    /**
+     * Forces the router to re-evaluate the current route.
+     */
     refresh: () => void;
+    /**
+     * Navigates to the previous entry in the browser's history stack.
+     */
     back: () => void;
+    /**
+     * Navigates to the next entry in the browser's history stack.
+     */
     forward: () => void;
+    /**
+     * Moves the current history entry to a specific point in the history stack.
+     */
     go: (delta: number) => void;
+    /**
+     * Registers a hook to be called before a route is entered.
+     */
     onBeforeRouteEnter: AddBeforeRouteHook;
+    /**
+     * Registers a hook to be called before a route is left.
+     */
     onBeforeRouteLeave: AddBeforeRouteHook;
+    /**
+     * Registers a hook to be called before a route is updated.
+     */
     onBeforeRouteUpdate: AddBeforeRouteHook;
+    /**
+     * Registers a hook to be called after a route is entered.
+     */
     onAfterRouteEnter: AddAfterRouteHook;
+    /**
+     * Registers a hook to be called after a route is left.
+     */
     onAfterRouteLeave: AddAfterRouteHook;
+    /**
+     * Registers a hook to be called after a route is updated.
+     */
     onAfterRouteUpdate: AddAfterRouteHook;
+    /**
+     * A promise that resolves when the router is fully initialized.
+     */
     initialized: Promise<void>;
-} & Plugin_2;
+};
 
-export declare type RouterFind<TRoutes extends Routes> = {
+declare type RouterFind<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
     (source: Url): ResolvedRoute | undefined;
 };
 
 declare type RouterFindArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
 
-export declare type RouterHistory = {
-    forward: NavigationForward;
-    back: NavigationBack;
-    go: NavigationGo;
-    update: NavigationUpdate;
-    refresh: NavigationRefresh;
-};
-
-export declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
-
-declare type RouterHistoryOptions = {
-    mode?: RouterHistoryMode;
-};
-
-export declare type RouterHooks = {
-    onBeforeRouteEnter: AddBeforeRouteHook;
-    onBeforeRouteUpdate: AddBeforeRouteHook;
-    onBeforeRouteLeave: AddBeforeRouteHook;
-    onAfterRouteEnter: AddAfterRouteHook;
-    onAfterRouteUpdate: AddAfterRouteHook;
-    onAfterRouteLeave: AddAfterRouteHook;
-    hooks: RouteHookStore;
-};
+declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
 
 export declare const routerInjectionKey: InjectionKey<RegisteredRouter>;
 
@@ -646,3465 +785,172 @@ to: Url | ToCallback;
     }) => unknown) | undefined;
 }>;
 
+/**
+ * Represents an error thrown when an attempt is made to use routing functionality before the router has been installed.
+ */
+export declare class RouterNotInstalledError extends Error {
+    constructor();
+}
+
+/**
+ * Options to initialize a {@link Router} instance.
+ */
 export declare type RouterOptions = {
+    /**
+     * Initial URL for the router to use. Required if using Node environment.
+     *
+     * @default window.location.toString()
+     */
     initialUrl?: string;
+    /**
+     * Specifies the history mode for the router, such as 'hash', 'history', or 'abstract'.
+     */
     historyMode?: RouterHistoryMode;
 } & RouterRejectionComponents;
 
-export declare type RouterPush<TRoutes extends Routes> = {
+declare type RouterPush<TRoutes extends Routes = any> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
     (source: Url, options?: RouterPushOptions): Promise<void>;
 };
 
 declare type RouterPushArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterPushOptions] : [params: TParams, options?: RouterPushOptions];
 
-export declare type RouterPushOptions = {
+declare type RouterPushOptions = {
     query?: Record<string, string>;
     replace?: boolean;
 };
 
 export declare type RouterReject = (type: RouterRejectionType) => void;
 
-export declare type RouterRejection = Ref<null | {
+declare type RouterRejection = Ref<null | {
     type: RouterRejectionType;
     component: RouteComponent;
 }>;
 
-export declare type RouterRejectionComponents = RegisteredRejectionType extends never ? {
-    rejections?: BuiltInRejectionComponents;
-} : {
-    rejections: BuiltInRejectionComponents & Record<RegisteredRejectionType, RouteComponent>;
+declare type RouterRejectionComponents = {
+    rejections?: Partial<Record<RouterRejectionType, RouteComponent>>;
 };
 
 export declare const routerRejectionKey: InjectionKey<RouterRejection>;
 
-export declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
+declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
 
-export declare type RouterReplace<TRoutes extends Routes> = {
+declare type RouterReplace<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
     (source: Url, options?: RouterReplaceOptions): Promise<void>;
 };
 
 declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions] : [params: TParams, options?: RouterReplaceOptions];
 
-export declare type RouterReplaceOptions = Omit<RouterPushOptions, 'replace'>;
+declare type RouterReplaceOptions = Omit<RouterPushOptions, 'replace'>;
 
-export declare type RouterResolve<TRoutes extends Routes> = {
+declare type RouterResolve<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterResolveArgs<TRoutes, TSource>): string;
     (source: Url, options?: RouterResolveOptions): string;
 };
 
 declare type RouterResolveArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
 
-export declare type RouterResolveOptions = {
+declare type RouterResolveOptions = {
     query?: Record<string, string>;
 };
 
-export declare type RouterSetReject = (type: RouterRejectionType | null) => void;
+declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Omit<ResolvedRoute, 'params'> & Readonly<{
+    params: Writable<TRoute['params']>;
+    update: RouteUpdate<TRoute>;
+}>;
 
 export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>, Readonly<{
     default?: ((props: {
-        route: {
-            readonly matched: {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name?: string | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly children?: readonly {
-                    readonly matched: any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    };
-                    readonly matches: readonly (any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    })[];
-                    readonly key: any;
-                    readonly path: {
-                        readonly path: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly query: {
-                        readonly query: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly pathParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly queryParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly depth: number;
-                    readonly disabled: boolean;
-                }[] | undefined;
-                readonly component?: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                } | undefined;
-                readonly meta?: {} | undefined;
-            } | {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name: string;
-                readonly disabled?: boolean | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly component: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                };
-                readonly meta?: {} | undefined;
-            };
-            readonly matches: readonly ({
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name?: string | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly children?: readonly {
-                    readonly matched: any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    };
-                    readonly matches: readonly (any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    })[];
-                    readonly key: any;
-                    readonly path: {
-                        readonly path: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly query: {
-                        readonly query: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly pathParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly queryParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly depth: number;
-                    readonly disabled: boolean;
-                }[] | undefined;
-                readonly component?: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                } | undefined;
-                readonly meta?: {} | undefined;
-            } | {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name: string;
-                readonly disabled?: boolean | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly component: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                };
-                readonly meta?: {} | undefined;
-            })[];
-            readonly key: any;
-            readonly query: {
-                readonly get: (key: string) => string | null;
-                readonly getAll: (key: string) => string[];
-            };
-            readonly params: {};
-        };
+        route: RouterRoute;
         component: RouteComponent;
     }) => unknown) | undefined;
 }> & {
     default?: ((props: {
-        route: {
-            readonly matched: {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name?: string | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly children?: readonly {
-                    readonly matched: any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    };
-                    readonly matches: readonly (any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    })[];
-                    readonly key: any;
-                    readonly path: {
-                        readonly path: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly query: {
-                        readonly query: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly pathParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly queryParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly depth: number;
-                    readonly disabled: boolean;
-                }[] | undefined;
-                readonly component?: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                } | undefined;
-                readonly meta?: {} | undefined;
-            } | {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name: string;
-                readonly disabled?: boolean | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly component: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                };
-                readonly meta?: {} | undefined;
-            };
-            readonly matches: readonly ({
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name?: string | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly children?: readonly {
-                    readonly matched: any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    };
-                    readonly matches: readonly (any | {
-                        readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                        readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                        readonly name: string;
-                        readonly disabled?: boolean | undefined;
-                        readonly path: string | {
-                            readonly path: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        };
-                        readonly query?: string | {
-                            readonly query: any;
-                            readonly params: {} | {
-                                readonly [x: string]: any;
-                            } | {
-                                readonly [x: string]: any;
-                            };
-                            readonly toString: () => string;
-                        } | undefined;
-                        readonly component: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | DefineComponent | AsyncComponentLoader | {
-                            readonly [x: string]: any;
-                            readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                                attrs: {
-                                    [x: string]: unknown;
-                                };
-                                slots: Readonly<{
-                                    [name: string]: Slot<any> | undefined;
-                                }>;
-                                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                                expose: (exposed?: Record<string, any> | undefined) => void;
-                            }) => any) | undefined;
-                            readonly name?: string | undefined;
-                            readonly template?: string | object | undefined;
-                            readonly render?: Function | undefined;
-                            readonly components?: {
-                                readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                                    new (...args: any[]): any;
-                                    __isFragment?: undefined;
-                                    __isTeleport?: undefined;
-                                    __isSuspense?: undefined;
-                                } | any;
-                            } | undefined;
-                            readonly directives?: {
-                                readonly [x: string]: FunctionDirective<any, any> | {
-                                    readonly created?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly updated?: DirectiveHook<any, VNode<any, any, {
-                                    [key: string]: any;
-                                    }>, any> | undefined;
-                                    readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                                    readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                                    readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                                    [key: string]: any;
-                                    }>) => {
-                                        [x: string]: unknown;
-                                    } | undefined) | undefined;
-                                    readonly deep?: boolean | undefined;
-                                };
-                            } | undefined;
-                            readonly inheritAttrs?: boolean | undefined;
-                            readonly emits?: any;
-                            readonly slots?: {} | undefined;
-                            readonly expose?: readonly string[] | undefined;
-                            readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                            readonly compilerOptions?: {
-                                readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                                readonly whitespace?: "preserve" | "condense" | undefined;
-                                readonly comments?: boolean | undefined;
-                                readonly delimiters?: readonly [string, string] | undefined;
-                            } | undefined;
-                            readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                            readonly __isFragment?: undefined;
-                            readonly __isTeleport?: undefined;
-                            readonly __isSuspense?: undefined;
-                            readonly __defaults?: any;
-                            readonly compatConfig?: {
-                                readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                                readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                                readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                                readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                                readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                                readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                                readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                                readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                                readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                                readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                                readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                                readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                                readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                                readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                                readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                                readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                            } | undefined;
-                            readonly data?: ((this: any, vm: any) => any) | undefined;
-                            readonly computed?: {
-                                readonly [x: string]: ComputedGetter<any> | {
-                                    readonly get: ComputedGetter<any>;
-                                    readonly set: ComputedSetter<any>;
-                                };
-                            } | undefined;
-                            readonly methods?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly watch?: {
-                                readonly [x: string]: string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                } | readonly (string | WatchCallback<any, any> | {
-                                    readonly handler: string | WatchCallback<any, any>;
-                                    readonly immediate?: boolean | undefined;
-                                    readonly deep?: boolean | undefined;
-                                    readonly once?: boolean | undefined;
-                                    readonly flush?: "pre" | "post" | "sync" | undefined;
-                                    readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                                    readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                                })[];
-                            } | undefined;
-                            readonly provide?: Function | {
-                                readonly [x: string]: Readonly<unknown>;
-                                readonly [x: symbol]: Readonly<unknown>;
-                            } | undefined;
-                            readonly inject?: readonly string[] | {} | undefined;
-                            readonly filters?: {
-                                readonly [x: string]: Function;
-                            } | undefined;
-                            readonly mixins?: readonly any[] | undefined;
-                            readonly extends?: any;
-                            readonly beforeCreate?: (() => void) | undefined;
-                            readonly created?: (() => void) | undefined;
-                            readonly beforeMount?: (() => void) | undefined;
-                            readonly mounted?: (() => void) | undefined;
-                            readonly beforeUpdate?: (() => void) | undefined;
-                            readonly updated?: (() => void) | undefined;
-                            readonly activated?: (() => void) | undefined;
-                            readonly deactivated?: (() => void) | undefined;
-                            readonly beforeDestroy?: (() => void) | undefined;
-                            readonly beforeUnmount?: (() => void) | undefined;
-                            readonly destroyed?: (() => void) | undefined;
-                            readonly unmounted?: (() => void) | undefined;
-                            readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                            readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                            readonly delimiters?: readonly [string, string] | undefined;
-                            readonly __differentiator?: string | number | symbol | undefined;
-                            readonly __isBuiltIn?: boolean | undefined;
-                            readonly __file?: string | undefined;
-                            readonly __name?: string | undefined;
-                        };
-                        readonly meta?: {} | undefined;
-                    })[];
-                    readonly key: any;
-                    readonly path: {
-                        readonly path: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly query: {
-                        readonly query: any;
-                        readonly params: {} | {
-                            readonly [x: string]: any;
-                        } | {
-                            readonly [x: string]: any;
-                        };
-                        readonly toString: () => string;
-                    };
-                    readonly pathParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly queryParams: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly depth: number;
-                    readonly disabled: boolean;
-                }[] | undefined;
-                readonly component?: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                } | undefined;
-                readonly meta?: {} | undefined;
-            } | {
-                readonly onBeforeRouteEnter?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteUpdate?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onBeforeRouteLeave?: BeforeRouteHook | readonly BeforeRouteHook[] | undefined;
-                readonly onAfterRouteEnter?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteUpdate?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly onAfterRouteLeave?: AfterRouteHook | readonly AfterRouteHook[] | undefined;
-                readonly name: string;
-                readonly disabled?: boolean | undefined;
-                readonly path: string | {
-                    readonly path: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                };
-                readonly query?: string | {
-                    readonly query: any;
-                    readonly params: {} | {
-                        readonly [x: string]: any;
-                    } | {
-                        readonly [x: string]: any;
-                    };
-                    readonly toString: () => string;
-                } | undefined;
-                readonly component: FunctionalComponent<any, {}, any, {}> | {
-                    new (...args: any[]): any;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } | DefineComponent | AsyncComponentLoader | {
-                    readonly [x: string]: any;
-                    readonly setup?: ((this: void, props: LooseRequired<any>, ctx: {
-                        attrs: {
-                            [x: string]: unknown;
-                        };
-                        slots: Readonly<{
-                            [name: string]: Slot<any> | undefined;
-                        }>;
-                        emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
-                        expose: (exposed?: Record<string, any> | undefined) => void;
-                    }) => any) | undefined;
-                    readonly name?: string | undefined;
-                    readonly template?: string | object | undefined;
-                    readonly render?: Function | undefined;
-                    readonly components?: {
-                        readonly [x: string]: FunctionalComponent<any, {}, any, {}> | {
-                            new (...args: any[]): any;
-                            __isFragment?: undefined;
-                            __isTeleport?: undefined;
-                            __isSuspense?: undefined;
-                        } | any;
-                    } | undefined;
-                    readonly directives?: {
-                        readonly [x: string]: FunctionDirective<any, any> | {
-                            readonly created?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeMount?: DirectiveHook<any, null, any> | undefined;
-                            readonly mounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly beforeUpdate?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly updated?: DirectiveHook<any, VNode<any, any, {
-                            [key: string]: any;
-                            }>, any> | undefined;
-                            readonly beforeUnmount?: DirectiveHook<any, null, any> | undefined;
-                            readonly unmounted?: DirectiveHook<any, null, any> | undefined;
-                            readonly getSSRProps?: ((binding: DirectiveBinding<any>, vnode: VNode<RendererNode, RendererElement, {
-                            [key: string]: any;
-                            }>) => {
-                                [x: string]: unknown;
-                            } | undefined) | undefined;
-                            readonly deep?: boolean | undefined;
-                        };
-                    } | undefined;
-                    readonly inheritAttrs?: boolean | undefined;
-                    readonly emits?: any;
-                    readonly slots?: {} | undefined;
-                    readonly expose?: readonly string[] | undefined;
-                    readonly serverPrefetch?: (() => void | Promise<any>) | undefined;
-                    readonly compilerOptions?: {
-                        readonly isCustomElement?: ((tag: string) => boolean) | undefined;
-                        readonly whitespace?: "preserve" | "condense" | undefined;
-                        readonly comments?: boolean | undefined;
-                        readonly delimiters?: readonly [string, string] | undefined;
-                    } | undefined;
-                    readonly call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
-                    readonly __isFragment?: undefined;
-                    readonly __isTeleport?: undefined;
-                    readonly __isSuspense?: undefined;
-                    readonly __defaults?: any;
-                    readonly compatConfig?: {
-                        readonly GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_SET?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
-                        readonly GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
-                        readonly CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SET?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
-                        readonly INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
-                        readonly OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
-                        readonly WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
-                        readonly PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
-                        readonly V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
-                        readonly CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
-                        readonly ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
-                        readonly TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
-                        readonly COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
-                        readonly RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
-                        readonly FILTERS?: boolean | "suppress-warning" | undefined;
-                        readonly PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
-                        readonly MODE?: 2 | 3 | ((comp: Component<any, any, any, ComputedOptions, MethodOptions, {}, any> | null) => 2 | 3) | undefined;
-                    } | undefined;
-                    readonly data?: ((this: any, vm: any) => any) | undefined;
-                    readonly computed?: {
-                        readonly [x: string]: ComputedGetter<any> | {
-                            readonly get: ComputedGetter<any>;
-                            readonly set: ComputedSetter<any>;
-                        };
-                    } | undefined;
-                    readonly methods?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly watch?: {
-                        readonly [x: string]: string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        } | readonly (string | WatchCallback<any, any> | {
-                            readonly handler: string | WatchCallback<any, any>;
-                            readonly immediate?: boolean | undefined;
-                            readonly deep?: boolean | undefined;
-                            readonly once?: boolean | undefined;
-                            readonly flush?: "pre" | "post" | "sync" | undefined;
-                            readonly onTrack?: ((event: DebuggerEvent) => void) | undefined;
-                            readonly onTrigger?: ((event: DebuggerEvent) => void) | undefined;
-                        })[];
-                    } | undefined;
-                    readonly provide?: Function | {
-                        readonly [x: string]: Readonly<unknown>;
-                        readonly [x: symbol]: Readonly<unknown>;
-                    } | undefined;
-                    readonly inject?: readonly string[] | {} | undefined;
-                    readonly filters?: {
-                        readonly [x: string]: Function;
-                    } | undefined;
-                    readonly mixins?: readonly any[] | undefined;
-                    readonly extends?: any;
-                    readonly beforeCreate?: (() => void) | undefined;
-                    readonly created?: (() => void) | undefined;
-                    readonly beforeMount?: (() => void) | undefined;
-                    readonly mounted?: (() => void) | undefined;
-                    readonly beforeUpdate?: (() => void) | undefined;
-                    readonly updated?: (() => void) | undefined;
-                    readonly activated?: (() => void) | undefined;
-                    readonly deactivated?: (() => void) | undefined;
-                    readonly beforeDestroy?: (() => void) | undefined;
-                    readonly beforeUnmount?: (() => void) | undefined;
-                    readonly destroyed?: (() => void) | undefined;
-                    readonly unmounted?: (() => void) | undefined;
-                    readonly renderTracked?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly renderTriggered?: ((e: DebuggerEvent) => void) | undefined;
-                    readonly errorCaptured?: ((err: unknown, instance: ComponentPublicInstance<    {}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | undefined;
-                    readonly delimiters?: readonly [string, string] | undefined;
-                    readonly __differentiator?: string | number | symbol | undefined;
-                    readonly __isBuiltIn?: boolean | undefined;
-                    readonly __file?: string | undefined;
-                    readonly __name?: string | undefined;
-                };
-                readonly meta?: {} | undefined;
-            })[];
-            readonly key: any;
-            readonly query: {
-                readonly get: (key: string) => string | null;
-                readonly getAll: (key: string) => string[];
-            };
-            readonly params: {};
-        };
+        route: RouterRoute;
         component: RouteComponent;
     }) => unknown) | undefined;
 }>;
 
+/**
+ * Represents an immutable array of Route instances. Return value of `createRoutes`, expected param for `createRouter`.
+ */
 export declare type Routes = Readonly<Route[]>;
 
-export declare const routes: [Route<"parentA", Path<"/:paramA", {}>, Query<"", {}>, false>, Route<"parentA.childA", Path<"/:paramA/:?paramB", MergeParams<    {
-paramA: StringConstructor;
-}, {
-paramB: StringConstructor | undefined;
-}>>, Query<"", MergeParams<    {}, {}>>, false>, Route<"parentA.childA.grandChildA", Path<"/:paramA/:?paramB/:paramC", MergeParams<    {
-paramA: StringConstructor;
-}, {
-paramB: StringConstructor | undefined;
-paramC: StringConstructor;
-}>>, Query<"", MergeParams<    {}, {}>>, false>, Route<"parentA.childB", Path<"/:paramA/:paramD", MergeParams<    {
-paramA: StringConstructor;
-}, {
-paramD: StringConstructor;
-}>>, Query<"", MergeParams<    {}, {}>>, false>, Route<"parentB", Path<"/parentB", {}>, Query<"", {}>, false>];
-
-export declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
-
-export declare type RoutesMap<TRoutes extends Routes = []> = {
+declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
+
+declare type RoutesMap<TRoutes extends Routes = []> = {
     [K in TRoutes[number] as NamedNotDisabled<K> extends {
         key: string;
     } ? NamedNotDisabled<K>['key'] : never]: NamedNotDisabled<K>;
 };
 
-declare type RouteSortMethod = (aRoute: Route, bRoute: Route) => number;
-
-export declare function setParamValue(value: unknown, param: Param): string;
-
-export declare function setParamValueOnUrl(path: string, paramReplace?: ParamReplace): string;
-
-export declare function stringHasValue(value: string | undefined): boolean;
+declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = {
+    <TKey extends keyof TRoute['params']>(key: TKey, value: TRoute['params'][TKey], options?: RouterPushOptions): Promise<void>;
+    (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
+};
 
 declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
 
-export declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
-
-export declare function toPath<T extends string | Path>(value: T): ToPath<T>;
-
-export declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;
-
-export declare function toQuery<T extends string | Query | undefined>(value: T): ToQuery<T>;
+declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
 
-export declare type Url = `http://${string}` | `https://${string}` | `/${string}` | '/';
+declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;
 
-export declare function useParam<T>(param: string): Ref<T | undefined>;
-
-export declare function useParam<T>(param: string, defaultValue: T): Ref<T>;
-
-export declare function useParamRaw(param: string): Ref<string | undefined>;
-
-export declare function useParamRaw(param: string, defaultValue: string): Ref<string>;
+declare type Url = `http://${string}` | `https://${string}` | `/${string}` | '/';
 
+/**
+ * A composition to access the router's rejection state.
+ *
+ * @returns {RouterRejection} The rejection state object from the router, which can be used to handle route rejections
+ *          such as authentication failures or permission denials.
+ * @throws {Error} Throws an error if the router's rejection state is not available, typically indicating
+ *         that createRouter was never called.
+ */
 export declare function useRejection(): RouterRejection;
 
-export declare function useRoute<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: TRouteKey): DeepReadonly<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
-
-export declare function useRoute(): DeepReadonly<ResolvedRoute>;
-
-export declare function useRouteParam<TRoute extends Route, TParam extends keyof ExtractRouteParamTypes<TRoute>, TParamType = ExtractRouteParamTypes<TRoute>[TParam]>(_route: TRoute, _param: TParam, _defaultValue?: TParamType): Ref<TParamType>;
-
-export declare function useRouteParamRaw<TRoute extends Route, TParam extends keyof ExtractRouteParamTypes<TRoute>, TParamType extends ParamRawValue<ExtractRouteParamTypes<TRoute>[TParam]>>(_route: TRoute, _param: TParam, _defaultValue?: TParamType): Ref<ParamRawValue<TParamType>>;
+/**
+ * A composition to access the current route or verify a specific route key within a Vue component.
+ * This function provides two overloads:
+ * 1. When called without arguments, it returns the current route from the router without types.
+ * 2. When called with a route key, it checks if the current active route includes the specified route key.
+ *
+ * @template TRouteKey - A string type that should match route key of RegisteredRouteMap, ensuring the route key exists.
+ * @param routeKey - Optional. The key of the route to validate against the current active routes.
+ * @returns The current router route. If a route key is provided, it validates the route key first.
+ * @throws {UseRouteInvalidError} Throws an error if the provided route key is not valid or does not match the current route.
+ *
+ * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route key
+ * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
+ */
+export declare function useRoute<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: TRouteKey): RouterRoute<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
+
+export declare function useRoute(): RouterRoute;
+
+/**
+ * Represents an error thrown when there is a mismatch between an expected route and the one actually used.
+ */
+export declare class UseRouteInvalidError extends Error {
+    /**
+     * Constructs a new UseRouteInvalidError instance with a message that specifies both the given and expected route names.
+     * This detailed error message aids in quickly identifying and resolving mismatches in route usage.
+     * @param routeName - The route name that was incorrectly used.
+     * @param actualRouteName - The expected route name that should have been used.
+     */
+    constructor(routeName: string, actualRouteName: string);
+}
 
+/**
+ * A composition to access the registered router instance within a Vue component.
+ *
+ * @returns The registered router instance.
+ * @throws {RouterNotInstalledError} Throws an error if the router has not been installed,
+ *         ensuring the component does not operate without routing functionality.
+ */
 export declare function useRouter(): RegisteredRouter;
 
+/**
+ * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
+ */
 declare type WithHooks = {
     onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
     onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
@@ -4118,7 +964,9 @@ declare type WithOptionalProperties<T> = {
     [P in keyof T]-?: undefined extends T[P] ? P : never;
 }[keyof T];
 
-export declare function withQuery(url: string, query?: Record<string, string>): string;
+declare type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 
 export { }