@regle/schemas 1.10.1 → 1.11.0-beta.1

package/dist/regle-schemas.d.ts

@@ -1,28 +1,28 @@
 import * as vue0 from "vue";
-import { MaybeRef, MaybeRefOrGetter, Raw, Ref, UnwrapNestedRefs, UnwrapRef } from "vue";
+import { AllowedComponentProps, AnchorHTMLAttributes, App, Component as Component$1, ComponentCustomProps, ComponentPublicInstance, ComputedRef, DefineComponent, MaybeRef, MaybeRefOrGetter, Raw, Ref, ShallowRef, UnwrapNestedRefs, UnwrapRef, VNode, VNodeProps } from "vue";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region ../core/dist/regle-core.d.ts
 //#region src/types/utils/misc.types.d.ts
-type Prettify<T> = T extends infer R ? { [K in keyof R]: R[K] } & {} : never;
-type Maybe<T = any> = T | null | undefined;
-type MaybeInput<T = any> = T | null | undefined;
-type MaybeOutput<T = any> = T | undefined;
-type NonUndefined<T> = Exclude<T, undefined>;
-type PromiseReturn<T> = T extends Promise<infer U> ? U : T;
-type MaybeGetter<T, V$1 = any, TAdd extends Record<string, any> = {}> = T | ((value: Ref<V$1>, index: number) => T & TAdd);
-type Unwrap<T extends MaybeRef<Record<string, any>>> = T extends Ref ? UnwrapRef<T> : UnwrapNestedRefs<T>;
-type ExtractFromGetter<T extends MaybeGetter<any, any, any>> = T extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T;
-type ExtendOnlyRealRecord<T extends unknown> = NonNullable<T> extends File | Date ? false : NonNullable<T> extends Record<string, any> ? true : false;
-type OmitByType<T extends Record<string, any>, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
-type DeepMaybeRef<T extends Record<string, any>> = { [K in keyof T]: MaybeRef<T[K]> };
-type ExcludeByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] extends U$1 ? never : T[K] };
+type Prettify<T$1> = T$1 extends infer R ? { [K in keyof R]: R[K] } & {} : never;
+type Maybe<T$1 = any> = T$1 | null | undefined;
+type MaybeInput<T$1 = any> = T$1 | null | undefined;
+type MaybeOutput<T$1 = any> = T$1 | undefined;
+type NonUndefined<T$1> = Exclude<T$1, undefined>;
+type PromiseReturn<T$1> = T$1 extends Promise<infer U> ? U : T$1;
+type MaybeGetter<T$1, V$1 = any, TAdd extends Record<string, any> = {}> = T$1 | ((value: Ref<V$1>, index: number) => T$1 & TAdd);
+type Unwrap<T$1 extends MaybeRef<Record<string, any>>> = T$1 extends Ref ? UnwrapRef<T$1> : UnwrapNestedRefs<T$1>;
+type ExtractFromGetter<T$1 extends MaybeGetter<any, any, any>> = T$1 extends ((value: Ref<any>, index: number) => infer U extends Record<string, any>) ? U : T$1;
+type ExtendOnlyRealRecord<T$1 extends unknown> = NonNullable<T$1> extends File | Date ? false : NonNullable<T$1> extends Record<string, any> ? true : false;
+type OmitByType<T$1 extends Record<string, any>, U$1> = { [K in keyof T$1 as T$1[K] extends U$1 ? never : K]: T$1[K] };
+type DeepMaybeRef<T$1 extends Record<string, any>> = { [K in keyof T$1]: MaybeRef<T$1[K]> };
+type ExcludeByType<T$1, U$1> = { [K in keyof T$1 as T$1[K] extends U$1 ? never : K]: T$1[K] extends U$1 ? never : T$1[K] };
 type PrimitiveTypes = string | number | boolean | bigint | Date | File;
-type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File ? false : NonNullable<T> extends Record<string, any> ? true : false;
+type isRecordLiteral<T$1 extends unknown> = NonNullable<T$1> extends Date | File ? false : NonNullable<T$1> extends Record<string, any> ? true : false;
 type NoInferLegacy<A$1 extends any> = [A$1][A$1 extends any ? 0 : never];
 //#endregion
 //#region src/types/utils/Array.types.d.ts
-type ArrayElement<T> = T extends Array<infer U> ? U : never;
+type ArrayElement<T$1> = T$1 extends Array<infer U> ? U : never;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/primitive.d.ts
 /**
@@ -141,7 +141,7 @@ type Fail = IsEmptyObject<null>; //=> false
 @see {@link EmptyObject}
 @category Object
 */
-type IsEmptyObject<T> = T extends EmptyObject$1 ? true : false;
+type IsEmptyObject<T$1> = T$1 extends EmptyObject$1 ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-any.d.ts
 /**
@@ -172,7 +172,7 @@ const anyA = get(anyObject, 'a');
 @category Type Guard
 @category Utilities
 */
-type IsAny$1<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type IsAny$1<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
@@ -325,7 +325,7 @@ endIfEqual('abc', '123');
 @category Type Guard
 @category Utilities
 */
-type IsNever$1<T> = [T] extends [never] ? true : false;
+type IsNever$1<T$1> = [T$1] extends [never] ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/if.d.ts
 /**
@@ -435,7 +435,7 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-type HasMultipleCallSignatures$1<T extends (...arguments_: any[]) => unknown> = T extends {
+type HasMultipleCallSignatures$1<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
   (...arguments_: infer A): unknown;
   (...arguments_: infer B): unknown;
 } ? B extends A ? A extends B ? false : true : true : false;
@@ -483,7 +483,7 @@ type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
 //=> ''
 ```
 */
-type IfNotAnyOrNever<T, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If$1<IsAny$1<T>, IfAny, If$1<IsNever$1<T>, IfNever, IfNotAnyOrNever$1>>;
+type IfNotAnyOrNever<T$1, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If$1<IsAny$1<T$1>, IfAny, If$1<IsNever$1<T$1>, IfNever, IfNotAnyOrNever$1>>;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-null.d.ts
 /**
@@ -505,7 +505,7 @@ type Example2 = NonNullFallback<number, string>;
 @category Type Guard
 @category Utilities
 */
-type IsNull<T> = [T] extends [null] ? true : false;
+type IsNull<T$1> = [T$1] extends [null] ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-unknown.d.ts
 /**
@@ -551,8 +551,8 @@ store.execute((state, payload) => ({value: state.value + payload}), someExternal
 
 @category Utilities
 */
-type IsUnknown<T> = (unknown extends T // `T` can be `unknown` or `any`
-? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
+type IsUnknown<T$1> = (unknown extends T$1 // `T` can be `unknown` or `any`
+? IsNull<T$1> extends false // `any` can be `null`, but `unknown` can't be
 ? true : false : false);
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/internal/keys.d.ts
@@ -619,7 +619,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify$1<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify$1<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
@@ -1109,14 +1109,14 @@ partialShape.dimensions = [15]; // OK
 @category Set
 @category Map
 */
-type PartialDeep$1<T, Options extends PartialDeepOptions$1 = {}> = _PartialDeep$1<T, ApplyDefaultOptions$1<PartialDeepOptions$1, DefaultPartialDeepOptions$1, Options>>;
-type _PartialDeep$1<T, Options extends Required<PartialDeepOptions$1>> = T extends BuiltIns$1 | ((new (...arguments_: any[]) => unknown)) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep$1<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep$1<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep$1<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep$1<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? IsNever$1<keyof T> extends true ? T // For functions with no properties
-: HasMultipleCallSignatures$1<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep$1<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
-? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-? ReadonlyArray<_PartialDeep$1<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep$1<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep$1<T, Options> // Tuples behave properly
-: T // If they don't opt into array testing, just use the original type
-: PartialObjectDeep$1<T, Options> : unknown;
+type PartialDeep$1<T$1, Options extends PartialDeepOptions$1 = {}> = _PartialDeep$1<T$1, ApplyDefaultOptions$1<PartialDeepOptions$1, DefaultPartialDeepOptions$1, Options>>;
+type _PartialDeep$1<T$1, Options extends Required<PartialDeepOptions$1>> = T$1 extends BuiltIns$1 | ((new (...arguments_: any[]) => unknown)) ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? PartialMapDeep$1<KeyType, ValueType, Options> : T$1 extends Set<infer ItemType> ? PartialSetDeep$1<ItemType, Options> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep$1<KeyType, ValueType, Options> : T$1 extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep$1<ItemType, Options> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever$1<keyof T$1> extends true ? T$1 // For functions with no properties
+: HasMultipleCallSignatures$1<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & PartialObjectDeep$1<T$1, Options> : T$1 extends object ? T$1 extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+? Options['recurseIntoArrays'] extends true ? ItemType[] extends T$1 // Test for arrays (non-tuples) specifically
+? readonly ItemType[] extends T$1 // Differentiate readonly and mutable arrays
+? ReadonlyArray<_PartialDeep$1<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep$1<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep$1<T$1, Options> // Tuples behave properly
+: T$1 // If they don't opt into array testing, just use the original type
+: PartialObjectDeep$1<T$1, Options> : unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
@@ -1126,7 +1126,7 @@ type PartialMapDeep$1<KeyType$1, ValueType$1, Options extends Required<PartialDe
 /**
 Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialSetDeep$1<T, Options extends Required<PartialDeepOptions$1>> = {} & Set<_PartialDeep$1<T, Options>>;
+type PartialSetDeep$1<T$1, Options extends Required<PartialDeepOptions$1>> = {} & Set<_PartialDeep$1<T$1, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
@@ -1136,7 +1136,7 @@ type PartialReadonlyMapDeep$1<KeyType$1, ValueType$1, Options extends Required<P
 /**
 Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialReadonlySetDeep$1<T, Options extends Required<PartialDeepOptions$1>> = {} & ReadonlySet<_PartialDeep$1<T, Options>>;
+type PartialReadonlySetDeep$1<T$1, Options extends Required<PartialDeepOptions$1>> = {} & ReadonlySet<_PartialDeep$1<T$1, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
@@ -1197,7 +1197,7 @@ type Last = LastOfUnion<1 | 2 | 3>;
 //=> 3
 ```
 */
-type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
+type LastOfUnion<T$1> = UnionToIntersection<T$1 extends any ? () => T$1 : never> extends (() => (infer R)) ? R : never;
 
 /**
 Convert a union type into an unordered tuple type of its elements.
@@ -1234,7 +1234,7 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-type UnionToTuple<T, L = LastOfUnion<T>> = IsNever$1<T> extends false ? [...UnionToTuple<Exclude<T, L>>, L] : [];
+type UnionToTuple<T$1, L = LastOfUnion<T$1>> = IsNever$1<T$1> extends false ? [...UnionToTuple<Exclude<T$1, L>>, L] : [];
 //#endregion
 //#region src/types/core/modifiers.types.d.ts
 interface RegleBehaviourOptions {
@@ -1272,6 +1272,11 @@ interface RegleBehaviourOptions {
    *
    */
   clearExternalErrorsOnChange?: boolean | undefined;
+  /**
+   * A unique identifier for the Regle instance in the devtools.
+   * @default undefined
+   */
+  id?: string | undefined;
 }
 interface LocalRegleBehaviourOptions<TState$1 extends Record<string, any>, TRules$1 extends ReglePartialRuleTree<TState$1, CustomRulesDeclarationTree>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = {}> {
   externalErrors?: Ref<RegleExternalErrorTree<Unwrap<TState$1>> | Record<string, string[]>>;
@@ -1303,8 +1308,8 @@ type CollectionRegleBehaviourOptions = FieldRegleBehaviourOptions & {
    * */
   $deepCompare?: boolean;
 };
-type ShortcutCommonFn<T extends Record<string, any>> = {
-  [x: string]: (element: Omit<OmitByType<T, Function>, '~standard'>) => unknown;
+type ShortcutCommonFn<T$1 extends Record<string, any>> = {
+  [x: string]: (element: Omit<OmitByType<T$1, Function>, '~standard'>) => unknown;
 };
 type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
   /**
@@ -1320,7 +1325,7 @@ type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
    */
   collections?: ShortcutCommonFn<RegleCollectionStatus<any[], Partial<TCustomRules> & Partial<DefaultValidators>>>;
 };
-type AddDollarToOptions<T extends Record<string, any>> = { [K in keyof T as `$${string & K}`]: T[K] };
+type AddDollarToOptions<T$1 extends Record<string, any>> = { [K in keyof T$1 as `$${string & K}`]: T$1[K] };
 //#endregion
 //#region src/types/core/useRegle.types.d.ts
 /**
@@ -1357,7 +1362,7 @@ type RegleSingleField<TState$1 extends Maybe<PrimitiveTypes> = any, TRules$1 ext
    */
   r$: Raw<RegleFieldStatus<TState$1, TRules$1, TShortcuts>>;
 } & TAdditionalReturnProperties;
-type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T> extends true ? { [K in keyof T]: InferDeepReactiveState<T[K]> } : never;
+type DeepReactiveState<T$1 extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T$1> extends true ? { [K in keyof T$1]: InferDeepReactiveState<T$1[K]> } : never;
 type InferDeepReactiveState<TState$1> = NonNullable<TState$1> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState$1> extends Date | File ? MaybeRef<TState$1> : NonNullable<TState$1> extends Record<string, any> ? DeepReactiveState<TState$1> : MaybeRef<TState$1>;
 //#endregion
 //#region src/types/core/reset.types.d.ts
@@ -1461,11 +1466,11 @@ type SafeFieldProperty<TState$1, TRule extends RegleFormPropertyType<any, any> |
 /**
  * Negates a boolean type.
  */
-type Not<T extends boolean> = T extends true ? false : true;
+type Not<T$1 extends boolean> = T$1 extends true ? false : true;
 /**
  * Checks if the given type is `never`.
  */
-type IsNever$2<T> = [T] extends [never] ? true : false;
+type IsNever$2<T$1> = [T$1] extends [never] ? true : false;
 /**
  * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
  * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
@@ -1493,7 +1498,7 @@ type TuplifyUnion<Union, LastElement = LastOf<Union>> = IsNever$2<Union> extends
  * Convert a union like `1 | 2 | 3` to a tuple like `[1, 2, 3]`.
  */
 type UnionToTuple$1<Union> = TuplifyUnion<Union>;
-type IsUnion<T> = Not<Extends<UnionToTuple$1<T>['length'], 1>>;
+type IsUnion<T$1> = Not<Extends<UnionToTuple$1<T$1>['length'], 1>>;
 //#endregion
 //#region src/types/core/variants.types.d.ts
 
@@ -1547,10 +1552,10 @@ type ExactObject<TInfer, TTree> = { [K in keyof TTree]: NonNullable<TTree[K]> ex
 type TypeError<Msg> = {
   [' TypeError']: Msg;
 };
-type Coerce<T> = `${T & string}`;
+type Coerce<T$1> = `${T$1 & string}`;
 //#endregion
 //#region src/types/utils/object.types.d.ts
-type RemoveCommonKey<T extends readonly any[], K$1 extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K$1>>, ...RemoveCommonKey<R, K$1>] : [];
+type RemoveCommonKey<T$1 extends readonly any[], K$1 extends PropertyKey> = T$1 extends [infer F, ...infer R] ? [Prettify<Omit<F, K$1>>, ...RemoveCommonKey<R, K$1>] : [];
 /**
  * Restore the optional properties (with ?) of a generated mapped object type
  */
@@ -1567,11 +1572,11 @@ type GetMaybeObjectValue<O extends Record<string, any>, K$1 extends string> = K$
 /**
  * Combine all union values to be able to get even the normally "never" values, act as an intersection type
  */
-type RetrieveUnionUnknownValues<T extends readonly any[], TKeys extends string> = T extends [infer F extends Record<string, any>, ...infer R] ? [{ [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K> } & { [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K> }, ...RetrieveUnionUnknownValues<R, TKeys>] : [];
+type RetrieveUnionUnknownValues<T$1 extends readonly any[], TKeys extends string> = T$1 extends [infer F extends Record<string, any>, ...infer R] ? [{ [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K> } & { [K in TKeys as GetMaybeObjectValue<F, K> extends NonUndefined<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K> }, ...RetrieveUnionUnknownValues<R, TKeys>] : [];
 /**
  * Get all possible keys from a union, even the ones present only on one union
  */
-type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
+type RetrieveUnionUnknownKeysOf<T$1 extends readonly any[]> = T$1 extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
 /**
  * Transforms a union and apply undefined values to non-present keys to support intersection
  */
@@ -1585,23 +1590,23 @@ type EnumLike = {
   [k: string]: string | number;
   [nu: number]: string;
 };
-type UnwrapMaybeRef<T extends MaybeRef<any> | DeepReactiveState<any>> = T extends Ref<any> ? UnwrapRef<T> : UnwrapNestedRefs<T>;
-type TupleToPlainObj<T> = { [I in keyof T & `${number}`]: T[I] };
-type HasNamedKeys<T> = IsUnion<T> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T>> : ProcessHasNamedKeys<T>;
-type ProcessHasNamedKeys<T> = { [K in keyof NonNullable<T>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T>] extends never ? false : true;
+type UnwrapMaybeRef<T$1 extends MaybeRef<any> | DeepReactiveState<any>> = T$1 extends Ref<any> ? UnwrapRef<T$1> : UnwrapNestedRefs<T$1>;
+type TupleToPlainObj<T$1> = { [I in keyof T$1 & `${number}`]: T$1[I] };
+type HasNamedKeys<T$1> = IsUnion<T$1> extends true ? ProcessHasNamedKeys<LazyJoinDiscriminatedUnions<T$1>> : ProcessHasNamedKeys<T$1>;
+type ProcessHasNamedKeys<T$1> = { [K in keyof NonNullable<T$1>]: K extends string ? (string extends K ? never : K) : never }[keyof NonNullable<T$1>] extends never ? false : true;
 //#endregion
 //#region src/types/utils/infer.types.d.ts
 
 //#endregion
 //#region src/types/rules/rule.params.types.d.ts
-type CreateFn<T extends any[]> = (...args: T) => any;
+type CreateFn<T$1 extends any[]> = (...args: T$1) => any;
 /**
  * Transform normal parameters tuple declaration to a rich tuple declaration
  *
  * [foo: string, bar?: number] => [foo: MaybeRef<string> | (() => string), bar?: MaybeRef<number | undefined> | (() => number) | undefined]
  */
-type RegleUniversalParams<T extends any[] = [], F$1 = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: MaybeRefOrGetter<Maybe<Args[K]>> }) => any : never>;
-type UnwrapRegleUniversalParams<T extends MaybeRefOrGetter[] = [], F$1 = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: Args[K] extends MaybeRefOrGetter<Maybe<infer U>> ? U : Args[K] }) => any : never>;
+type RegleUniversalParams<T$1 extends any[] = [], F$1 = CreateFn<T$1>> = [T$1] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: MaybeRefOrGetter<Maybe<Args[K]>> }) => any : never>;
+type UnwrapRegleUniversalParams<T$1 extends MaybeRefOrGetter[] = [], F$1 = CreateFn<T$1>> = [T$1] extends [[]] ? [] : Parameters<F$1 extends ((...args: infer Args) => any) ? (...args: { [K in keyof Args]: Args[K] extends MaybeRefOrGetter<Maybe<infer U>> ? U : Args[K] }) => any : never>;
 //#endregion
 //#region src/types/rules/rule.internal.types.d.ts
 /**
@@ -1621,7 +1626,7 @@ type RegleInternalRuleDefs<TValue$1 extends any = any, TParams$1 extends any[] =
 }>;
 //#endregion
 //#region src/types/rules/rule.definition.type.d.ts
-type IsLiteral<T> = string extends T ? false : true;
+type IsLiteral<T$1> = string extends T$1 ? false : true;
 /**
  * Returned typed of rules created with `createRule`
  * */
@@ -2167,6 +2172,7 @@ type SuperCompatibleRegleStatus = {
   readonly $silentErrors: Record<string, RegleValidationErrors<any, false>>;
   $extractDirtyFields: (filterNullishValues?: boolean) => Record<string, any>;
   $validate?: () => Promise<SuperCompatibleRegleResult>;
+  $reset: (options?: ResetOptions<unknown>) => void;
   [x: string]: any;
 };
 //#endregion
@@ -2260,6 +2266,1436 @@ type CreateScopedUseRegleOptions<TCustomRegle extends useRegleFn<any, any>, TAsR
   asRecord?: TAsRecord;
 };
 //#endregion
+//#region ../../node_modules/.pnpm/vue-router@4.6.3_vue@3.5.22_typescript@5.9.3_/node_modules/vue-router/dist/router-BbqN7H95.d.mts
+//#region src/query.d.ts
+
+/**
+ * Possible values in normalized {@link LocationQuery}. `null` renders the query
+ * param but without an `=`.
+ *
+ * @example
+ * ```
+ * ?isNull&isEmpty=&other=other
+ * gives
+ * `{ isNull: null, isEmpty: '', other: 'other' }`.
+ * ```
+ *
+ * @internal
+ */
+type LocationQueryValue = string | null;
+/**
+ * Possible values when defining a query. `undefined` allows to remove a value.
+ *
+ * @internal
+ */
+type LocationQueryValueRaw = LocationQueryValue | number | undefined;
+/**
+ * Normalized query object that appears in {@link RouteLocationNormalized}
+ *
+ * @public
+ */
+type LocationQuery = Record<string, LocationQueryValue | LocationQueryValue[]>;
+/**
+ * Loose {@link LocationQuery} object that can be passed to functions like
+ * {@link Router.push} and {@link Router.replace} or anywhere when creating a
+ * {@link RouteLocationRaw}
+ *
+ * @public
+ */
+type LocationQueryRaw = Record<string | number, LocationQueryValueRaw | LocationQueryValueRaw[]>;
+/**
+ * Transforms a queryString into a {@link LocationQuery} object. Accept both, a
+ * version with the leading `?` and without Should work as URLSearchParams
+
+ * @internal
+ *
+ * @param search - search string to parse
+ * @returns a query object
+ */
+declare function parseQuery(search: string): LocationQuery;
+/**
+ * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it
+ * doesn't prepend a `?`
+ *
+ * @internal
+ *
+ * @param query - query object to stringify
+ * @returns string version of the query without the leading `?`
+ */
+declare function stringifyQuery(query: LocationQueryRaw | undefined): string;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Allows customizing existing types of the router that are used globally like `$router`, `<RouterLink>`, etc. **ONLY FOR INTERNAL USAGE**.
+ *
+ * - `$router` - the router instance
+ * - `$route` - the current route location
+ * - `beforeRouteEnter` - Page component option
+ * - `beforeRouteUpdate` - Page component option
+ * - `beforeRouteLeave` - Page component option
+ * - `RouterLink` - RouterLink Component
+ * - `RouterView` - RouterView Component
+ *
+ * @internal
+ */
+interface TypesConfig {}
+//#endregion
+//#region src/typed-routes/route-map.d.ts
+/**
+ * Helper type to define a Typed `RouteRecord`
+ * @see {@link RouteRecord}
+ */
+interface RouteRecordInfo<Name extends string | symbol = string, Path extends string = string, ParamsRaw extends RouteParamsRawGeneric = RouteParamsRawGeneric, Params$1 extends RouteParamsGeneric = RouteParamsGeneric, ChildrenNames extends string | symbol = never> {
+  name: Name;
+  path: Path;
+  paramsRaw: ParamsRaw;
+  params: Params$1;
+  childrenNames: ChildrenNames;
+}
+type RouteRecordInfoGeneric = RouteRecordInfo<string | symbol, string, RouteParamsRawGeneric, RouteParamsGeneric, string | symbol>;
+/**
+ * Convenience type to get the typed RouteMap or a generic one if not provided. It is extracted from the {@link TypesConfig} if it exists, it becomes {@link RouteMapGeneric} otherwise.
+ */
+type RouteMap = TypesConfig extends Record<'RouteNamedMap', infer RouteNamedMap> ? RouteNamedMap : RouteMapGeneric;
+/**
+ * Generic version of the `RouteMap`.
+ */
+type RouteMapGeneric = Record<string | symbol, RouteRecordInfoGeneric>;
+//#endregion
+//#region src/types/utils.d.ts
+/**
+ * Creates a union type that still allows autocompletion for strings.
+ * @internal
+ */
+type _LiteralUnion<LiteralType, BaseType extends string = string> = LiteralType | (BaseType & Record<never, never>);
+/**
+ * Maybe a promise maybe not
+ * @internal
+ */
+type _Awaitable<T$1> = T$1 | PromiseLike<T$1>;
+/**
+ * @internal
+ */
+
+//#endregion
+//#region src/typed-routes/route-records.d.ts
+/**
+ * @internal
+ */
+type RouteRecordRedirectOption = RouteLocationRaw | ((to: RouteLocation, from: RouteLocationNormalizedLoaded) => RouteLocationRaw);
+/**
+ * Generic version of {@link RouteRecordName}.
+ */
+type RouteRecordNameGeneric = string | symbol | undefined;
+/**
+ * Possible values for a route record **after normalization**
+ *
+ * NOTE: since `RouteRecordName` is a type, it evaluates too early and it's often the generic version {@link RouteRecordNameGeneric}. If you need a typed version of all of the names of routes, use {@link RouteMap | `keyof RouteMap`}
+ */
+
+/**
+ * @internal
+ */
+type _RouteRecordProps<Name extends keyof RouteMap = keyof RouteMap> = boolean | Record<string, any> | ((to: RouteLocationNormalized<Name>) => Record<string, any>);
+//#endregion
+//#region src/typed-routes/route-location.d.ts
+/**
+ * Generic version of {@link RouteLocation}. It is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationGeneric extends _RouteLocationBase, RouteLocationOptions {
+  /**
+   * Array of {@link RouteRecord} containing components as they were
+   * passed when adding records. It can also contain redirect records. This
+   * can't be used directly. **This property is non-enumerable**.
+   */
+  matched: RouteRecord[];
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocation} type.
+ */
+interface RouteLocationTyped<RouteMap$1 extends RouteMapGeneric, Name extends keyof RouteMap$1> extends RouteLocationGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap$1[Name]['params'];
+}
+/**
+ * List of all possible {@link RouteLocation} indexed by the route name.
+ * @internal
+ */
+type RouteLocationTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationTyped<RouteMap$1, N> };
+/**
+ * Generic version of {@link RouteLocationNormalized} that is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationNormalizedGeneric extends _RouteLocationBase {
+  name: RouteRecordNameGeneric;
+  /**
+   * Array of {@link RouteRecordNormalized}
+   */
+  matched: RouteRecordNormalized[];
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationNormalized} type.
+ */
+interface RouteLocationNormalizedTyped<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap$1 = keyof RouteMap$1> extends RouteLocationNormalizedGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap$1[Name]['params'];
+  /**
+   * Array of {@link RouteRecordNormalized}
+   */
+  matched: RouteRecordNormalized[];
+}
+/**
+ * List of all possible {@link RouteLocationNormalized} indexed by the route name.
+ * @internal
+ */
+type RouteLocationNormalizedTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationNormalizedTyped<RouteMap$1, N> };
+/**
+ * Generic version of {@link RouteLocationNormalizedLoaded} that is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationNormalizedLoadedGeneric extends RouteLocationNormalizedGeneric {
+  /**
+   * Array of {@link RouteLocationMatched} containing only plain components (any
+   * lazy-loaded components have been loaded and were replaced inside the
+   * `components` object) so it can be directly used to display routes. It
+   * cannot contain redirect records either. **This property is non-enumerable**.
+   */
+  matched: RouteLocationMatched[];
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationNormalizedLoaded} type.
+ */
+interface RouteLocationNormalizedLoadedTyped<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap$1 = keyof RouteMap$1> extends RouteLocationNormalizedLoadedGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap$1[Name]['params'];
+}
+/**
+ * List of all possible {@link RouteLocationNormalizedLoaded} indexed by the route name.
+ * @internal
+ */
+type RouteLocationNormalizedLoadedTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationNormalizedLoadedTyped<RouteMap$1, N> };
+/**
+ * Generic version of {@link RouteLocationAsRelative}. It is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationAsRelativeGeneric extends RouteQueryAndHash, RouteLocationOptions {
+  name?: RouteRecordNameGeneric;
+  params?: RouteParamsRawGeneric;
+  /**
+   * A relative path to the current location. This property should be removed
+   */
+  path?: undefined;
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationAsRelative} type.
+ */
+interface RouteLocationAsRelativeTyped<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap$1 = keyof RouteMap$1> extends RouteLocationAsRelativeGeneric {
+  name?: Extract<Name, string | symbol>;
+  params?: RouteMap$1[Name]['paramsRaw'];
+}
+/**
+ * List of all possible {@link RouteLocationAsRelative} indexed by the route name.
+ * @internal
+ */
+type RouteLocationAsRelativeTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationAsRelativeTyped<RouteMap$1, N> };
+/**
+ * Generic version of {@link RouteLocationAsPath}. It is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationAsPathGeneric extends RouteQueryAndHash, RouteLocationOptions {
+  /**
+   * Percentage encoded pathname section of the URL.
+   */
+  path: string;
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationAsPath} type.
+ */
+interface RouteLocationAsPathTyped<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap$1 = keyof RouteMap$1> extends RouteLocationAsPathGeneric {
+  path: _LiteralUnion<RouteMap$1[Name]['path']>;
+}
+/**
+ * List of all possible {@link RouteLocationAsPath} indexed by the route name.
+ * @internal
+ */
+type RouteLocationAsPathTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationAsPathTyped<RouteMap$1, N> };
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationAsString} type.
+ */
+type RouteLocationAsStringTyped<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap$1 = keyof RouteMap$1> = RouteMap$1[Name]['path'];
+/**
+ * List of all possible {@link RouteLocationAsString} indexed by the route name.
+ * @internal
+ */
+type RouteLocationAsStringTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationAsStringTyped<RouteMap$1, N> };
+/**
+ * Generic version of {@link RouteLocationResolved}. It is used when no {@link RouteMap} is provided.
+ */
+interface RouteLocationResolvedGeneric extends RouteLocationGeneric {
+  /**
+   * Resolved `href` for the route location that will be set on the `<a href="...">`.
+   */
+  href: string;
+}
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationResolved} type.
+ */
+interface RouteLocationResolvedTyped<RouteMap$1 extends RouteMapGeneric, Name extends keyof RouteMap$1> extends RouteLocationTyped<RouteMap$1, Name> {
+  /**
+   * Resolved `href` for the route location that will be set on the `<a href="...">`.
+   */
+  href: string;
+}
+/**
+ * List of all possible {@link RouteLocationResolved} indexed by the route name.
+ * @internal
+ */
+type RouteLocationResolvedTypedList<RouteMap$1 extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap$1]: RouteLocationResolvedTyped<RouteMap$1, N> };
+/**
+ * Type safe versions of types that are exposed by vue-router. We have to use a generic check to allow for names to be `undefined` when no `RouteMap` is provided.
+ */
+/**
+ * {@link RouteLocationRaw} resolved using the matcher
+ */
+type RouteLocation<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationGeneric : RouteLocationTypedList<RouteMap>[Name];
+/**
+ * Similar to {@link RouteLocation} but its
+ * {@link RouteLocationNormalizedTyped.matched | `matched` property} cannot contain redirect records
+ */
+type RouteLocationNormalized<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationNormalizedGeneric : RouteLocationNormalizedTypedList<RouteMap>[Name];
+/**
+ * Similar to {@link RouteLocationNormalized} but its `components` do not contain any function to lazy load components.
+ * In other words, it's ready to be rendered by `<RouterView>`.
+ */
+type RouteLocationNormalizedLoaded<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationNormalizedLoadedGeneric : RouteLocationNormalizedLoadedTypedList<RouteMap>[Name];
+/**
+ * Route location relative to the current location. It accepts other properties than `path` like `params`, `query` and
+ * `hash` to conveniently change them.
+ */
+type RouteLocationAsRelative<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationAsRelativeGeneric : RouteLocationAsRelativeTypedList<RouteMap>[Name];
+/**
+ * Route location resolved with {@link Router | `router.resolve()`}.
+ */
+type RouteLocationResolved<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationResolvedGeneric : RouteLocationResolvedTypedList<RouteMap>[Name];
+/**
+ * Same as {@link RouteLocationAsPath} but as a string literal.
+ */
+type RouteLocationAsString<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? string : _LiteralUnion<RouteLocationAsStringTypedList<RouteMap>[Name], string>;
+/**
+ * Route location as an object with a `path` property.
+ */
+type RouteLocationAsPath<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationAsPathGeneric : RouteLocationAsPathTypedList<RouteMap>[Name];
+/**
+ * Route location that can be passed to `router.push()` and other user-facing APIs.
+ */
+type RouteLocationRaw<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationAsString | RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric : _LiteralUnion<RouteLocationAsStringTypedList<RouteMap>[Name], string> | RouteLocationAsRelativeTypedList<RouteMap>[Name] | RouteLocationAsPathTypedList<RouteMap>[Name];
+//#endregion
+//#region src/typed-routes/navigation-guards.d.ts
+/**
+ * Return types for a Navigation Guard. Based on `TypesConfig`
+ *
+ * @see {@link TypesConfig}
+ */
+type NavigationGuardReturn = void | Error | boolean | RouteLocationRaw;
+/**
+ * Navigation Guard with a type parameter for `this`.
+ * @see {@link TypesConfig}
+ */
+interface NavigationGuardWithThis<T$1> {
+  (this: T$1, to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext): _Awaitable<NavigationGuardReturn>;
+}
+/**
+ * Navigation Guard.
+ */
+interface NavigationGuard {
+  (to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext): _Awaitable<NavigationGuardReturn>;
+}
+/**
+ * Navigation hook triggered after a navigation is settled.
+ */
+interface NavigationHookAfter {
+  (to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, failure?: NavigationFailure | void): unknown;
+}
+/**
+ * `next()` callback passed to navigation guards.
+ */
+interface NavigationGuardNext {
+  (): void;
+  (error: Error): void;
+  (location: RouteLocationRaw): void;
+  (valid: boolean | undefined): void;
+  (cb: NavigationGuardNextCallback): void;
+}
+/**
+ * Callback that can be passed to `next()` in `beforeRouteEnter()` guards.
+ */
+type NavigationGuardNextCallback = (vm: ComponentPublicInstance) => unknown;
+//#endregion
+//#region src/matcher/types.d.ts
+/**
+ * Normalized version of a {@link RouteRecord | route record}.
+ */
+interface RouteRecordNormalized {
+  /**
+   * {@inheritDoc _RouteRecordBase.path}
+   */
+  path: _RouteRecordBase['path'];
+  /**
+   * {@inheritDoc _RouteRecordBase.redirect}
+   */
+  redirect: _RouteRecordBase['redirect'] | undefined;
+  /**
+   * {@inheritDoc _RouteRecordBase.name}
+   */
+  name: _RouteRecordBase['name'];
+  /**
+   * {@inheritDoc RouteRecordMultipleViews.components}
+   */
+  components: RouteRecordMultipleViews['components'] | null | undefined;
+  /**
+   * Contains the original modules for lazy loaded components.
+   * @internal
+   */
+  mods: Record<string, unknown>;
+  /**
+   * Nested route records.
+   */
+  children: RouteRecordRaw[];
+  /**
+   * {@inheritDoc _RouteRecordBase.meta}
+   */
+  meta: Exclude<_RouteRecordBase['meta'], void>;
+  /**
+   * {@inheritDoc RouteRecordMultipleViews.props}
+   */
+  props: Record<string, _RouteRecordProps>;
+  /**
+   * Registered beforeEnter guards
+   */
+  beforeEnter: _RouteRecordBase['beforeEnter'];
+  /**
+   * Registered leave guards
+   *
+   * @internal
+   */
+  leaveGuards: Set<NavigationGuard>;
+  /**
+   * Registered update guards
+   *
+   * @internal
+   */
+  updateGuards: Set<NavigationGuard>;
+  /**
+   * Registered beforeRouteEnter callbacks passed to `next` or returned in guards
+   *
+   * @internal
+   */
+  enterCallbacks: Record<string, NavigationGuardNextCallback[]>;
+  /**
+   * Mounted route component instances
+   * Having the instances on the record mean beforeRouteUpdate and
+   * beforeRouteLeave guards can only be invoked with the latest mounted app
+   * instance if there are multiple application instances rendering the same
+   * view, basically duplicating the content on the page, which shouldn't happen
+   * in practice. It will work if multiple apps are rendering different named
+   * views.
+   */
+  instances: Record<string, ComponentPublicInstance | undefined | null>;
+  /**
+   * Defines if this record is the alias of another one. This property is
+   * `undefined` if the record is the original one.
+   */
+  aliasOf: RouteRecordNormalized | undefined;
+}
+/**
+ * {@inheritDoc RouteRecordNormalized}
+ */
+type RouteRecord = RouteRecordNormalized;
+//#endregion
+//#region src/matcher/pathParserRanker.d.ts
+
+/**
+ * @internal
+ */
+interface _PathParserOptions {
+  /**
+   * Makes the RegExp case-sensitive.
+   *
+   * @defaultValue `false`
+   */
+  sensitive?: boolean;
+  /**
+   * Whether to disallow a trailing slash or not.
+   *
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+  /**
+   * Should the RegExp match from the beginning by prepending a `^` to it.
+   * @internal
+   *
+   * @defaultValue `true`
+   */
+  start?: boolean;
+  /**
+   * Should the RegExp match until the end by appending a `$` to it.
+   *
+   * @deprecated this option will alsways be `true` in the future. Open a discussion in vuejs/router if you need this to be `false`
+   *
+   * @defaultValue `true`
+   */
+  end?: boolean;
+}
+type PathParserOptions = Pick<_PathParserOptions, 'end' | 'sensitive' | 'strict'>;
+//#endregion
+//#region src/matcher/pathMatcher.d.ts
+
+//#endregion
+//#region src/history/common.d.ts
+type HistoryLocation = string;
+/**
+ * Allowed variables in HTML5 history state. Note that pushState clones the state
+ * passed and does not accept everything: e.g.: it doesn't accept symbols, nor
+ * functions as values. It also ignores Symbols as keys.
+ *
+ * @internal
+ */
+type HistoryStateValue = string | number | boolean | null | undefined | HistoryState | HistoryStateArray;
+/**
+ * Allowed HTML history.state
+ */
+interface HistoryState {
+  [x: number]: HistoryStateValue;
+  [x: string]: HistoryStateValue;
+}
+/**
+ * Allowed arrays for history.state.
+ *
+ * @internal
+ */
+interface HistoryStateArray extends Array<HistoryStateValue> {}
+declare enum NavigationType {
+  pop = "pop",
+  push = "push",
+}
+declare enum NavigationDirection {
+  back = "back",
+  forward = "forward",
+  unknown = "",
+}
+interface NavigationInformation {
+  type: NavigationType;
+  direction: NavigationDirection;
+  delta: number;
+}
+interface NavigationCallback {
+  (to: HistoryLocation, from: HistoryLocation, information: NavigationInformation): void;
+}
+/**
+ * Interface implemented by History implementations that can be passed to the
+ * router as {@link Router.history}
+ *
+ * @alpha
+ */
+interface RouterHistory {
+  /**
+   * Base path that is prepended to every url. This allows hosting an SPA at a
+   * sub-folder of a domain like `example.com/sub-folder` by having a `base` of
+   * `/sub-folder`
+   */
+  readonly base: string;
+  /**
+   * Current History location
+   */
+  readonly location: HistoryLocation;
+  /**
+   * Current History state
+   */
+  readonly state: HistoryState;
+  /**
+   * Navigates to a location. In the case of an HTML5 History implementation,
+   * this will call `history.pushState` to effectively change the URL.
+   *
+   * @param to - location to push
+   * @param data - optional {@link HistoryState} to be associated with the
+   * navigation entry
+   */
+  push(to: HistoryLocation, data?: HistoryState): void;
+  /**
+   * Same as {@link RouterHistory.push} but performs a `history.replaceState`
+   * instead of `history.pushState`
+   *
+   * @param to - location to set
+   * @param data - optional {@link HistoryState} to be associated with the
+   * navigation entry
+   */
+  replace(to: HistoryLocation, data?: HistoryState): void;
+  /**
+   * Traverses history in a given direction.
+   *
+   * @example
+   * ```js
+   * myHistory.go(-1) // equivalent to window.history.back()
+   * myHistory.go(1) // equivalent to window.history.forward()
+   * ```
+   *
+   * @param delta - distance to travel. If delta is \< 0, it will go back,
+   * if it's \> 0, it will go forward by that amount of entries.
+   * @param triggerListeners - whether this should trigger listeners attached to
+   * the history
+   */
+  go(delta: number, triggerListeners?: boolean): void;
+  /**
+   * Attach a listener to the History implementation that is triggered when the
+   * navigation is triggered from outside (like the Browser back and forward
+   * buttons) or when passing `true` to {@link RouterHistory.back} and
+   * {@link RouterHistory.forward}
+   *
+   * @param callback - listener to attach
+   * @returns a callback to remove the listener
+   */
+  listen(callback: NavigationCallback): () => void;
+  /**
+   * Generates the corresponding href to be used in an anchor tag.
+   *
+   * @param location - history location that should create an href
+   */
+  createHref(location: HistoryLocation): string;
+  /**
+   * Clears any event listener attached by the history implementation.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/types/index.d.ts
+type Lazy<T$1> = () => Promise<T$1>;
+/**
+ * @internal
+ */
+type RouteParamValue = string;
+/**
+ * @internal
+ */
+type RouteParamValueRaw = RouteParamValue | number | null | undefined;
+type RouteParamsGeneric = Record<string, RouteParamValue | RouteParamValue[]>;
+type RouteParamsRawGeneric = Record<string, RouteParamValueRaw | Exclude<RouteParamValueRaw, null | undefined>[]>;
+/**
+ * @internal
+ */
+interface RouteQueryAndHash {
+  query?: LocationQueryRaw;
+  hash?: string;
+}
+/**
+ * @internal
+ */
+
+/**
+ * Common options for all navigation methods.
+ */
+interface RouteLocationOptions {
+  /**
+   * Replace the entry in the history instead of pushing a new entry
+   */
+  replace?: boolean;
+  /**
+   * Triggers the navigation even if the location is the same as the current one.
+   * Note this will also add a new entry to the history unless `replace: true`
+   * is passed.
+   */
+  force?: boolean;
+  /**
+   * State to save using the History API. This cannot contain any reactive
+   * values and some primitives like Symbols are forbidden. More info at
+   * https://developer.mozilla.org/en-US/docs/Web/API/History/state
+   */
+  state?: HistoryState;
+}
+/**
+ * Route Location that can infer the necessary params based on the name.
+ *
+ * @internal
+ */
+
+interface RouteLocationMatched extends RouteRecordNormalized {
+  components: Record<string, RouteComponent> | null | undefined;
+}
+/**
+ * Base properties for a normalized route location.
+ *
+ * @internal
+ */
+interface _RouteLocationBase extends Pick<MatcherLocation, 'name' | 'path' | 'params' | 'meta'> {
+  /**
+   * The whole location including the `search` and `hash`. This string is
+   * percentage encoded.
+   */
+  fullPath: string;
+  /**
+   * Object representation of the `search` property of the current location.
+   */
+  query: LocationQuery;
+  /**
+   * Hash of the current location. If present, starts with a `#`.
+   */
+  hash: string;
+  /**
+   * Contains the location we were initially trying to access before ending up
+   * on the current location.
+   */
+  redirectedFrom: RouteLocation | undefined;
+}
+/**
+ * Allowed Component in {@link RouteLocationMatched}
+ */
+type RouteComponent = Component$1 | DefineComponent;
+/**
+ * Allowed Component definitions in route records provided by the user
+ */
+type RawRouteComponent = RouteComponent | Lazy<RouteComponent>;
+/**
+ * Internal type for common properties among all kind of {@link RouteRecordRaw}.
+ */
+interface _RouteRecordBase extends PathParserOptions {
+  /**
+   * Path of the record. Should start with `/` unless the record is the child of
+   * another record.
+   *
+   * @example `/users/:id` matches `/users/1` as well as `/users/posva`.
+   */
+  path: string;
+  /**
+   * Where to redirect if the route is directly matched. The redirection happens
+   * before any navigation guard and triggers a new navigation with the new
+   * target location.
+   */
+  redirect?: RouteRecordRedirectOption;
+  /**
+   * Aliases for the record. Allows defining extra paths that will behave like a
+   * copy of the record. Allows having paths shorthands like `/users/:id` and
+   * `/u/:id`. All `alias` and `path` values must share the same params.
+   */
+  alias?: string | string[];
+  /**
+   * Name for the route record. Must be unique.
+   */
+  name?: RouteRecordNameGeneric;
+  /**
+   * Before Enter guard specific to this record. Note `beforeEnter` has no
+   * effect if the record has a `redirect` property.
+   */
+  beforeEnter?: NavigationGuardWithThis<undefined> | NavigationGuardWithThis<undefined>[];
+  /**
+   * Arbitrary data attached to the record.
+   */
+  meta?: RouteMeta;
+  /**
+   * Array of nested routes.
+   */
+  children?: RouteRecordRaw[];
+  /**
+   * Allow passing down params as props to the component rendered by `router-view`.
+   */
+  props?: _RouteRecordProps | Record<string, _RouteRecordProps>;
+}
+/**
+ * Interface to type `meta` fields in route records.
+ *
+ * @example
+ *
+ * ```ts
+ * // typings.d.ts or router.ts
+ * import 'vue-router';
+ *
+ * declare module 'vue-router' {
+ *   interface RouteMeta {
+ *     requiresAuth?: boolean
+ *   }
+ * }
+ * ```
+ */
+interface RouteMeta extends Record<PropertyKey, unknown> {}
+/**
+ * Route Record defining one single component with the `component` option.
+ */
+interface RouteRecordSingleView extends _RouteRecordBase {
+  /**
+   * Component to display when the URL matches this route.
+   */
+  component: RawRouteComponent;
+  components?: never;
+  children?: never;
+  redirect?: never;
+  /**
+   * Allow passing down params as props to the component rendered by `router-view`.
+   */
+  props?: _RouteRecordProps;
+}
+/**
+ * Route Record defining one single component with a nested view. Differently
+ * from {@link RouteRecordSingleView}, this record has children and allows a
+ * `redirect` option.
+ */
+interface RouteRecordSingleViewWithChildren extends _RouteRecordBase {
+  /**
+   * Component to display when the URL matches this route.
+   */
+  component?: RawRouteComponent | null | undefined;
+  components?: never;
+  children: RouteRecordRaw[];
+  /**
+   * Allow passing down params as props to the component rendered by `router-view`.
+   */
+  props?: _RouteRecordProps;
+}
+/**
+ * Route Record defining multiple named components with the `components` option.
+ */
+interface RouteRecordMultipleViews extends _RouteRecordBase {
+  /**
+   * Components to display when the URL matches this route. Allow using named views.
+   */
+  components: Record<string, RawRouteComponent>;
+  component?: never;
+  children?: never;
+  redirect?: never;
+  /**
+   * Allow passing down params as props to the component rendered by
+   * `router-view`. Should be an object with the same keys as `components` or a
+   * boolean to be applied to every component.
+   */
+  props?: Record<string, _RouteRecordProps> | boolean;
+}
+/**
+ * Route Record defining multiple named components with the `components` option and children.
+ */
+interface RouteRecordMultipleViewsWithChildren extends _RouteRecordBase {
+  /**
+   * Components to display when the URL matches this route. Allow using named views.
+   */
+  components?: Record<string, RawRouteComponent> | null | undefined;
+  component?: never;
+  children: RouteRecordRaw[];
+  /**
+   * Allow passing down params as props to the component rendered by
+   * `router-view`. Should be an object with the same keys as `components` or a
+   * boolean to be applied to every component.
+   */
+  props?: Record<string, _RouteRecordProps> | boolean;
+}
+/**
+ * Route Record that defines a redirect. Cannot have `component` or `components`
+ * as it is never rendered.
+ */
+interface RouteRecordRedirect extends _RouteRecordBase {
+  redirect: RouteRecordRedirectOption;
+  component?: never;
+  components?: never;
+  props?: never;
+}
+type RouteRecordRaw = RouteRecordSingleView | RouteRecordSingleViewWithChildren | RouteRecordMultipleViews | RouteRecordMultipleViewsWithChildren | RouteRecordRedirect;
+/**
+ * Route location that can be passed to the matcher.
+ */
+
+/**
+ * Normalized/resolved Route location that returned by the matcher.
+ */
+interface MatcherLocation {
+  /**
+   * Name of the matched record
+   */
+  name: RouteRecordNameGeneric | null | undefined;
+  /**
+   * Percentage encoded pathname section of the URL.
+   */
+  path: string;
+  /**
+   * Object of decoded params extracted from the `path`.
+   */
+  params: RouteParamsGeneric;
+  /**
+   * Merged `meta` properties from all the matched route records.
+   */
+  meta: RouteMeta;
+  /**
+   * Array of {@link RouteRecord} containing components as they were
+   * passed when adding records. It can also contain redirect records. This
+   * can't be used directly
+   */
+  matched: RouteRecord[];
+}
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Flags so we can combine them when checking for multiple errors. This is the internal version of
+ * {@link NavigationFailureType}.
+ *
+ * @internal
+ */
+declare const enum ErrorTypes {
+  MATCHER_NOT_FOUND = 1,
+  NAVIGATION_GUARD_REDIRECT = 2,
+  NAVIGATION_ABORTED = 4,
+  NAVIGATION_CANCELLED = 8,
+  NAVIGATION_DUPLICATED = 16,
+}
+/**
+ * Enumeration with all possible types for navigation failures. Can be passed to
+ * {@link isNavigationFailure} to check for specific failures.
+ */
+
+/**
+ * Extended Error that contains extra information regarding a failed navigation.
+ */
+interface NavigationFailure extends Error {
+  /**
+   * Type of the navigation. One of {@link NavigationFailureType}
+   */
+  type: ErrorTypes.NAVIGATION_CANCELLED | ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED;
+  /**
+   * Route location we were navigating from
+   */
+  from: RouteLocationNormalized;
+  /**
+   * Route location we were navigating to
+   */
+  to: RouteLocationNormalized;
+}
+/**
+ * Internal error used to detect a redirection.
+ *
+ * @internal
+ */
+
+/**
+ * Internal type to define an ErrorHandler
+ *
+ * @param error - error thrown
+ * @param to - location we were navigating to when the error happened
+ * @param from - location we were navigating from when the error happened
+ * @internal
+ */
+interface _ErrorListener {
+  (error: any, to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded): any;
+}
+//#endregion
+//#region src/scrollBehavior.d.ts
+/**
+ * Scroll position similar to
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions | `ScrollToOptions`}.
+ * Note that not all browsers support `behavior`.
+ */
+type ScrollPositionCoordinates = {
+  behavior?: ScrollOptions['behavior'];
+  left?: number;
+  top?: number;
+};
+/**
+ * Internal normalized version of {@link ScrollPositionCoordinates} that always
+ * has `left` and `top` coordinates. Must be a type to be assignable to HistoryStateValue.
+ *
+ * @internal
+ */
+type _ScrollPositionNormalized = {
+  behavior?: ScrollOptions['behavior'];
+  left: number;
+  top: number;
+};
+/**
+ * Type of the `scrollBehavior` option that can be passed to `createRouter`.
+ */
+interface RouterScrollBehavior {
+  /**
+   * @param to - Route location where we are navigating to
+   * @param from - Route location where we are navigating from
+   * @param savedPosition - saved position if it exists, `null` otherwise
+   */
+  (to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, savedPosition: _ScrollPositionNormalized | null): Awaitable<ScrollPosition | false | void>;
+}
+interface ScrollPositionElement extends ScrollToOptions {
+  /**
+   * A valid CSS selector. Note some characters must be escaped in id selectors (https://mathiasbynens.be/notes/css-escapes).
+   * @example
+   * Here are a few examples:
+   *
+   * - `.title`
+   * - `.content:first-child`
+   * - `#marker`
+   * - `#marker\~with\~symbols`
+   * - `#marker.with.dot`: selects `class="with dot" id="marker"`, not `id="marker.with.dot"`
+   *
+   */
+  el: string | Element;
+}
+type ScrollPosition = ScrollPositionCoordinates | ScrollPositionElement;
+type Awaitable<T$1> = T$1 | PromiseLike<T$1>;
+//#endregion
+//#region src/experimental/route-resolver/matchers/param-parsers/types.d.ts
+/**
+ * Defines a parser that can read a param from the url (string-based) and
+ * transform it into a more complex type, or vice versa.
+ *
+ * @see MatcherPattern
+ */
+
+//#endregion
+//#region src/experimental/router.d.ts
+/**
+ * Options to initialize a {@link Router} instance.
+ */
+interface EXPERIMENTAL_RouterOptions_Base extends PathParserOptions {
+  /**
+   * History implementation used by the router. Most web applications should use
+   * `createWebHistory` but it requires the server to be properly configured.
+   * You can also use a _hash_ based history with `createWebHashHistory` that
+   * does not require any configuration on the server but isn't handled at all
+   * by search engines and does poorly on SEO.
+   *
+   * @example
+   * ```js
+   * createRouter({
+   *   history: createWebHistory(),
+   *   // other options...
+   * })
+   * ```
+   */
+  history: RouterHistory;
+  /**
+   * Function to control scrolling when navigating between pages. Can return a
+   * Promise to delay scrolling.
+   *
+   * @see {@link RouterScrollBehavior}.
+   *
+   * @example
+   * ```js
+   * function scrollBehavior(to, from, savedPosition) {
+   *   // `to` and `from` are both route locations
+   *   // `savedPosition` can be null if there isn't one
+   * }
+   * ```
+   */
+  scrollBehavior?: RouterScrollBehavior;
+  /**
+   * Custom implementation to parse a query. See its counterpart,
+   * {@link EXPERIMENTAL_RouterOptions_Base.stringifyQuery}.
+   *
+   * @example
+   * Let's say you want to use the [qs package](https://github.com/ljharb/qs)
+   * to parse queries, you can provide both `parseQuery` and `stringifyQuery`:
+   * ```js
+   * import qs from 'qs'
+   *
+   * createRouter({
+   *   // other options...
+   *   parseQuery: qs.parse,
+   *   stringifyQuery: qs.stringify,
+   * })
+   * ```
+   */
+  parseQuery?: typeof parseQuery;
+  /**
+   * Custom implementation to stringify a query object. Should not prepend a leading `?`.
+   * {@link parseQuery} counterpart to handle query parsing.
+   */
+  stringifyQuery?: typeof stringifyQuery;
+  /**
+   * Default class applied to active {@link RouterLink}. If none is provided,
+   * `router-link-active` will be applied.
+   */
+  linkActiveClass?: string;
+  /**
+   * Default class applied to exact active {@link RouterLink}. If none is provided,
+   * `router-link-exact-active` will be applied.
+   */
+  linkExactActiveClass?: string;
+}
+/**
+ * Internal type for common properties among all kind of {@link RouteRecordRaw}.
+ */
+
+/**
+ * Router base instance.
+ *
+ * @experimental This version is not stable, it's meant to replace {@link Router} in the future.
+ */
+interface EXPERIMENTAL_Router_Base<TRecord> {
+  /**
+   * Current {@link RouteLocationNormalized}
+   */
+  readonly currentRoute: ShallowRef<RouteLocationNormalizedLoaded>;
+  /**
+   * Allows turning off the listening of history events. This is a low level api for micro-frontend.
+   */
+  listening: boolean;
+  /**
+   * Checks if a route with a given name exists
+   *
+   * @param name - Name of the route to check
+   */
+  hasRoute(name: NonNullable<RouteRecordNameGeneric>): boolean;
+  /**
+   * Get a full list of all the {@link RouteRecord | route records}.
+   */
+  getRoutes(): TRecord[];
+  /**
+   * Returns the {@link RouteLocation | normalized version} of a
+   * {@link RouteLocationRaw | route location}. Also includes an `href` property
+   * that includes any existing `base`. By default, the `currentLocation` used is
+   * `router.currentRoute` and should only be overridden in advanced use cases.
+   *
+   * @param to - Raw route location to resolve
+   * @param currentLocation - Optional current location to resolve against
+   */
+  resolve<Name extends keyof RouteMap = keyof RouteMap>(to: RouteLocationAsRelativeTyped<RouteMap, Name>, currentLocation?: RouteLocationNormalizedLoaded): RouteLocationResolved<Name>;
+  resolve(to: RouteLocationAsString | RouteLocationAsRelative | RouteLocationAsPath, currentLocation?: RouteLocationNormalizedLoaded): RouteLocationResolved;
+  /**
+   * Programmatically navigate to a new URL by pushing an entry in the history
+   * stack.
+   *
+   * @param to - Route location to navigate to
+   */
+  push(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+  /**
+   * Programmatically navigate to a new URL by replacing the current entry in
+   * the history stack.
+   *
+   * @param to - Route location to navigate to
+   */
+  replace(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+  /**
+   * Go back in history if possible by calling `history.back()`. Equivalent to
+   * `router.go(-1)`.
+   */
+  back(): void;
+  /**
+   * Go forward in history if possible by calling `history.forward()`.
+   * Equivalent to `router.go(1)`.
+   */
+  forward(): void;
+  /**
+   * Allows you to move forward or backward through the history. Calls
+   * `history.go()`.
+   *
+   * @param delta - The position in the history to which you want to move,
+   * relative to the current page
+   */
+  go(delta: number): void;
+  /**
+   * Add a navigation guard that executes before any navigation. Returns a
+   * function that removes the registered guard.
+   *
+   * @param guard - navigation guard to add
+   */
+  beforeEach(guard: NavigationGuardWithThis<undefined>): () => void;
+  /**
+   * Add a navigation guard that executes before navigation is about to be
+   * resolved. At this state all component have been fetched and other
+   * navigation guards have been successful. Returns a function that removes the
+   * registered guard.
+   *
+   * @param guard - navigation guard to add
+   * @returns a function that removes the registered guard
+   *
+   * @example
+   * ```js
+   * router.beforeResolve(to => {
+   *   if (to.meta.requiresAuth && !isAuthenticated) return false
+   * })
+   * ```
+   *
+   */
+  beforeResolve(guard: NavigationGuardWithThis<undefined>): () => void;
+  /**
+   * Add a navigation hook that is executed after every navigation. Returns a
+   * function that removes the registered hook.
+   *
+   * @param guard - navigation hook to add
+   * @returns a function that removes the registered hook
+   *
+   * @example
+   * ```js
+   * router.afterEach((to, from, failure) => {
+   *   if (isNavigationFailure(failure)) {
+   *     console.log('failed navigation', failure)
+   *   }
+   * })
+   * ```
+   */
+  afterEach(guard: NavigationHookAfter): () => void;
+  /**
+   * Adds an error handler that is called every time a non caught error happens
+   * during navigation. This includes errors thrown synchronously and
+   * asynchronously, errors returned or passed to `next` in any navigation
+   * guard, and errors occurred when trying to resolve an async component that
+   * is required to render a route.
+   *
+   * @param handler - error handler to register
+   */
+  onError(handler: _ErrorListener): () => void;
+  /**
+   * Returns a Promise that resolves when the router has completed the initial
+   * navigation, which means it has resolved all async enter hooks and async
+   * components that are associated with the initial route. If the initial
+   * navigation already happened, the promise resolves immediately.
+   *
+   * This is useful in server-side rendering to ensure consistent output on both
+   * the server and the client. Note that on server side, you need to manually
+   * push the initial location while on client side, the router automatically
+   * picks it up from the URL.
+   */
+  isReady(): Promise<void>;
+  /**
+   * Called automatically by `app.use(router)`. Should not be called manually by
+   * the user. This will trigger the initial navigation when on client side.
+   *
+   * @internal
+   * @param app - Application that uses the router
+   */
+  install(app: App): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/vue-router@4.6.3_vue@3.5.22_typescript@5.9.3_/node_modules/vue-router/dist/vue-router.d.mts
+//#endregion
+//#region src/router.d.ts
+/**
+ * Options to initialize a {@link Router} instance.
+ */
+interface RouterOptions extends EXPERIMENTAL_RouterOptions_Base {
+  /**
+   * Initial list of routes that should be added to the router.
+   */
+  routes: Readonly<RouteRecordRaw[]>;
+}
+/**
+ * Router instance.
+ */
+interface Router extends EXPERIMENTAL_Router_Base<RouteRecordNormalized> {
+  /**
+   * Original options object passed to create the Router
+   */
+  readonly options: RouterOptions;
+  /**
+   * Add a new {@link RouteRecordRaw | route record} as the child of an existing route.
+   *
+   * @param parentName - Parent Route Record where `route` should be appended at
+   * @param route - Route Record to add
+   */
+  addRoute(parentName: NonNullable<RouteRecordNameGeneric>, route: RouteRecordRaw): () => void;
+  /**
+   * Add a new {@link RouteRecordRaw | route record} to the router.
+   *
+   * @param route - Route Record to add
+   */
+  addRoute(route: RouteRecordRaw): () => void;
+  /**
+   * Remove an existing route by its name.
+   *
+   * @param name - Name of the route to remove
+   */
+  removeRoute(name: NonNullable<RouteRecordNameGeneric>): void;
+  /**
+   * Delete all routes from the router.
+   */
+  clearRoutes(): void;
+}
+/**
+ * Creates a Router instance that can be used by a Vue app.
+ *
+ * @param options - {@link RouterOptions}
+ */
+
+//#endregion
+//#region src/RouterLink.d.ts
+interface RouterLinkOptions {
+  /**
+   * Route Location the link should navigate to when clicked on.
+   */
+  to: RouteLocationRaw;
+  /**
+   * Calls `router.replace` instead of `router.push`.
+   */
+  replace?: boolean;
+}
+interface RouterLinkProps extends RouterLinkOptions {
+  /**
+   * Whether RouterLink should not wrap its content in an `a` tag. Useful when
+   * using `v-slot` to create a custom RouterLink
+   */
+  custom?: boolean;
+  /**
+   * Class to apply when the link is active
+   */
+  activeClass?: string;
+  /**
+   * Class to apply when the link is exact active
+   */
+  exactActiveClass?: string;
+  /**
+   * Value passed to the attribute `aria-current` when the link is exact active.
+   *
+   * @defaultValue `'page'`
+   */
+  ariaCurrentValue?: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+  /**
+   * Pass the returned promise of `router.push()` to `document.startViewTransition()` if supported.
+   */
+  viewTransition?: boolean;
+}
+/**
+ * Options passed to {@link useLink}.
+ */
+interface UseLinkOptions<Name extends keyof RouteMap = keyof RouteMap> {
+  to: MaybeRef<RouteLocationAsString | RouteLocationAsRelativeTyped<RouteMap, Name> | RouteLocationAsPath | RouteLocationRaw>;
+  replace?: MaybeRef<boolean | undefined>;
+  /**
+   * Pass the returned promise of `router.push()` to `document.startViewTransition()` if supported.
+   */
+  viewTransition?: boolean;
+}
+/**
+ * Return type of {@link useLink}.
+ * @internal
+ */
+interface UseLinkReturn<Name extends keyof RouteMap = keyof RouteMap> {
+  route: ComputedRef<RouteLocationResolved<Name>>;
+  href: ComputedRef<string>;
+  isActive: ComputedRef<boolean>;
+  isExactActive: ComputedRef<boolean>;
+  navigate(e?: MouseEvent): Promise<void | NavigationFailure>;
+}
+/**
+ * Returns the internal behavior of a {@link RouterLink} without the rendering part.
+ *
+ * @param props - a `to` location and an optional `replace` flag
+ */
+declare function useLink<Name extends keyof RouteMap = keyof RouteMap>(props: UseLinkOptions<Name>): UseLinkReturn<Name>;
+/**
+ * Component to render a link that triggers a navigation on click.
+ */
+declare const RouterLink: _RouterLinkI;
+/**
+ * @internal
+ */
+type _RouterLinkPropsTypedBase = AllowedComponentProps & ComponentCustomProps & VNodeProps & RouterLinkProps;
+/**
+ * @internal
+ */
+type RouterLinkPropsTyped<Custom extends boolean | undefined> = Custom extends true ? _RouterLinkPropsTypedBase & {
+  custom: true;
+} : _RouterLinkPropsTypedBase & {
+  custom?: false | undefined;
+} & Omit<AnchorHTMLAttributes, 'href'>;
+/**
+ * Typed version of the `RouterLink` component. Its generic defaults to the typed router, so it can be inferred
+ * automatically for JSX.
+ *
+ * @internal
+ */
+interface _RouterLinkI {
+  new <Custom extends boolean | undefined = boolean | undefined>(): {
+    $props: RouterLinkPropsTyped<Custom>;
+    $slots: {
+      default?: ({
+        route,
+        href,
+        isActive,
+        isExactActive,
+        navigate
+      }: UnwrapRef<UseLinkReturn>) => VNode[];
+    };
+  };
+  /**
+   * Access to `useLink()` without depending on using vue-router
+   *
+   * @internal
+   */
+  useLink: typeof useLink;
+}
+//#endregion
+//#region src/RouterView.d.ts
+interface RouterViewProps {
+  name?: string;
+  route?: RouteLocationNormalized;
+}
+/**
+ * Component to display the current route the user is at.
+ */
+declare const RouterView: {
+  new (): {
+    $props: AllowedComponentProps & ComponentCustomProps & VNodeProps & RouterViewProps;
+    $slots: {
+      default?: ({
+        Component,
+        route
+      }: {
+        Component: VNode;
+        route: RouteLocationNormalizedLoaded;
+      }) => VNode[];
+    };
+  };
+};
+//#endregion
+//#region src/useApi.d.ts
+/**
+ * Returns the router instance. Equivalent to using `$router` inside
+ * templates.
+ */
+
+//#endregion
+//#region src/index.d.ts
+declare module 'vue' {
+  interface ComponentCustomOptions {
+    /**
+     * Guard called when the router is navigating to the route that is rendering
+     * this component from a different route. Differently from `beforeRouteUpdate`
+     * and `beforeRouteLeave`, `beforeRouteEnter` does not have access to the
+     * component instance through `this` because it triggers before the component
+     * is even mounted.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteEnter?: TypesConfig extends Record<'beforeRouteEnter', infer T> ? T : NavigationGuardWithThis<undefined>;
+    /**
+     * Guard called whenever the route that renders this component has changed, but
+     * it is reused for the new route. This allows you to guard for changes in
+     * params, the query or the hash.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteUpdate?: TypesConfig extends Record<'beforeRouteUpdate', infer T> ? T : NavigationGuard;
+    /**
+     * Guard called when the router is navigating away from the current route that
+     * is rendering this component.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteLeave?: TypesConfig extends Record<'beforeRouteLeave', infer T> ? T : NavigationGuard;
+  }
+  interface ComponentCustomProperties {
+    /**
+     * Normalized current location. See {@link RouteLocationNormalizedLoaded}.
+     */
+    $route: TypesConfig extends Record<'$route', infer T> ? T : RouteLocationNormalizedLoaded;
+    /**
+     * {@link Router} instance used by the application.
+     */
+    $router: TypesConfig extends Record<'$router', infer T> ? T : Router;
+  }
+  interface GlobalComponents {
+    RouterView: TypesConfig extends Record<'RouterView', infer T> ? T : typeof RouterView;
+    RouterLink: TypesConfig extends Record<'RouterLink', infer T> ? T : typeof RouterLink;
+  }
+}
+//#endregion
+//#endregion
+//#region src/devtools/registry.d.ts
+//#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
@@ -2330,7 +3766,7 @@ const anyA = get(anyObject, 'a');
 @category Type Guard
 @category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type IsAny<T$1> = 0 extends 1 & NoInfer<T$1> ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
@@ -2483,7 +3919,7 @@ endIfEqual('abc', '123');
 @category Type Guard
 @category Utilities
 */
-type IsNever<T> = [T] extends [never] ? true : false;
+type IsNever<T$1> = [T$1] extends [never] ? true : false;
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/if.d.ts
 /**
@@ -2593,7 +4029,7 @@ Needed to handle the case of a single call signature with properties.
 Multiple call signatures cannot currently be supported due to a TypeScript limitation.
 @see https://github.com/microsoft/TypeScript/issues/29732
 */
-type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+type HasMultipleCallSignatures<T$1 extends (...arguments_: any[]) => unknown> = T$1 extends {
   (...arguments_: infer A): unknown;
   (...arguments_: infer B): unknown;
 } ? B extends A ? A extends B ? false : true : true : false;
@@ -2656,7 +4092,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @see {@link SimplifyDeep}
 @category Object
 */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type Simplify<T$1> = { [KeyType in keyof T$1]: T$1[KeyType] } & {};
 //#endregion
 //#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
@@ -2979,14 +4415,14 @@ partialShape.dimensions = [15]; // OK
 @category Set
 @category Map
 */
-type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
-type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T // For functions with no properties
-: HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
-? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
-: T // If they don't opt into array testing, just use the original type
-: PartialObjectDeep<T, Options> : unknown;
+type PartialDeep<T$1, Options extends PartialDeepOptions = {}> = _PartialDeep<T$1, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+type _PartialDeep<T$1, Options extends Required<PartialDeepOptions>> = T$1 extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T$1 : T$1 extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T$1 extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T$1 extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T$1 extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T$1 extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T$1> extends true ? T$1 // For functions with no properties
+: HasMultipleCallSignatures<T$1> extends true ? T$1 : ((...arguments_: Parameters<T$1>) => ReturnType<T$1>) & PartialObjectDeep<T$1, Options> : T$1 extends object ? T$1 extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+? Options['recurseIntoArrays'] extends true ? ItemType[] extends T$1 // Test for arrays (non-tuples) specifically
+? readonly ItemType[] extends T$1 // Differentiate readonly and mutable arrays
+? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T$1, Options> // Tuples behave properly
+: T$1 // If they don't opt into array testing, just use the original type
+: PartialObjectDeep<T$1, Options> : unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
@@ -2996,7 +4432,7 @@ type PartialMapDeep<KeyType$1, ValueType$1, Options extends Required<PartialDeep
 /**
 Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+type PartialSetDeep<T$1, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T$1, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
@@ -3006,7 +4442,7 @@ type PartialReadonlyMapDeep<KeyType$1, ValueType$1, Options extends Required<Par
 /**
 Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+type PartialReadonlySetDeep<T$1, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T$1, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.