@fastkit/vui-wysiwyg 8.2.0 → 8.3.0-next.0

package/dist/vui-wysiwyg.d.mts

@@ -0,0 +1,3576 @@
+import * as vue2 from "vue";
+import { AllowedComponentProps, App, Component, ComponentCustomProps, ComponentInternalInstance, ComponentPublicInstance, ComputedRef, DefineComponent, ExtractPropTypes, MaybeRef, Prop, PropType, Ref, SetupContext, SlotsType, UnwrapRef, VNode, VNodeArrayChildren, VNodeChild, VNodeProps, WritableComputedRef } from "vue";
+import { AnyExtension, Editor, EditorOptions, Extension, Extensions, Mark, Node } from "@tiptap/vue-3";
+import { EditorView } from "@tiptap/pm/view";
+import "@tiptap/extension-text-style";
+import { BulletListOptions } from "@tiptap/extension-bullet-list";
+import { BoldOptions } from "@tiptap/extension-bold";
+import { ItalicOptions } from "@tiptap/extension-italic";
+import { UnderlineOptions } from "@tiptap/extension-underline";
+import { HistoryOptions } from "@tiptap/extension-history";
+import { LinkOptions } from "@tiptap/extension-link";
+import * as _fastkit_vui0 from "@fastkit/vui";
+import { IconName, TextableControl, VuiService } from "@fastkit/vui";
+import { OrderedListOptions } from "@tiptap/extension-ordered-list";
+import { TextAlignOptions } from "@tiptap/extension-text-align";
+import { Node as Node$1 } from "@tiptap/pm/model";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region src/schemes.d.ts
+declare const EDITOR_EVENTS: readonly ["beforeCreate", "create", "update", "selectionUpdate", "transaction", "focus", "blur", "destroy"];
+type PrefixedEventName<S extends string> = `on${Capitalize<S>}`;
+type WysiwygEditorEvent = (typeof EDITOR_EVENTS)[number];
+type WysiwygEditorPrefixedEvent = PrefixedEventName<WysiwygEditorEvent>;
+interface WysiwygEditorEventsOptions extends Partial<Pick<EditorOptions, WysiwygEditorPrefixedEvent>> {}
+type WysiwygEditorEventsBucket = { [EV in WysiwygEditorEvent]: NonNullable<WysiwygEditorEventsOptions[PrefixedEventName<EV>]>[] };
+declare class WysiwygEditorInitializeContext {
+  readonly listeners: WysiwygEditorEventsBucket;
+  private readonly _vui;
+  get vui(): VuiService;
+  constructor(vuiGetter: () => VuiService, opts?: WysiwygEditorEventsOptions);
+  on<EV extends WysiwygEditorEvent>(ev: EV, handler: NonNullable<WysiwygEditorEventsOptions[PrefixedEventName<EV>]>): () => void;
+  off<EV extends WysiwygEditorEvent>(ev: EV, handler: NonNullable<WysiwygEditorEventsOptions[PrefixedEventName<EV>]>): void;
+  editorOptions(): WysiwygEditorEventsOptions;
+}
+interface WysiwygEditorContext {
+  editor: Editor;
+  vui: VuiService;
+}
+type WysiwygExtensionFactory<Options = any, Storage = any> = (ctx: WysiwygEditorInitializeContext) => Extension<Options, Storage> | Node<Options, Storage> | Mark<Options, Storage>;
+interface CreatedWysiwygExtension<Options = any, Storage = any> {
+  __isCreatedWysiwygExtension: true;
+  _configs: Partial<Options>[];
+  configure(options?: Partial<Options>): CreatedWysiwygExtension<Options, Storage>;
+  raw: WysiwygExtensionSource<Options, Storage>;
+}
+type WysiwygExtensionSource<Options = any, Storage = any> = Extension<Options, Storage> | Node<Options, Storage> | Mark<Options, Storage> | WysiwygExtensionFactory<Options, Storage>;
+type RawWysiwygExtension<Options = any, Storage = any> = WysiwygExtensionSource<Options, Storage> | CreatedWysiwygExtension<Options, Storage>;
+declare function createWysiwygExtension<Options = any, Storage = any>(extension: WysiwygExtensionSource<Options, Storage>): CreatedWysiwygExtension<Options, Storage>;
+declare function resolveRawWysiwygExtensions(raws: RawWysiwygExtension[], ctx: WysiwygEditorInitializeContext): AnyExtension[];
+type WysiwygEditorToolIcon = IconName | ((ctx: WysiwygEditorContext) => IconName | (() => VNodeChild) | undefined);
+/**
+ * Tool Configuration
+ */
+interface WysiwygEditorTool {
+  /**
+   * Tool Key
+   *
+   * Must be unique to identify the tool
+   */
+  key: string;
+  /** Icons to be displayed on the toolbar */
+  icon: WysiwygEditorToolIcon;
+  /** Conditions for displaying the icon as active */
+  active?: boolean | ((ctx: WysiwygEditorContext) => boolean);
+  /** Conditions for deactivating the icon */
+  disabled?: boolean | ((ctx: WysiwygEditorContext) => boolean);
+  /** Handler when mark text is clicked */
+  onClick: (ctx: WysiwygEditorContext, ev: PointerEvent) => any;
+  /** Whether to display tools in floating menu or not */
+  floating?: boolean;
+  /** Extensions that the tool depends on */
+  extensions?: Extensions;
+}
+type WysiwygEditorToolFactory<Options = void> = (vui: VuiService, options?: Options) => WysiwygEditorTool | WysiwygEditorTool[];
+type RawWysiwygEditorTool = WysiwygEditorTool | WysiwygEditorToolFactory<any>;
+interface ResolvedWysiwygEditorSettings {
+  tools: WysiwygEditorTool[];
+  extensions: Extensions;
+}
+declare function resolveRawWysiwygEditorTools(rawTools: RawWysiwygEditorTool[], vui: VuiService): ResolvedWysiwygEditorSettings;
+//#endregion
+//#region src/injections.d.ts
+declare const VUI_WYSIWYG_EDITOR_SYMBOL = "vui-wysiwyg-editor";
+//#endregion
+//#region src/extensions/linter/LinterPlugin.d.ts
+type WysiwygLinterFixFn = (view: EditorView, issue: WysiwygLinterResult) => any;
+type WysiwygLinterFixMessage = string | (() => VNodeChild);
+interface WysiwygLinterFixer {
+  message: WysiwygLinterFixMessage;
+  handler: WysiwygLinterFixFn;
+}
+type WysiwygLinterResultLevel = 'warning' | 'error';
+interface WysiwygLinterResult {
+  id: string;
+  icon: boolean;
+  level: WysiwygLinterResultLevel;
+  message: WysiwygLinterFixMessage;
+  from: number;
+  to: number;
+  fix: WysiwygLinterFixer[];
+}
+interface RawLinterResult extends Omit<WysiwygLinterResult, 'level' | 'fix' | 'id' | 'icon'> {
+  level?: WysiwygLinterResultLevel;
+  icon?: boolean;
+  fix?: WysiwygLinterFixer | WysiwygLinterFixer[];
+}
+declare class WysiwygLinterPlugin {
+  protected doc: Node$1;
+  private results;
+  constructor(doc: Node$1);
+  record(result: RawLinterResult): void;
+  scan(): this;
+  getResults(): WysiwygLinterResult[];
+}
+//#endregion
+//#region src/extensions/linter/Linter.d.ts
+interface WysiwygLinterOptions {
+  plugins: Array<typeof WysiwygLinterPlugin>;
+}
+interface WysiwygLinterStorage {
+  issues: WysiwygLinterResult[];
+}
+declare const WysiwygLinter: CreatedWysiwygExtension<WysiwygLinterOptions, WysiwygLinterStorage>;
+//#endregion
+//#region src/extensions/linter/plugins/BadWords.d.ts
+declare function WysiwygLinterBadWords(words: string[]): typeof WysiwygLinterPlugin;
+//#endregion
+//#region src/extensions/linter/plugins/HeadingLevel.d.ts
+declare class WysiwygLinterHeadingLevel extends WysiwygLinterPlugin {
+  fixHeader(level: number): ({
+    state,
+    dispatch
+  }: EditorView, issue: WysiwygLinterResult) => void;
+  scan(): this;
+}
+//#endregion
+//#region src/extensions/linter/plugins/Punctuation.d.ts
+declare class WysiwygLinterPunctuation extends WysiwygLinterPlugin {
+  regex: RegExp;
+  fix(replacement: any): ({
+    state,
+    dispatch
+  }: EditorView, issue: WysiwygLinterResult) => void;
+  scan(): this;
+}
+//#endregion
+//#region src/extensions/color.d.ts
+type WysiwygColorOptions = {
+  types: string[];
+};
+declare module '@tiptap/vue-3' {
+  interface Commands<ReturnType> {
+    color: {
+      /**
+       * Set the text color
+       */
+      setColor: (color: string) => ReturnType;
+      /**
+       * Unset the text color
+       */
+      unsetColor: () => ReturnType;
+    };
+  }
+}
+declare const WysiwygColorExtension: Extension<WysiwygColorOptions, any>;
+//#endregion
+//#region src/extensions/custom-tag.d.ts
+type WysiwygCustomTagSettings = {
+  /**
+   * tag name
+   *
+   * Either the html default tag name or a custom tag name is acceptable
+   *
+   * @default "span"
+   */
+  tag: string;
+  /**
+   * HTML Attributes
+   *
+   * Attributes to be assigned to tags such as `class`, `data-xxx`, etc.
+   */
+  attrs?: Record<any, string>;
+};
+declare module '@tiptap/vue-3' {
+  interface Commands<ReturnType> {
+    customTag: {
+      /**
+       * Set the custom tag
+       */
+      setCustomTag: (markName: string) => ReturnType;
+      /**
+       * Toggle the custom tag
+       */
+      toggleCustomTag: (markName: string) => ReturnType;
+      /**
+       * Unset the custom tag
+       */
+      unsetCustomTag: (markName: string) => ReturnType;
+    };
+  }
+}
+declare function createWysiwygCustomTagMark(name: string, settings: Partial<WysiwygCustomTagSettings>): Mark<WysiwygCustomTagSettings, any>;
+declare const WysiwygCustomTagExtension: Extension<WysiwygCustomTagSettings, any>;
+//#endregion
+//#region src/tools/bullet-list.d.ts
+declare const WysiwygBulletListTool: WysiwygEditorToolFactory<BulletListOptions>;
+//#endregion
+//#region src/tools/format-bold.d.ts
+declare const WysiwygFormatBoldTool: WysiwygEditorToolFactory<BoldOptions>;
+//#endregion
+//#region src/tools/format-italic.d.ts
+declare const WysiwygFormatItalicTool: WysiwygEditorToolFactory<ItalicOptions>;
+//#endregion
+//#region src/tools/format-underline.d.ts
+declare const WysiwygFormatUnderlineTool: WysiwygEditorToolFactory<UnderlineOptions>;
+//#endregion
+//#region src/tools/history.d.ts
+declare const WysiwygHistoryTool: WysiwygEditorToolFactory<HistoryOptions>;
+//#endregion
+//#region src/tools/link.d.ts
+declare const WysiwygLinkTool: WysiwygEditorToolFactory<LinkOptions>;
+//#endregion
+//#region src/tools/ordered-list.d.ts
+declare const WysiwygOrderedListTool: WysiwygEditorToolFactory<OrderedListOptions>;
+//#endregion
+//#region src/tools/color.d.ts
+interface WysiwygColorItem {
+  key?: string | number;
+  name?: VNodeChild | ((vui: VuiService) => VNodeChild);
+  color: string | null;
+}
+interface CreateWysiwygColorToolOptions {
+  items: WysiwygColorItem[];
+  withLabel?: boolean;
+}
+declare function createWysiwygColorTool(opts: CreateWysiwygColorToolOptions): WysiwygEditorToolFactory;
+//#endregion
+//#region src/tools/text-align.d.ts
+/**
+ * A list of available options for the text align attribute.
+ * @remarks
+ * `"justify"` has not yet been adopted because of ambiguity in browser support.
+ */
+declare const WYSIWYG_TEXT_ALIGN_VALUES: readonly ["left", "center", "right"];
+/** Text align value */
+type WysiwygTextAlignValue = (typeof WYSIWYG_TEXT_ALIGN_VALUES)[number];
+interface WysiwygTextAlignOptions {
+  /**
+   * A list of nodes where the text align attribute should be applied to. Usually something like `['heading', 'paragraph']`
+   * @default DEFAULT_TYPES
+   * @see {@link DEFAULT_TYPES}
+   */
+  types?: TextAlignOptions['types'];
+  /**
+   * A list of available options for the text align attribute.
+   * @default WYSIWYG_TEXT_ALIGN_VALUES
+   * @see {@link WYSIWYG_TEXT_ALIGN_VALUES}
+   */
+  alignments?: WysiwygTextAlignValue[];
+  /**
+   * The default text align.
+   * @default left
+   */
+  defaultAlignment: WysiwygTextAlignValue;
+}
+declare const WysiwygTextAlignTool: WysiwygEditorToolFactory<WysiwygTextAlignOptions>;
+//#endregion
+//#region src/tools/custom-tag.d.ts
+interface WysiwygCustomTagToolSettings extends Pick<WysiwygEditorTool, 'icon' | 'floating'>, Partial<WysiwygCustomTagSettings> {}
+/**
+ * Generate Custom Tag Tool
+ *
+ * @param markName - Mark name
+ * @param settings - Tool Configuration
+ * @returns Generated Tool
+ */
+declare function createWysiwygCustomTagTool(markName: string, settings: WysiwygCustomTagToolSettings): WysiwygEditorToolFactory;
+//#endregion
+//#region ../ts-type-utils/types/types.d.ts
+/**
+ * Recursive Arrays
+ */
+type RecursiveArray<T> = T | RecursiveArray<T>[];
+//#endregion
+//#region ../helpers/dist/helpers.d.mts
+type Mixin<T extends object, U extends object> = Omit<T, keyof U> & U;
+/**
+ * Returns a Proxy instance that mixes in the specified trait object for the given base object
+ *
+ * @param base - Base object
+ * @param trait - trait object
+ * @returns Mixed-in Proxy
+ */
+//#endregion
+//#region ../rules/dist/rules.d.mts
+//#endregion
+//#region src/schemes.d.ts
+/**
+ * Symbol indicating a validation error.
+ */
+declare const VALIDATION_ERROR_SYMBOL = "ValidationError";
+/**
+ * Validation error.
+ */
+interface ValidationError {
+  /**
+   * Symbol indicating a validation error.
+   *
+   * @see {@link VALIDATION_ERROR_SYMBOL}
+   */
+  $$symbol: typeof VALIDATION_ERROR_SYMBOL;
+  /** Failed validation rule name. */
+  name: string;
+  /** Prefix for the path during object enumeration. */
+  eachPrefix?: string;
+  /** Property name during object enumeration. */
+  path?: string | number;
+  /** Full path to the property during object enumeration. */
+  fullPath?: string;
+  /** Error message. */
+  message: string;
+  /** Failed validation value. */
+  value?: any;
+  /** List of errors for descendant properties if it's an error for an object. */
+  children?: ValidationError[];
+  /** Constraints set in the rule. */
+  constraints?: any;
+}
+/**
+ * Check if the specified value is a validation error.
+ *
+ * @param source - Value to be checked.
+ * @returns `true` if it is a validation error.
+ */
+/**
+ * Symbol indicating validation cancellation.
+ */
+declare const VALIDATE_CANCEL_SYMBOL = "__VALIDATE_CANCEL_SYMBOL__";
+/**
+ * Check if the specified value is a symbol for validation cancellation.
+ *
+ * @param source - Value to be checked.
+ * @returns `true` if it is a symbol for cancellation.
+ */
+//#endregion
+//#region src/factories/rule.d.ts
+/**
+ * Execution result of the rule.
+ */
+type RuleResult = Promise<void | typeof VALIDATE_CANCEL_SYMBOL | ValidationError>;
+/**
+ * Validation options for the rule.
+ */
+interface RuleValidationOptions {
+  /**
+   * Property name during object enumeration.
+   *
+   * This is typically not specified from the application and is intended for internal use.
+   *
+   * @internal
+   */
+  path?: string | number;
+  /**
+   * Prefix for the path during object enumeration.
+   *
+   * This is typically not specified from the application and is intended for internal use.
+   *
+   * @internal
+   */
+  eachPrefix?: string;
+}
+/**
+ * Result of rule validation.
+ */
+type RuleValidationResultValue = /** When it passes verification */true /** When verification fails */ | false /** When the verification is considered successful and the subsequent verifications are skipped */ | typeof VALIDATE_CANCEL_SYMBOL /** When verification fails */ | string /** When there is a nested validation result object */ | ValidationError[];
+/**
+ * Result of rule validation or its Promise instance.
+ */
+type RuleValidationResult = RuleValidationResultValue | Promise<RuleValidationResultValue>;
+/**
+ * Message specification for the rule.
+ */
+type RuleMessageSpec<C = any> = string | ((value: any, ctx: RuleValidateContext<C>) => string);
+/** Basic settings for the rule. */
+interface RuleBasicSettings<C = any> {
+  /** Rule name. */
+  name: string;
+  /**
+   * Message specification for the rule.
+   *
+   * @see {@link RuleMessageSpec}
+   */
+  message?: RuleMessageSpec<C>;
+}
+/**
+ * Rule settings.
+ */
+type RuleSettings<C = any> = (RuleBasicSettings<C> & {
+  /**
+   * Validation function.
+   *
+   * @param value - Value to be validated.
+   * @param constraints - Constraints.
+   * @returns Result of rule validation or its Promise instance.
+   */
+  validate: (value: any, constraints: C) => RuleValidationResult;
+  /**
+   * Constraints.
+   *
+   * Passed as the second argument to the validation function, this value can be customized through rule forking.
+   */
+  constraints: C;
+}) | (RuleBasicSettings<C> & {
+  /**
+   * Validation function.
+   *
+   * @param value - Value to be validated.
+   * @returns Result of rule validation or its Promise instance.
+   */
+  validate: (value: any) => RuleValidationResult;
+  constraints?: any;
+});
+/**
+ * Context object for rule validation.
+ */
+interface RuleValidateContext<C = any> {
+  /** Rule name. */
+  name: string;
+  /** Value to be validated. */
+  value: any;
+  /** Constraints. */
+  constraints: C;
+  /** Prefix for the path during object enumeration. */
+  eachPrefix?: string;
+  /** Property name during object enumeration. */
+  path?: string | number;
+  /** Full path to the property during object enumeration. */
+  fullPath?: string;
+  /**
+   * Message specification for the rule.
+   *
+   * @see {@link RuleMessageSpec}
+   */
+  message?: RuleMessageSpec<C>;
+  /** Exception that occurred during rule validation. */
+  exception?: any;
+}
+/**
+ * Fork settings for the rule.
+ */
+interface RuleForkSettings<C = any> {
+  /** New rule name. */
+  name?: string;
+  /** New constraints. */
+  constraints?: C;
+  /**
+   * New message specification.
+   *
+   * @see {@link RuleMessageSpec}
+   */
+  message?: RuleMessageSpec<C>;
+}
+/**
+ * Rule interface.
+ */
+interface Rule<C = any> {
+  <EC extends C = C>(constraints: Partial<EC>, overRides?: string | Partial<RuleSettings<EC>>): Rule<EC>;
+  /** Rule name. */
+  $name: string;
+  /**
+   * Validate the specified value.
+   *
+   * @param value - Value to be validated.
+   * @param options Validation options for the rule.
+   * @returns Execution result of the rule.
+   */
+  validate: (value: any, options?: RuleValidationOptions) => RuleResult;
+  /**
+   * Message specification for the rule.
+   *
+   * @see {@link RuleMessageSpec}
+   */
+  message: RuleMessageSpec<C>;
+  /**
+   * Constraints.
+   *
+   * Passed as the second argument to the validation function, this value can be customized through rule forking.
+   */
+  constraints: C;
+  /**
+   * Fork this rule to create a new rule.
+   *
+   * Used when creating a new rule with customized name, constraints, and message specifications.
+   *
+   * @param settings - RuleForkSettings
+   */
+  fork(settings: RuleForkSettings): Rule<C>;
+  /**
+   * Validation function.
+   *
+   * @internal
+   */
+  _validate: ((value: any, constraints: C) => RuleValidationResult) | ((value: any) => RuleValidationResult);
+  /**
+   * Options used in the most recent validation.
+   *
+   * @see {@link RuleValidationOptions}
+   */
+  _lastValidationOptions: RuleValidationOptions;
+  /**
+   * Retrieve the rule as JSON.
+   */
+  toJSON(): {
+    /** Rule name. */name: string; /** Constraints. */
+    constraints: C;
+  };
+}
+/**
+ * Create a rule.
+ *
+ * @param settings - Rule settings.
+ * @returns Rule interface.
+ *
+ * @see {@link RuleSettings}
+ */
+/**
+ * Interface available for validation rule.
+ */
+interface VerifiableRule extends Pick<Rule, 'validate' | 'message' | '$name'> {}
+/**
+ * Verifiable function type.
+ *
+ * - Treats it as an error if it returns `string` or `false`.
+ * - If it returns `string`, it is considered as an error message.
+ */
+type VerifiableFn = (value: any) => string | boolean | undefined | void | Promise<string | boolean | undefined | void>;
+/**
+ * Rule or function available for validation.
+ */
+type VerifiableRuleOrFn = VerifiableRule | VerifiableFn;
+/**
+ * Create a validation interface from a function.
+ *
+ * @param fn - Verifiable function type.
+ * @returns Interface available for validation rule.
+ *
+ * @see {@link VerifiableFn}
+ * @see {@link VerifiableRule}
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/vue-router@4.5.1_vue@3.5.22_typescript@5.9.3_/node_modules/vue-router/dist/vue-router.d.ts
+declare type Awaitable<T> = T | Promise<T>;
+/**
+ * Maybe a promise maybe not
+ * @internal
+ */
+declare type _Awaitable<T> = T | PromiseLike<T>;
+/**
+ * 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
+ */
+declare interface _ErrorListener {
+  (error: any, to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded): any;
+}
+/**
+ * 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
+}
+declare type HistoryLocation = string;
+/**
+ * Allowed HTML history.state
+ */
+declare interface HistoryState {
+  [x: number]: HistoryStateValue;
+  [x: string]: HistoryStateValue;
+}
+/**
+ * Allowed arrays for history.state.
+ *
+ * @internal
+ */
+declare interface HistoryStateArray extends Array<HistoryStateValue> {}
+/**
+ * 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
+ */
+declare type HistoryStateValue = string | number | boolean | null | undefined | HistoryState | HistoryStateArray;
+/**
+ * Check if an object is a {@link NavigationFailure}.
+ *
+ * @param error - possible {@link NavigationFailure}
+ * @param type - optional types to check for
+ *
+ * @example
+ * ```js
+ * import { isNavigationFailure, NavigationFailureType } from 'vue-router'
+ *
+ * router.afterEach((to, from, failure) => {
+ *   // Any kind of navigation failure
+ *   if (isNavigationFailure(failure)) {
+ *     // ...
+ *   }
+ *   // Only duplicated navigations
+ *   if (isNavigationFailure(failure, NavigationFailureType.duplicated)) {
+ *     // ...
+ *   }
+ *   // Aborted or canceled navigations
+ *   if (isNavigationFailure(failure, NavigationFailureType.aborted | NavigationFailureType.canceled)) {
+ *     // ...
+ *   }
+ * })
+ * ```
+ */
+declare type Lazy<T> = () => Promise<T>;
+/**
+ * Creates a union type that still allows autocompletion for strings.
+ * @internal
+ */
+declare type _LiteralUnion<LiteralType, BaseType extends string = string> = LiteralType | (BaseType & Record<never, never>);
+/**
+ * Ensures a route is loaded, so it can be passed as o prop to `<RouterView>`.
+ *
+ * @param route - resolved route to load
+ */
+/**
+ * Normalized query object that appears in {@link RouteLocationNormalized}
+ *
+ * @public
+ */
+declare 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
+ */
+declare type LocationQueryRaw = Record<string | number, LocationQueryValueRaw | LocationQueryValueRaw[]>;
+/**
+ * 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
+ */
+declare type LocationQueryValue = string | null;
+/**
+ * Possible values when defining a query.
+ *
+ * @internal
+ */
+declare type LocationQueryValueRaw = LocationQueryValue | number | undefined;
+/**
+ * Normalized/resolved Route location that returned by the matcher.
+ */
+declare 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[];
+}
+declare interface NavigationCallback {
+  (to: HistoryLocation, from: HistoryLocation, information: NavigationInformation): void;
+}
+declare enum NavigationDirection {
+  back = "back",
+  forward = "forward",
+  unknown = ""
+}
+/**
+ * Extended Error that contains extra information regarding a failed navigation.
+ */
+declare 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;
+}
+/**
+ * Navigation Guard.
+ */
+declare interface NavigationGuard {
+  (to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext): _Awaitable<NavigationGuardReturn>;
+}
+/**
+ * `next()` callback passed to navigation guards.
+ */
+declare 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.
+ */
+declare type NavigationGuardNextCallback = (vm: ComponentPublicInstance) => unknown;
+/**
+ * Return types for a Navigation Guard. Based on `TypesConfig`
+ *
+ * @see {@link TypesConfig}
+ */
+declare type NavigationGuardReturn = void | Error | boolean | RouteLocationRaw;
+/**
+ * Navigation Guard with a type parameter for `this`.
+ * @see {@link TypesConfig}
+ */
+declare interface NavigationGuardWithThis<T> {
+  (this: T, to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext): _Awaitable<NavigationGuardReturn>;
+}
+/**
+ * Navigation hook triggered after a navigation is settled.
+ */
+declare interface NavigationHookAfter {
+  (to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, failure?: NavigationFailure | void): unknown;
+}
+declare interface NavigationInformation {
+  type: NavigationType;
+  direction: NavigationDirection;
+  delta: number;
+}
+/**
+ * Internal error used to detect a redirection.
+ *
+ * @internal
+ */
+declare enum NavigationType {
+  pop = "pop",
+  push = "push"
+}
+/**
+ * Add a navigation guard that triggers whenever the component for the current
+ * location is about to be left. Similar to {@link beforeRouteLeave} but can be
+ * used in any component. The guard is removed when the component is unmounted.
+ *
+ * @param leaveGuard - {@link NavigationGuard}
+ */
+/**
+ * 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;
+declare type PathParserOptions = Pick<_PathParserOptions, 'end' | 'sensitive' | 'strict'>;
+/**
+ * @internal
+ */
+declare 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.
+   *
+   * @defaultValue `true`
+   */
+  end?: boolean;
+}
+/**
+ * Allowed Component definitions in route records provided by the user
+ */
+declare type RawRouteComponent = RouteComponent | Lazy<RouteComponent>;
+/**
+ * Allowed Component in {@link RouteLocationMatched}
+ */
+declare type RouteComponent = Component | DefineComponent;
+/**
+ * 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
+ */
+declare type RouteLocation<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationGeneric : RouteLocationTypedList<RouteMap>[Name];
+/**
+ * Route location as an object with a `path` property.
+ */
+declare type RouteLocationAsPath<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationAsPathGeneric : RouteLocationAsPathTypedList<RouteMap>[Name];
+/**
+ * Generic version of {@link RouteLocationAsPath}. It is used when no {@link RouteMap} is provided.
+ */
+declare 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.
+ */
+declare interface RouteLocationAsPathTyped<RouteMap extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap = keyof RouteMap> extends RouteLocationAsPathGeneric {
+  path: _LiteralUnion<RouteMap[Name]['path']>;
+}
+/**
+ * List of all possible {@link RouteLocationAsPath} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationAsPathTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationAsPathTyped<RouteMap, N> };
+/**
+ * Route location relative to the current location. It accepts other properties than `path` like `params`, `query` and
+ * `hash` to conveniently change them.
+ */
+declare type RouteLocationAsRelative<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationAsRelativeGeneric : RouteLocationAsRelativeTypedList<RouteMap>[Name];
+/**
+ * Generic version of {@link RouteLocationAsRelative}. It is used when no {@link RouteMap} is provided.
+ */
+declare 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.
+ */
+declare interface RouteLocationAsRelativeTyped<RouteMap extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap = keyof RouteMap> extends RouteLocationAsRelativeGeneric {
+  name?: Extract<Name, string | symbol>;
+  params?: RouteMap[Name]['paramsRaw'];
+}
+/**
+ * List of all possible {@link RouteLocationAsRelative} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationAsRelativeTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationAsRelativeTyped<RouteMap, N> };
+/**
+ * Same as {@link RouteLocationAsPath} but as a string literal.
+ */
+declare type RouteLocationAsString<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? string : _LiteralUnion<RouteLocationAsStringTypedList<RouteMap>[Name], string>;
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationAsString} type.
+ */
+declare type RouteLocationAsStringTyped<RouteMap extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap = keyof RouteMap> = RouteMap[Name]['path'];
+/**
+ * List of all possible {@link RouteLocationAsString} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationAsStringTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationAsStringTyped<RouteMap, N> };
+/**
+ * Base properties for a normalized route location.
+ *
+ * @internal
+ */
+declare 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;
+}
+/**
+ * Generic version of {@link RouteLocation}. It is used when no {@link RouteMap} is provided.
+ */
+declare interface RouteLocationGeneric extends _RouteLocationBase {
+  /**
+   * 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[];
+}
+declare interface RouteLocationMatched extends RouteRecordNormalized {
+  components: Record<string, RouteComponent> | null | undefined;
+}
+/**
+ * Similar to {@link RouteLocation} but its
+ * {@link RouteLocationNormalizedTyped.matched | `matched` property} cannot contain redirect records
+ */
+declare type RouteLocationNormalized<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationNormalizedGeneric : RouteLocationNormalizedTypedList<RouteMap>[Name];
+/**
+ * Generic version of {@link RouteLocationNormalized} that is used when no {@link RouteMap} is provided.
+ */
+declare interface RouteLocationNormalizedGeneric extends _RouteLocationBase {
+  name: RouteRecordNameGeneric;
+  params: RouteParamsGeneric;
+  /**
+   * Array of {@link RouteRecordNormalized}
+   */
+  matched: RouteRecordNormalized[];
+}
+/**
+ * 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>`.
+ */
+declare type RouteLocationNormalizedLoaded<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationNormalizedLoadedGeneric : RouteLocationNormalizedLoadedTypedList<RouteMap>[Name];
+/**
+ * Generic version of {@link RouteLocationNormalizedLoaded} that is used when no {@link RouteMap} is provided.
+ */
+declare 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.
+ */
+declare interface RouteLocationNormalizedLoadedTyped<RouteMap extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap = keyof RouteMap> extends RouteLocationNormalizedLoadedGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap[Name]['params'];
+}
+/**
+ * List of all possible {@link RouteLocationNormalizedLoaded} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationNormalizedLoadedTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationNormalizedLoadedTyped<RouteMap, N> };
+/**
+ * Helper to generate a type safe version of the {@link RouteLocationNormalized} type.
+ */
+declare interface RouteLocationNormalizedTyped<RouteMap extends RouteMapGeneric = RouteMapGeneric, Name extends keyof RouteMap = keyof RouteMap> extends RouteLocationNormalizedGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap[Name]['params'];
+  /**
+   * Array of {@link RouteRecordNormalized}
+   */
+  matched: RouteRecordNormalized[];
+}
+/**
+ * List of all possible {@link RouteLocationNormalized} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationNormalizedTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationNormalizedTyped<RouteMap, N> };
+/**
+ * Common options for all navigation methods.
+ */
+declare 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 be passed to `router.push()` and other user-facing APIs.
+ */
+declare 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];
+/**
+ * Route location resolved with {@link Router | `router.resolve()`}.
+ */
+declare type RouteLocationResolved<Name extends keyof RouteMap = keyof RouteMap> = RouteMapGeneric extends RouteMap ? RouteLocationResolvedGeneric : RouteLocationResolvedTypedList<RouteMap>[Name];
+/**
+ * Generic version of {@link RouteLocationResolved}. It is used when no {@link RouteMap} is provided.
+ */
+declare 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.
+ */
+declare interface RouteLocationResolvedTyped<RouteMap extends RouteMapGeneric, Name extends keyof RouteMap> extends RouteLocationTyped<RouteMap, 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
+ */
+declare type RouteLocationResolvedTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationResolvedTyped<RouteMap, N> };
+/**
+ * Helper to generate a type safe version of the {@link RouteLocation} type.
+ */
+declare interface RouteLocationTyped<RouteMap extends RouteMapGeneric, Name extends keyof RouteMap> extends RouteLocationGeneric {
+  name: Extract<Name, string | symbol>;
+  params: RouteMap[Name]['params'];
+}
+/**
+ * List of all possible {@link RouteLocation} indexed by the route name.
+ * @internal
+ */
+declare type RouteLocationTypedList<RouteMap extends RouteMapGeneric = RouteMapGeneric> = { [N in keyof RouteMap]: RouteLocationTyped<RouteMap, N> };
+/**
+ * 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.
+ */
+declare type RouteMap = TypesConfig extends Record<'RouteNamedMap', infer RouteNamedMap> ? RouteNamedMap : RouteMapGeneric;
+/**
+ * Generic version of the `RouteMap`.
+ */
+declare type RouteMapGeneric = Record<string | symbol, RouteRecordInfoGeneric>;
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+declare interface RouteMeta extends Record<PropertyKey, unknown> {}
+declare type RouteParamsGeneric = Record<string, RouteParamValue | RouteParamValue[]>;
+declare type RouteParamsRawGeneric = Record<string, RouteParamValueRaw | Exclude<RouteParamValueRaw, null | undefined>[]>;
+/**
+ * @internal
+ */
+declare type RouteParamValue = string;
+/**
+ * @internal
+ */
+declare type RouteParamValueRaw = RouteParamValue | number | null | undefined;
+/**
+ * @internal
+ */
+declare interface RouteQueryAndHash {
+  query?: LocationQueryRaw;
+  hash?: string;
+}
+/**
+ * Router instance.
+ */
+declare interface Router {
+  /**
+   * @internal
+   */
+  /**
+   * Current {@link RouteLocationNormalized}
+   */
+  readonly currentRoute: Ref<RouteLocationNormalizedLoaded>;
+  /**
+   * Original options object passed to create the Router
+   */
+  readonly options: RouterOptions;
+  /**
+   * Allows turning off the listening of history events. This is a low level api for micro-frontend.
+   */
+  listening: boolean;
+  /**
+   * 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;
+  /**
+   * 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(): RouteRecord[];
+  /**
+   * Delete all routes from the router matcher.
+   */
+  clearRoutes(): void;
+  /**
+   * 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(): ReturnType<Router['go']>;
+  /**
+   * Go forward in history if possible by calling `history.forward()`.
+   * Equivalent to `router.go(1)`.
+   */
+  forward(): ReturnType<Router['go']>;
+  /**
+   * 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;
+}
+/**
+ * {@inheritDoc RouteRecordNormalized}
+ */
+declare type RouteRecord = RouteRecordNormalized;
+/**
+ * Internal type for common properties among all kind of {@link RouteRecordRaw}.
+ */
+declare 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>;
+}
+/**
+ * Helper type to define a Typed `RouteRecord`
+ * @see {@link RouteRecord}
+ */
+declare interface RouteRecordInfo<Name extends string | symbol = string, Path extends string = string, ParamsRaw extends RouteParamsRawGeneric = RouteParamsRawGeneric, Params extends RouteParamsGeneric = RouteParamsGeneric, ChildrenNames extends string | symbol = never> {
+  name: Name;
+  path: Path;
+  paramsRaw: ParamsRaw;
+  params: Params;
+  childrenNames: ChildrenNames;
+}
+declare type RouteRecordInfoGeneric = RouteRecordInfo<string | symbol, string, RouteParamsRawGeneric, RouteParamsGeneric, string | symbol>;
+/**
+ * Route Record defining multiple named components with the `components` option.
+ */
+declare 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.
+ */
+declare 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;
+}
+/**
+ * Generic version of {@link RouteRecordName}.
+ */
+declare type RouteRecordNameGeneric = string | symbol | undefined;
+/**
+ * Normalized version of a {@link RouteRecord | route record}.
+ */
+declare 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;
+}
+/**
+ * @internal
+ */
+declare type _RouteRecordProps<Name extends keyof RouteMap = keyof RouteMap> = boolean | Record<string, any> | ((to: RouteLocationNormalized<Name>) => Record<string, any>);
+declare type RouteRecordRaw = RouteRecordSingleView | RouteRecordSingleViewWithChildren | RouteRecordMultipleViews | RouteRecordMultipleViewsWithChildren | RouteRecordRedirect;
+/**
+ * Route Record that defines a redirect. Cannot have `component` or `components`
+ * as it is never rendered.
+ */
+declare interface RouteRecordRedirect extends _RouteRecordBase {
+  redirect: RouteRecordRedirectOption;
+  component?: never;
+  components?: never;
+  props?: never;
+}
+/**
+ * @internal
+ */
+declare type RouteRecordRedirectOption = RouteLocationRaw | ((to: RouteLocation) => RouteLocationRaw);
+/**
+ * Route Record defining one single component with the `component` option.
+ */
+declare 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.
+ */
+declare 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;
+}
+/**
+ * Interface implemented by History implementations that can be passed to the
+ * router as {@link Router.history}
+ *
+ * @alpha
+ */
+declare 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;
+}
+/**
+ * Component to render a link that triggers a navigation on click.
+ */
+declare const RouterLink: _RouterLinkI;
+/**
+ * Typed version of the `RouterLink` component. Its generic defaults to the typed router, so it can be inferred
+ * automatically for JSX.
+ *
+ * @internal
+ */
+declare interface _RouterLinkI {
+  new (): {
+    $props: AllowedComponentProps & ComponentCustomProps & VNodeProps & RouterLinkProps;
+    $slots: {
+      default?: ({
+        route,
+        href,
+        isActive,
+        isExactActive,
+        navigate
+      }: UnwrapRef<UseLinkReturn>) => VNode[];
+    };
+  };
+  /**
+   * Access to `useLink()` without depending on using vue-router
+   *
+   * @internal
+   */
+  useLink: typeof useLink;
+}
+declare interface RouterLinkOptions {
+  /**
+   * Route Location the link should navigate to when clicked on.
+   */
+  to: RouteLocationRaw;
+  /**
+   * Calls `router.replace` instead of `router.push`.
+   */
+  replace?: boolean;
+}
+declare 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 to initialize a {@link Router} instance.
+ */
+declare interface RouterOptions 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;
+  /**
+   * Initial list of routes that should be added to the router.
+   */
+  routes: Readonly<RouteRecordRaw[]>;
+  /**
+   * Function to control scrolling when navigating between pages. Can return a
+   * Promise to delay scrolling. Check {@link ScrollBehavior}.
+   *
+   * @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 RouterOptions.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 RouterOptions.parseQuery | 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;
+}
+/**
+ * Type of the `scrollBehavior` option that can be passed to `createRouter`.
+ */
+declare 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>;
+}
+/**
+ * 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[];
+    };
+  };
+};
+declare interface RouterViewProps {
+  name?: string;
+  route?: RouteLocationNormalized;
+}
+declare type ScrollPosition = ScrollPositionCoordinates | ScrollPositionElement;
+/**
+ * Scroll position similar to
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions | `ScrollToOptions`}.
+ * Note that not all browsers support `behavior`.
+ */
+declare type ScrollPositionCoordinates = {
+  behavior?: ScrollOptions['behavior'];
+  left?: number;
+  top?: number;
+};
+declare 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;
+}
+/**
+ * Internal normalized version of {@link ScrollPositionCoordinates} that always
+ * has `left` and `top` coordinates. Must be a type to be assignable to HistoryStateValue.
+ *
+ * @internal
+ */
+declare type _ScrollPositionNormalized = {
+  behavior?: ScrollOptions['behavior'];
+  left: number;
+  top: number;
+};
+/**
+ * Initial route location where the router is. Can be used in navigation guards
+ * to differentiate the initial navigation.
+ *
+ * @example
+ * ```js
+ * import { START_LOCATION } from 'vue-router'
+ *
+ * router.beforeEach((to, from) => {
+ *   if (from === START_LOCATION) {
+ *     // initial navigation
+ *   }
+ * })
+ * ```
+ */
+/**
+ * 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): string;
+/**
+ * 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
+ */
+declare interface TypesConfig {}
+/**
+ * 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>;
+/**
+ * Options passed to {@link useLink}.
+ */
+declare 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
+ */
+declare 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>;
+}
+/**
+ * NOTE: this used to be `@vue/runtime-core` but it should have been `vue` for a long time. Using both declaration at
+ * the same time breaks so using only one everywhere is the preferred way.
+ */
+declare module 'vue' {
+  export 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;
+  }
+  export 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;
+  }
+  export interface GlobalComponents {
+    RouterView: TypesConfig extends Record<'RouterView', infer T> ? T : typeof RouterView;
+    RouterLink: TypesConfig extends Record<'RouterLink', infer T> ? T : typeof RouterLink;
+  }
+}
+//#endregion
+//#region ../vue-utils/dist/vue-utils.d.mts
+type TypedSlot<Prop = any> = (prop: Prop) => VNodeChild;
+type VNodeChildOrSlot<Prop = any> = VNodeChild | TypedSlot<Prop>;
+//#endregion
+//#region src/utils/slots.d.ts
+type RawSlot = (...args: any[]) => any;
+type RawSlots = Record<string, RawSlot>;
+/**
+ * Modify all ReturnTypes of the map type of the Slot
+ *
+ */
+type NormalizedSlotsReturnTypes<S extends RawSlots, T> = { [K in keyof S]: (...params: Parameters<S[K]>) => T };
+/**
+ * Map of slots that can be bound as `v-slots` directives.
+ */
+type SlotsDirectiveBindings<S extends RawSlots> = NormalizedSlotsReturnTypes<S, VNodeChild>;
+/**
+ * Interface of the slots object that can be referenced in the setup context
+ */
+/**
+ * Map type of slots that can be set as `slots` option in Vue components
+ */
+type ResolvedSlots<S extends RawSlots> = SlotsType<NormalizedSlotsReturnTypes<S, VNode[]>>;
+/**
+ * A factory that generates map types for slots that can be set as `slots` options in Vue components and props options for tsx support
+ *
+ */
+type DefinedSlots<S extends RawSlots> = ResolvedSlots<S> & {
+  (): {
+    'v-slots': PropType<SlotsDirectiveBindings<S>>;
+  };
+};
+/**
+ * Define Vue slot options and props factory for tsx support
+ *
+ * @example
+ * ```tsx
+ * import { defineComponent } from 'vue';
+ * import { defineSlots } from '@fastkit/vue-utils';
+ *
+ * const slots = defineSlots({
+ *   default?: (params: string) => any;
+ *   requiredSlots: (optionalParams?: number) => any;
+ * });
+ *
+ * const Component = defineComponent({
+ *   props: {
+ *     ...slots(), // For tsx
+ *   },
+ *   slots,
+ *   setup() {
+ *     // .....
+ *   },
+ * });
+ *
+ * <Component
+ *   v-slots={{
+ *     requiredSlots: (optionalParams) => `${optionalParams || 'fallback message'}`,
+ *     default: () => <div>Hello slots.</div>
+ *   }}
+ * />
+ * ```
+ *
+ * @returns slot options and props factory
+ */
+//#endregion
+//#region ../vue-form-control/dist/vue-form-control.d.mts
+//#region src/schemes/autocapitalize.d.ts
+type FormAutoCapitalize = 'off' | 'on' | 'words' | 'characters'; //#endregion
+//#region src/schemes/autocomplete.d.ts
+declare const FORM_AUTO_COMPLETES: readonly ["off", "on", "name", "honorific-prefix", "given-name", "additional-name", "family-name", "honorific-suffix", "nickname", "email", "username", "new-password", "current-password", "one-time-code", "organization-title", "organization", "street-address", "address-line1", "address-line2", "address-line3", "address-level4", "address-level3", "address-level2", "address-level1", "country", "country-name", "postal-code", "cc-name", "cc-given-name", "cc-additional-name", "cc-family-name", "cc-number", "cc-exp", "cc-exp-month", "cc-exp-year", "cc-csc", "cc-type", "transaction-currency", "transaction-amount", "language", "bday", "bday-day", "bday-month", "bday-year", "sex", "tel", "tel-country-code", "tel-national", "tel-area-code", "tel-local", "tel-extension", "impp", "url", "photo"];
+type FormAutoComplete = (typeof FORM_AUTO_COMPLETES)[number]; //#endregion
+//#region src/schemes/textinput.d.ts
+type TextFinalizer = (value?: string | null) => string | Promise<string>;
+declare const BUILTIN_TEXT_FINALIZERS: Record<"trim" | "removeSpace" | "upper" | "lower" | "halfWidth" | "singleSpace", TextFinalizer>;
+type BuiltinTextFinalizerName = keyof typeof BUILTIN_TEXT_FINALIZERS; //#endregion
+//#region src/schemes/imask.d.ts
+//#endregion
+//#region src/composables/group.d.ts
+declare function createFormGroupProps(): {
+  /**
+   * Collect the error messages of all nodes belonging to this node
+   *
+   * By default, a node attempts to render error messages on its own, but enabling this setting allows the parent group to manage the rendering of error messages.
+   * If you want to exclude a specific node from this configuration, enable the `showOwnErrors` setting for that node.
+   */
+  collectErrorMessages: BooleanConstructor;
+  /**
+   * Auto scroll to the location of the form when invalid input is detected in the validation on submission
+   */
+  disableAutoScroll: BooleanConstructor;
+  name: StringConstructor;
+  tag: StringConstructor;
+  modelValue: vue2.Prop<unknown, unknown>;
+  tabindex: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: number;
+  };
+  autofocus: BooleanConstructor;
+  disabled: BooleanConstructor;
+  readonly: BooleanConstructor;
+  viewonly: BooleanConstructor;
+  spellcheck: BooleanConstructor;
+  required: BooleanConstructor | vue2.PropType<boolean>;
+  clearable: BooleanConstructor;
+  validateTiming: {
+    type: vue2.PropType<ValidateTiming>;
+    default: ValidateTiming;
+  };
+  rules: {
+    type: vue2.PropType<RecursiveVerifiableRuleOrFn>;
+    default: () => never[];
+  };
+  validationDeps: vue2.PropType<(nodeControl: FormNodeControl) => any>;
+  error: BooleanConstructor;
+  errorMessages: vue2.PropType<string | string[]>;
+  showOwnErrors: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+  detach: BooleanConstructor;
+};
+type FormGroupProps = ExtractPropTypes<ReturnType<typeof createFormGroupProps>>;
+declare function createFormGroupEmits(): {
+  'update:modelValue': (value: unknown) => boolean;
+  'update:errors': (errors: FormNodeError[]) => boolean;
+  change: (value: unknown) => boolean;
+  focus: (ev: FocusEvent) => boolean;
+  blur: (ev: FocusEvent) => boolean;
+};
+interface FormGroupEmitOptions extends ReturnType<typeof createFormGroupEmits> {}
+type FormGroupContext = SetupContext<FormGroupEmitOptions>;
+interface FormGroupOptions extends FormNodeControlBaseOptions {}
+declare class FormGroupControl extends FormNodeControl {
+  readonly _props: FormGroupProps;
+  protected _allNodes: Ref<FormNodeControl[]>;
+  protected _allInvalidNodes: ComputedRef<FormNodeControl[]>;
+  /**
+   * All nodes in an error state belonging recursively to this group
+   */
+  get allInvalidNodes(): FormNodeControl<any, any, BooleanConstructor>[];
+  /**
+   * Collect the error messages of all nodes belonging to this node
+   */
+  get collectErrorMessages(): boolean;
+  /**
+   * Auto scroll to the location of the form when invalid input is detected in the validation on submission
+   */
+  get disableAutoScroll(): boolean;
+  /**
+   * List of all nodes belonging to this group
+   *
+   * This list is a reactive list, and depending on usage, it may contain a large number of nodes.
+   * Please be aware that complex operations using this list can lead to performance issues.
+   */
+  get allNodes(): FormNodeControl<any, any, BooleanConstructor>[];
+  constructor(props: FormGroupProps, ctx: FormGroupContext, options?: FormGroupOptions);
+  /** @internal */
+  __joinFromNode(node: FormNodeControl): void;
+  /** @internal */
+  __leaveFromNode(node: FormNodeControl): void;
+  /**
+   * Recursively retrieve the leading node in an error state within this group
+   */
+  findFirstInvalidNode(): FormNodeControl<any, any, BooleanConstructor> | undefined;
+  /**
+   * Scroll to the position of the leading node in an error state within this group
+   */
+  scrollToFirstInvalidNode(): void;
+  protected dispatchAutoScroll(): void;
+  protected _forceFinalize(): boolean;
+  /**
+   * Validate the values of this group and all descendant nodes. If there is one or more errors, scroll to the top error node
+   *
+   * If `disableAutoScroll` is set, scrolling will not be performed.
+   */
+  validateAndScroll(): Promise<boolean>;
+}
+//#endregion
+//#region src/composables/form.d.ts
+/**
+ * Form action context
+ */
+interface FormActionContext {
+  /** Control for form element */
+  form: VueForm;
+  /** Action has been canceled */
+  get canceled(): boolean;
+  /** Submit event object */
+  get event(): Event;
+  /**
+   * Cancel the action
+   *
+   * Currently, this method simply sets the `canceled` property of the context to `false`.
+   * This specification is subject to change in the future.
+   */
+  cancel: () => void;
+}
+type FormActionHandler = (ctx: FormActionContext) => any;
+/**
+ * @deprecated
+ * This type has been changed to {@link FormActionHandler}. It will be deprecated in future releases.
+ */
+type FormAction = string | FormActionHandler;
+interface FormInvalidSubmissionAcceptorContext {
+  /** Form control */
+  readonly form: VueForm;
+  /**
+   * Accepted
+   */
+  get accepted(): boolean;
+  /**
+   * Accept submission
+   */
+  accept(): void;
+}
+type FormInvalidSubmissionAcceptor = (payload: FormInvalidSubmissionAcceptorContext) => void;
+type FormAcceptInvalidSubmissionSpec = boolean | FormInvalidSubmissionAcceptor;
+interface FormOptions extends FormGroupOptions {}
+declare function createFormProps(options?: FormOptions): {
+  /**
+   * Do not perform default HTML validation when submitting the form
+   *
+   * @default true
+   */
+  novalidate: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Action settings for form submission
+   *
+   * Set the destination URL or callback handler
+   */
+  action: PropType<FormAction>;
+  /**
+   * Automatic validation on transmission
+   *
+   * If this setting is enabled, all validation will be done before transmission and the transmission process will be canceled if there are invalid entries
+   *
+   * @default true
+   */
+  autoValidate: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * Form is sending
+   */
+  sending: BooleanConstructor;
+  /**
+   * Accept invalid values during form submission
+   *
+   * @default false
+   */
+  acceptInvalidSubmission: {
+    type: PropType<FormAcceptInvalidSubmissionSpec>;
+    default: boolean;
+  };
+  collectErrorMessages: BooleanConstructor;
+  disableAutoScroll: BooleanConstructor;
+  name: StringConstructor;
+  tag: StringConstructor;
+  modelValue: vue2.Prop<unknown, unknown>;
+  tabindex: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: number;
+  };
+  autofocus: BooleanConstructor;
+  disabled: BooleanConstructor;
+  readonly: BooleanConstructor;
+  viewonly: BooleanConstructor;
+  spellcheck: BooleanConstructor;
+  required: BooleanConstructor | PropType<boolean>;
+  clearable: BooleanConstructor;
+  validateTiming: {
+    type: PropType<ValidateTiming>;
+    default: ValidateTiming;
+  };
+  rules: {
+    type: PropType<RecursiveVerifiableRuleOrFn>;
+    default: () => never[];
+  };
+  validationDeps: PropType<(nodeControl: FormNodeControl) => any>;
+  error: BooleanConstructor;
+  errorMessages: PropType<string | string[]>;
+  showOwnErrors: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+  detach: BooleanConstructor;
+};
+type FormProps = ExtractPropTypes<ReturnType<typeof createFormProps>>;
+declare function createFormEmits(): {
+  /**
+   * Form Submission
+   *
+   * This event is notified when the validation is complete and before the action is called
+   *
+   * @param form - VueForm instance
+   * @param ev - Event
+   */
+  submit: (form: VueForm, ev: Event) => boolean;
+  /**
+   * Updating sending status
+   *
+   * @param sending - sending status
+   * @param form - VueForm instance
+   */
+  'update:sending': (sending: boolean, form: VueForm) => boolean;
+  /**
+   * The form action has been finished
+   *
+   * @param actionContext - Form action context
+   */
+  finishAction: (actionContext: FormActionContext) => boolean;
+  /**
+   * Failed automatic validation
+   *
+   * @param form - VueForm instance
+   */
+  autoValidationFailed: (form: VueForm) => boolean;
+  'update:modelValue': (value: unknown) => boolean;
+  'update:errors': (errors: FormNodeError[]) => boolean;
+  change: (value: unknown) => boolean;
+  focus: (ev: FocusEvent) => boolean;
+  blur: (ev: FocusEvent) => boolean;
+};
+interface FormEmitOptions extends ReturnType<typeof createFormEmits> {}
+type FormContext = SetupContext<FormEmitOptions>;
+/**
+ * Option to check the submittability of the form
+ */
+interface PrepareFormSubmissionOptions {
+  /** Skip operability check */
+  skipOperationCheck?: boolean;
+  /** Skip in-progress check during submission */
+  skipSendingCheck?: boolean;
+  /** Skip validation */
+  skipValidation?: boolean;
+}
+/**
+ * Dispatch option for form action
+ */
+interface DispatchFormActionOptions extends PrepareFormSubmissionOptions {
+  /** Submit event object */
+  event?: Event;
+}
+interface ComputedFormAttributes {
+  ref: Ref<HTMLFormElement | null>;
+  action: string | undefined;
+  spellcheck: boolean;
+  onSubmit: (ev: Event) => void;
+  novalidate: boolean;
+  'aria-disabled': boolean;
+}
+/**
+ * Control for form element
+ */
+declare class VueForm extends FormGroupControl {
+  readonly _props: FormProps;
+  protected _formContext: FormContext;
+  protected _nativeAction: ComputedRef<string | undefined>;
+  protected _fnAction: ComputedRef<FormActionHandler | undefined>;
+  protected _formRef: Ref<HTMLFormElement | null, HTMLFormElement | null>;
+  protected _actionPromise: Ref<{
+    then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+    catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+    finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+    readonly [Symbol.toStringTag]: string;
+  } | null, Promise<any> | {
+    then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+    catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+    finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+    readonly [Symbol.toStringTag]: string;
+  } | null>;
+  protected _sending: ComputedRef<boolean>;
+  protected _formAttrs: ComputedRef<ComputedFormAttributes>;
+  /**
+   * Do not perform default HTML validation when submitting the form
+   */
+  get novalidate(): boolean;
+  get nativeAction(): string | undefined;
+  /**
+   * Executing asynchronous submission action
+   */
+  get sending(): boolean;
+  /**
+   * Automatic validation on transmission
+   *
+   * If this setting is enabled, all validation will be done before transmission and the transmission process will be canceled if there are invalid entries
+   *
+   * @default true
+   */
+  get autoValidate(): boolean;
+  /**
+   * Attributes to apply to the form element
+   */
+  get formAttrs(): ComputedFormAttributes;
+  constructor(props: FormProps, ctx: FormContext, options?: FormOptions);
+  /**
+   * Generates SubmitEvent and dispatches it to the form element
+   *
+   * - If `preventDefault()` is called by the event handler, the sending process is canceled
+   */
+  submit(): void;
+  /**
+   * Returns `true` if the form is in a submittable state after performing state checks and validation
+   *
+   * @param options - PrepareFormSubmissionOptions
+   * @returns `true` if submission is possible
+   */
+  prepareFormSubmission(options?: PrepareFormSubmissionOptions): Promise<boolean>;
+  protected _dispatchAction(options?: DispatchFormActionOptions): Promise<void>;
+  /**
+   * Dispatch the specified action function
+   *
+   * @param options - Dispatch option for form action
+   */
+  dispatchAction(options?: DispatchFormActionOptions): Promise<void>;
+  /**
+   * Handler for form element submission
+   *
+   * @param ev - Submit event object
+   */
+  handleSubmit(ev: Event): void;
+}
+//#endregion
+//#region src/service.d.ts
+type FormErrorMessageResolver = (error: FormNodeError, node?: FormNodeControl) => string | void;
+/**
+ * Scroll option for the form element
+ */
+interface VueFormScrollOptions {
+  /**
+   * Default scroll option
+   *
+   * @see {@link ScrollIntoViewOptions}
+   */
+  options?: ScrollIntoViewOptions;
+  /**
+   * Scroll handler function
+   *
+   * @param element - Scroll target element
+   * @param options - Scroll option
+   * @returns When canceling the default scroll and implementing custom scrolling within the application, return a truthy value.
+   */
+  fn?: (element: HTMLElement, options?: ScrollIntoViewOptions) => void;
+}
+interface VueFormServiceOptions {
+  errorMessageResolvers?: FormErrorMessageResolver[];
+  /**
+   * Scroll option for the form element
+   *
+   * @see {@link VueFormScrollOptions}
+   */
+  scroll?: VueFormScrollOptions;
+  /**
+   * Default value for text input autocomplete.
+   *
+   * @see {@link FormAutoComplete}
+   */
+  defaultAutocomplete?: FormAutoComplete | boolean | undefined;
+}
+/**
+ * Root service of `vue-form-control`
+ */
+declare class VueFormService {
+  readonly errorMessageResolvers: FormErrorMessageResolver[];
+  /**
+   * Scroll option for the form element
+   *
+   * @see {@link VueFormScrollOptions}
+   */
+  readonly scroll?: VueFormScrollOptions;
+  constructor(options?: VueFormServiceOptions);
+  addMessageResolver(resolvers: FormErrorMessageResolver | FormErrorMessageResolver[]): void;
+  resolveErrorMessage(error: FormNodeError, node?: FormNodeControl): string | void;
+  scrollToElement(element: HTMLElement, options?: ScrollIntoViewOptions): void;
+} //#endregion
+//#region src/composables/wrapper.d.ts
+type RequiredChipSource = (() => VNodeChild) | string | boolean;
+type FormNodeWrapperHinttip = boolean | string | (() => VNodeChild);
+type FormNodeWrapperHinttipDelay = 'click' | number;
+declare function createFormNodeWrapperProps$1(): {
+  /**
+   * Instance of FormNodeControl
+   *
+   * When this setting is applied, the state and error messages will always refer to the state of this node. If not set, it will attempt to compute them from descendant nodes.
+   */
+  nodeControl: PropType<FormNodeControl>; /** label */
+  label: PropType<VNodeChildOrSlot>; /** hint message */
+  hint: PropType<VNodeChildOrSlot>; /** Settings for displaying hint as tips */
+  hinttip: PropType<FormNodeWrapperHinttip>; /** hint tip Display Delay */
+  hinttipDelay: PropType<FormNodeWrapperHinttipDelay>; /** Elements to be added to the information message */
+  infoAppends: PropType<VNodeChildOrSlot>; /** Hide information */
+  hiddenInfo: BooleanConstructor; /** Chip(required) display settings */
+  requiredChip: PropType<RequiredChipSource>;
+  /**
+   * Collect the error messages of all nodes belonging to this node
+   *
+   * By default, a node attempts to render error messages on its own, but enabling this setting allows the parent wrapper to manage the rendering of error messages.
+   * If you want to exclude a specific node from this configuration, enable the `showOwnErrors` setting for that node.
+   *
+   * @default true
+   */
+  collectErrorMessages: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+};
+type FormNodeWrapperProps = ExtractPropTypes<ReturnType<typeof createFormNodeWrapperProps$1>>;
+declare function createFormNodeWrapperEmits(): {
+  clickLabel: (ev: PointerEvent, wrapper: FormNodeWrapper) => boolean;
+};
+type FormNodeWrapperEmitOptions = ReturnType<typeof createFormNodeWrapperEmits>;
+type FormNodeWrapperContext = SetupContext<FormNodeWrapperEmitOptions>;
+interface FormNodeWrapperOptions {
+  hinttipPrepend?: () => VNodeChild;
+}
+/**
+ * Form node wrapper
+ */
+declare class FormNodeWrapper {
+  readonly _props: FormNodeWrapperProps;
+  readonly _service: VueFormService;
+  protected _ctx: FormNodeWrapperContext | undefined;
+  protected _allNodes: Ref<FormNodeControl[]>;
+  protected _labelSlot: ComputedRef<TypedSlot<FormNodeWrapper> | undefined>;
+  protected _hintSlot: ComputedRef<TypedSlot<FormNodeWrapper> | undefined>;
+  protected _hinttip: ComputedRef<VNodeChild>;
+  protected _hinttipDelay: ComputedRef<FormNodeWrapperHinttipDelay | undefined>;
+  protected _hinttipPrepend?: () => VNodeChild;
+  protected _infoAppendsSlot: ComputedRef<TypedSlot<FormNodeWrapper> | undefined>;
+  protected _validating: ComputedRef<boolean>;
+  protected _pending: ComputedRef<boolean>;
+  protected _focused: ComputedRef<boolean>;
+  protected _dirty: ComputedRef<boolean>;
+  protected _disabled: ComputedRef<boolean>;
+  protected _readonly: ComputedRef<boolean>;
+  protected _viewonly: ComputedRef<boolean>;
+  protected _touched: ComputedRef<boolean>;
+  protected _required: ComputedRef<boolean>;
+  protected _invalid: ComputedRef<boolean>;
+  protected _resolvedErrorMessages: ComputedRef<FormNodeErrorMessageSource[]>;
+  /**
+   * Root service of `vue-form-control`
+   *
+   * @see {@link VueFormService}
+   */
+  get service(): VueFormService;
+  /**
+   * Instance of FormNodeControl
+   *
+   * When this setting is applied, the state and error messages will always refer to the state of this node. If not set, it will attempt to compute them from descendant nodes.
+   */
+  get nodeControl(): FormNodeControl | undefined;
+  /**
+   * List of all nodes belonging to this wrapper
+   *
+   * This list is a reactive list, and depending on usage, it may contain a large number of nodes.
+   * Please be aware that complex operations using this list can lead to performance issues.
+   */
+  get allNodes(): FormNodeControl<any, any, BooleanConstructor>[];
+  /**
+   * At least one of the associated nodes is validating the value
+   */
+  get validating(): boolean;
+  /**
+   * Pending processing
+   *
+   * This is marked as `true` during the validation and finalization process of the value
+   */
+  get pending(): boolean;
+  /**
+   * One of the associated nodes is currently focused
+   */
+  get focused(): boolean;
+  /**
+   * The changes to the input value have not been committed yet
+   *
+   * @see {@link FormNodeControl.initialValue initialValue}
+   */
+  get dirty(): boolean;
+  /**
+   * The input value has not been changed from its initial value
+   */
+  get pristine(): boolean;
+  /**
+   * All associated nodes are disabled
+   */
+  get isDisabled(): boolean;
+  /**
+   * All associated nodes are read-only
+   */
+  get isReadonly(): boolean;
+  /**
+   * All associated nodes are view-only
+   */
+  get isViewonly(): boolean;
+  /**
+   * All associated nodes are operable
+   */
+  get canOperation(): boolean;
+  /**
+   * One of the associated nodes has already been touched
+   */
+  get touched(): boolean;
+  /**
+   * None of the associated nodes has been touched yet
+   */
+  get untouched(): boolean;
+  /**
+   * One of the associated nodes requires input
+   */
+  get isRequired(): boolean;
+  /**
+   * There is an error in the input value of one of the associated nodes
+   */
+  get invalid(): boolean;
+  /**
+   * No errors in the input values of all associated nodes
+   */
+  get valid(): boolean;
+  /**
+   * Collect the error messages of all nodes belonging to this node
+   */
+  get collectErrorMessages(): boolean;
+  /**
+   * Source code for all collected error messages
+   *
+   * This list is generated based on the setting of {@link FormNodeControl.showOwnErrors showOwnErrors}.
+   *
+   * @see {@link FormNodeErrorMessageSource}
+   */
+  get errorMessages(): FormNodeErrorMessageSource[];
+  /**
+   * Source code for the first error message among all collected messages
+   *
+   * This list is generated based on the setting of {@link FormNodeControl.showOwnErrors showOwnErrors}.
+   *
+   * @see {@link FormNodeErrorMessageSource}
+   */
+  get firstErrorMessage(): FormNodeErrorMessageSource | undefined;
+  get labelSlot(): TypedSlot<FormNodeWrapper> | undefined;
+  get hintSlot(): TypedSlot<FormNodeWrapper> | undefined;
+  get infoAppendsSlot(): TypedSlot<FormNodeWrapper> | undefined;
+  get hinttipDelay(): FormNodeWrapperHinttipDelay | undefined;
+  constructor(props: FormNodeWrapperProps, ctx: FormNodeWrapperContext, options?: FormNodeWrapperOptions);
+  renderLabel(): vue2.VNodeArrayChildren | undefined;
+  renderHint(allowNotFocused?: boolean): vue2.VNodeArrayChildren | undefined;
+  renderInfoAppends(): vue2.VNodeArrayChildren | undefined;
+  protected _getContextOrDie(): {
+    attrs: {
+      [x: string]: unknown;
+    };
+    slots: Readonly<{
+      [name: string]: vue2.Slot<any> | undefined;
+    }>;
+    emit: (event: "clickLabel", ev: PointerEvent, wrapper: FormNodeWrapper) => void;
+    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+  };
+  renderFirstError(slotsOverrides?: FormNodeErrorSlotsSource): vue2.VNodeArrayChildren | undefined;
+  renderMessage(allowNotFocused?: boolean): vue2.VNodeArrayChildren | " ";
+  renderHinttip(): {
+    tip: VNodeChild;
+    hint: VNodeChild;
+  } | undefined;
+  /** @internal */
+  __joinFromNode(node: FormNodeControl): void;
+  /** @internal */
+  __leaveFromNode(node: FormNodeControl): void;
+  /**
+   * Generate a Proxy instance that extends the interface for this wrapper.
+   *
+   * @param trait - trait object
+   * @returns Mixed-in Proxy
+   */
+  extend<U extends object>(trait: U): Mixin<this, U>;
+}
+//#endregion
+//#region src/composables/node.d.ts
+type RecursiveVerifiableRuleOrFn = RecursiveArray<VerifiableRuleOrFn>;
+type FormNodeType = string | number | symbol;
+interface FormNodeError extends Omit<ValidationError, '$$symbol'> {}
+/**
+ * Validation Timing
+ *
+ * - `always` Always validate
+ * - `touch` Once touched, always validated thereafter.
+ * - `blur` Once the focus is removed from the element at least once, subsequent validations will always be performed.
+ * - `change` Once the value is changed at least once, subsequent validations will always be performed.
+ * - `manual` Validation is not performed automatically. Only manual validation through programming is possible.
+ *
+ */
+type ValidateTiming = 'always' | 'touch' | 'blur' | 'change' | 'manual';
+type ValidationResult = ValidationError[] | null;
+type ValidateResolver = (result: ValidationResult) => void;
+type FormNodeStateExtension = (nodeControl: FormNodeControl, computedValue: boolean) => boolean;
+interface FormNodeStateExtensions {
+  disabled?: FormNodeStateExtension;
+  readonly?: FormNodeStateExtension;
+  viewonly?: FormNodeStateExtension;
+  canOperation?: FormNodeStateExtension;
+}
+interface FormNodeControlBaseOptions {
+  nodeType?: FormNodeType;
+  requiredFactory?: () => Rule<any> | undefined;
+  defaultValidateTiming?: ValidateTiming;
+  validationValue?: () => any;
+  stateExtensions?: FormNodeStateExtensions;
+  /** Add a custom error message */
+  errorMessages?: () => string | string[] | undefined;
+}
+interface FormNodeControlOptions<T = any, D = T, Required extends Prop<any> = BooleanConstructor> extends FormNodeControlBaseOptions {
+  modelValue?: Prop<T, D>;
+  required?: Required;
+  shallow?: boolean;
+}
+type FormNodeErrorSlotsSource = {
+  /** Error message */error?: (error: FormNodeError) => any;
+} & { [K in `error:${string}`]: (error: FormNodeError) => any };
+declare function createFormNodeProps<T, D = T, Required extends Prop<any> = PropType<boolean>>(options?: FormNodeControlOptions<T, D, Required>): {
+  /**
+   * form node name
+   *
+   * This is set as is for input elements.
+   */
+  name: StringConstructor;
+  /**
+   * Tag string for node searching
+   */
+  tag: StringConstructor; /** model value */
+  modelValue: Prop<T, D>;
+  /**
+   * Tab index
+   *
+   * @default 0
+   *
+   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/tabindex
+   */
+  tabindex: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: number;
+  }; /** Automatic focus */
+  autofocus: BooleanConstructor; /** disabled state */
+  disabled: BooleanConstructor; /** read-only state */
+  readonly: BooleanConstructor; /** view-only state */
+  viewonly: BooleanConstructor;
+  /**
+   * Spell Check Settings
+   *
+   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/spellcheck
+   */
+  spellcheck: BooleanConstructor; /** required */
+  required: BooleanConstructor | Required; /** clearable */
+  clearable: BooleanConstructor;
+  /**
+   * Validation Timing
+   *
+   * - `always` Always validate
+   * - `touch` Once touched, always validated thereafter.
+   * - `blur` Once the focus is removed from the element at least once, subsequent validations will always be performed.
+   * - `change` Once the value is changed at least once, subsequent validations will always be performed.
+   * - `manual` Validation is not performed automatically. Only manual validation through programming is possible.
+   *
+   * @see {@link ValidateTiming}
+   */
+  validateTiming: {
+    type: PropType<ValidateTiming>;
+    default: ValidateTiming;
+  };
+  /**
+   * List of validation rules
+   */
+  rules: {
+    type: PropType<RecursiveVerifiableRuleOrFn>;
+    default: () => never[];
+  };
+  /**
+   * Validation dependencies
+   *
+   * In vue-form-control, validation is performed again whenever the input value or related values change. However, if the validation condition references values from other nodes or external reactive values that are not included in the node, those changes cannot be detected.
+   * By registering a function that returns such external reactive values, validation can be automatically triggered.
+   */
+  validationDeps: PropType<(nodeControl: FormNodeControl) => any>; /** Force an error state. */
+  error: BooleanConstructor; /** List of error messages. */
+  errorMessages: PropType<string | string[]>;
+  /**
+   * Display error messages on this node itself
+   *
+   * If `true`, attempts to render errors for this node itself; if `false`, delegates error message display to the associated form group or wrapper.
+   *
+   * @default `false` if a parent group or wrapper exists and the `collectErrorMessages` setting is enabled; otherwise, `true`.
+   */
+  showOwnErrors: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+  /**
+   * Detach and become independent from the parent node
+   *
+   * By default, the form node inherits the state of the form node existing in the parent tree and notifies the parent node of its own validation status, among other things. This option disables that behavior, allowing this node and its descendants to be detached from the parent node.
+   */
+  detach: BooleanConstructor;
+};
+type FormNodeProps = ExtractPropTypes<ReturnType<typeof createFormNodeProps>>;
+declare class Wrapper<T, D = T> {
+  wrapped(options: FormNodeControlOptions<T, D>): {
+    /**
+     * Update Model Values
+     */
+    'update:modelValue': (value: T | D) => boolean;
+    /**
+     * Updating error content.
+     * @param errors - List of error contents.
+     */
+    'update:errors': (errors: FormNodeError[]) => boolean;
+    /**
+     * Update Model Values
+     */
+    change: (value: T | D) => boolean;
+    /**
+     * Focus on an element.
+     * @param ev - FocusEvent
+     */
+    focus: (ev: FocusEvent) => boolean;
+    /**
+     * The focus is removed from an element.
+     * @param ev - FocusEvent
+     */
+    blur: (ev: FocusEvent) => boolean;
+  };
+}
+interface FormNodeEmitOptions<T, D = T> extends ReturnType<Wrapper<T, D>['wrapped']> {}
+type FormNodeContext<T, D = T> = SetupContext<FormNodeEmitOptions<T, D>>;
+/**
+ * Source code for rendering error messages of form nodes
+ */
+interface FormNodeErrorMessageSource {
+  /** Render error message */
+  render: (slotsOverrides?: FormNodeErrorSlotsSource) => VNodeArrayChildren;
+  /**
+   * Error object
+   *
+   * @see {@link FormNodeError}
+   */
+  error: FormNodeError;
+  /**
+   * Node holding the error
+   *
+   * @see {@link FormNodeControl}
+   */
+  node: FormNodeControl;
+  /**
+   * Automatically generated key
+   *
+   * Can be safely used as the key for the vnode when rendering in lists, etc.
+   */
+  key: string;
+}
+/**
+ * Base class for all form nodes
+ */
+declare class FormNodeControl<T = any, D = T, Required extends Prop<any> = BooleanConstructor> {
+  readonly _props: FormNodeProps;
+  readonly _service: VueFormService;
+  readonly nodeType?: FormNodeType;
+  readonly __multiple: boolean;
+  protected _isMounted: Ref<boolean, boolean>;
+  protected _mountedId: Ref<number | undefined, number | undefined>;
+  protected _ctx: FormNodeContext<T, D>;
+  protected _parentNode: FormNodeControl | null;
+  protected _parentForm: VueForm | null;
+  protected _parentFormGroup: FormGroupControl | null;
+  protected _parentFormNodeWrapper: FormNodeWrapper | null;
+  protected _booted: Ref<boolean, boolean>;
+  protected _name: ComputedRef<string | undefined>;
+  protected _value: Ref<T | D>;
+  protected _initialValue: Ref<T | D>;
+  protected _focused: Ref<boolean, boolean>;
+  protected _children: Ref<FormNodeControl[]>;
+  protected _invalidChildren: ComputedRef<FormNodeControl[]>;
+  protected _finalizePromise: Ref<(() => Promise<void>) | null>;
+  protected _validationErrors: Ref<ValidationError[]>;
+  protected _validateResolvers: ValidateResolver[];
+  protected _lastValidateValueChanged: boolean;
+  protected _validating: Ref<boolean, boolean>;
+  protected _validateRequestId: number;
+  protected _isDestroyed: boolean;
+  protected _dirty: ComputedRef<boolean>;
+  protected _touched: Ref<boolean, boolean>;
+  protected _shouldValidate: Ref<boolean, boolean>;
+  protected _currentValue: WritableComputedRef<T | D>;
+  protected _errorMessages: ComputedRef<string[]>;
+  protected _errors: ComputedRef<FormNodeError[]>;
+  protected _resolvedErrorMessages: ComputedRef<FormNodeErrorMessageSource[]>;
+  protected _errorCount: ComputedRef<number>;
+  protected _isDisabled: ComputedRef<boolean>;
+  protected _isReadonly: ComputedRef<boolean>;
+  protected _isViewonly: ComputedRef<boolean>;
+  protected _canOperation: ComputedRef<boolean>;
+  protected _rules: ComputedRef<VerifiableRule[]>;
+  protected _hasRequired: ComputedRef<boolean>;
+  protected _tabindex: ComputedRef<number>;
+  protected _cii: ComponentInternalInstance | null;
+  protected _validationValueGetter?: () => any;
+  protected _shouldSkipValidation: boolean;
+  protected _stateExtensions: FormNodeStateExtensions;
+  protected _requiredFactory: () => Rule<any> | undefined;
+  /**
+   * Root service of `vue-form-control`
+   *
+   * @see {@link VueFormService}
+   */
+  get service(): VueFormService;
+  /**
+   * form node name
+   *
+   * This is set as is for input elements.
+   */
+  get name(): string | undefined;
+  /**
+   * Tag string for node searching
+   */
+  get tag(): string | undefined;
+  /** Parent node */
+  get parentNode(): FormNodeControl | null;
+  /** Parent form group */
+  get parentFormGroup(): FormGroupControl | null;
+  /** Parent form node wrapper */
+  get parentFormNodeWrapper(): FormNodeWrapper | null;
+  /** Parent form */
+  get parentForm(): VueForm | null;
+  /** Automatic focus */
+  get autofocus(): boolean;
+  /**
+   * Detached and independent from the parent node
+   */
+  get detached(): boolean;
+  /**
+   * Component created
+   *
+   * @remarks
+   * Please be aware that it may not have been mounted yet.
+   */
+  get booted(): boolean;
+  /** Component mounted */
+  get isMounted(): boolean;
+  /** If already mounted, its unique ID. */
+  get mountedId(): number | undefined;
+  /** If already mounted, its unique ID. */
+  get mountedNodeId(): string | undefined;
+  /** Finalizing the value adjustment process */
+  get isFinalizing(): boolean;
+  /** Validating the value */
+  get validating(): boolean;
+  /**
+   * Pending processing
+   *
+   * This is marked as `true` during the validation and finalization process of the value
+   */
+  get pending(): boolean;
+  /** Current input value */
+  get value(): T | D;
+  set value(value: T | D);
+  /** Value used for validation */
+  get validationValue(): any;
+  /** In focus */
+  get focused(): boolean;
+  /**
+   * Initial value before commit
+   *
+   * This value, once initialized with the value passed when the FormNode is instantiated, will not be modified from within the vue-form-control package internals.
+   * Calling the commit series of methods from the application side updates the value to its state at that moment.
+   *
+   * @see {@link FormNodeControl.commitSelfValue commitSelfValue}
+   * @see {@link FormNodeControl.commitValue commitValue}
+   * @see {@link FormNodeControl.commitSelf commitSelf}
+   * @see {@link FormNodeControl.commit commit}
+   */
+  get initialValue(): T | D;
+  /**
+   * The changes to the input value have not been committed yet
+   *
+   * @see {@link FormNodeControl.initialValue initialValue}
+   */
+  get dirty(): boolean;
+  /**
+   * The input value has not been changed from its initial value
+   */
+  get pristine(): boolean;
+  /**
+   * Touched the elements of this node at least once
+   */
+  get touched(): boolean;
+  set touched(touched: boolean);
+  /**
+   * Not touched the elements of this node yet.
+   */
+  get untouched(): boolean;
+  /**
+   * The list of FormNode instances directly belonging to this node as children
+   */
+  get children(): FormNodeControl[];
+  /**
+   * The list of FormNode instances directly belonging to itself, and possessing one or more errors
+   */
+  get invalidChildren(): FormNodeControl[];
+  /**
+   * The list of validation errors for the value within itself
+   */
+  get validationErrors(): ValidationError[];
+  /**
+   * The list of all errors within itself
+   *
+   * This is a merged list of error messages injected through properties and its own `validationErrors`.
+   *
+   * @remarks
+   * This list does not include error information specified with the `error` attribute.
+   */
+  get errors(): FormNodeError[];
+  /**
+   * Source code for all collected error messages
+   *
+   * This list is generated based on the setting of {@link FormNodeControl.showOwnErrors showOwnErrors}.
+   *
+   * @see {@link FormNodeErrorMessageSource}
+   */
+  get errorMessages(): FormNodeErrorMessageSource[];
+  /**
+   * Source code for the first error message among all collected messages
+   *
+   * This list is generated based on the setting of {@link FormNodeControl.showOwnErrors showOwnErrors}.
+   *
+   * @see {@link FormNodeErrorMessageSource}
+   */
+  get firstErrorMessage(): FormNodeErrorMessageSource | undefined;
+  /**
+   * Whether itself has one or more errors
+   *
+   * @remarks
+   * This also takes into consideration the configuration of the `error` property.
+   */
+  get hasMyError(): boolean;
+  /**
+   * The number of errors it possesses
+   */
+  get errorCount(): number;
+  /**
+   * Either itself or the parent node has one or more errors.
+   */
+  get hasError(): boolean;
+  /**
+   * Either itself or the parent node is in a disabled state.
+   */
+  get isDisabled(): boolean;
+  /**
+   * Either itself or the parent node is in a read-only state.
+   */
+  get isReadonly(): boolean;
+  /**
+   * Either itself or the parent node is in a view-only state.
+   */
+  get isViewonly(): boolean;
+  /**
+   * Operable
+   */
+  get canOperation(): boolean;
+  /**
+   * Validation Timing
+   *
+   *@see {@link ValidateTiming}
+   */
+  get validateTiming(): ValidateTiming;
+  /**
+   * Always perform value validation.
+   */
+  get validateTimingIsAlways(): boolean;
+  /**
+   * Perform value validation only when the elements of this node have been touched at least once.
+   */
+  get validateTimingIsTouch(): boolean;
+  /**
+   * Perform value validation when focus is removed from the elements of this node.
+   */
+  get validateTimingIsBlur(): boolean;
+  /**
+   * Perform value validation when the input value changes.
+   */
+  get validateTimingIsChange(): boolean;
+  /**
+   * Value validation is manually performed on the application side.
+   */
+  get validateTimingIsManual(): boolean;
+  /**
+   * The list of all rules, including those specified in the properties under 'rules' and others calculated from values related to rule logic.
+   */
+  get rules(): VerifiableRule[];
+  /**
+   * Input is required
+   *
+   * @remarks
+   * This checks whether there is at least one 'required' rule in the 'required' setting or within the specified 'rules'.
+   */
+  get isRequired(): boolean;
+  /**
+   * The component has been destroyed
+   */
+  get isDestroyed(): boolean;
+  /**
+   * There is at least one node in an error state among the nodes directly under this node
+   */
+  get hasInvalidChild(): boolean;
+  /**
+   * Either this node or one of its descendants has an error
+   */
+  get invalid(): boolean;
+  /**
+   * This node and none of its descendants have an error
+   */
+  get valid(): boolean;
+  /**
+   * Tab index
+   *
+   * When the node is disabled, it is forcibly set to `-1`.
+   */
+  get tabindex(): number;
+  /**
+   * Spell Check Settings
+   *
+   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/spellcheck
+   */
+  get spellcheck(): boolean;
+  /**
+   * The input value should be validated
+   *
+   * This varies based on the specified `validateTiming` and the user's interaction status.
+   */
+  get shouldValidate(): boolean;
+  /**
+   * The form to which this node belongs is currently executing an asynchronous submission action
+   *
+   * @remarks
+   * If the `detach` option is set, this will always be `false`.
+   */
+  get sending(): boolean;
+  /**
+   * The current Vue instance initializing this node
+   */
+  get currentInstance(): ComponentInternalInstance | null;
+  /**
+   * The host element of the current Vue instance initializing this node
+   */
+  get currentEl(): HTMLElement | null;
+  /**
+   * Multiple input mode
+   */
+  get multiple(): boolean;
+  /**
+   * Display error messages on this node itself
+   */
+  get showOwnErrors(): boolean;
+  /**
+   * Whether to temporarily skip validation.
+   * Useful for internal operations where validation is not needed.
+   */
+  get shouldSkipValidation(): boolean;
+  readonly shallow: boolean;
+  constructor(props: FormNodeProps, ctx: FormNodeContext<T, D>, options: FormNodeControlOptions<T, D, Required>);
+  /** @internal */
+  _createFormNodeErrorMessageSource(error: FormNodeError, index: number, slotsOverrides?: FormNodeErrorSlotsSource): FormNodeErrorMessageSource;
+  protected hasRequiredRule(): VerifiableRule | undefined;
+  /**
+   * Recursively searches and retrieves the FormNode belonging to this node.
+   *
+   * @param predicate - Predicate executed recursively on descendant elements
+   */
+  findNodeRecursive(predicate: (node: FormNodeControl) => unknown): FormNodeControl | undefined;
+  /**
+   * Recursively retrieves all FormNodes belonging to this node.
+   *
+   * @param predicate - Predicate executed recursively on descendant elements
+   */
+  filterNodesRecursive(predicate: (node: FormNodeControl) => unknown): FormNodeControl[];
+  /**
+   * Search for a node within this node that matches the specified name
+   *
+   * @param name Node name
+   */
+  findNodeByName(name: string): FormNodeControl | undefined;
+  /**
+   * Search for a node within this node that matches the specified tag
+   *
+   * @param tag Tag string
+   */
+  findNodeByTag(tag: string): FormNodeControl | undefined;
+  protected _getContextOrDie(): {
+    attrs: {
+      [x: string]: unknown;
+    };
+    slots: Readonly<{
+      [name: string]: vue2.Slot<any> | undefined;
+    }>;
+    emit: ((event: "blur", ev: FocusEvent) => void) & ((event: "change", value: T | D) => void) & ((event: "update:modelValue", value: T | D) => void) & ((event: "update:errors", errors: FormNodeError[]) => void) & ((event: "focus", ev: FocusEvent) => void);
+    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+  };
+  /**
+   * Render the specified error source as a `VNodeArrayChildren`
+   *
+   * @param errorSource - string or FormNodeError
+   */
+  renderErrorSource(errorSource: string | FormNodeError, slotsOverrides?: FormNodeErrorSlotsSource): VNodeArrayChildren;
+  protected _finalize(): Promise<void>;
+  /**
+   * Finalize the input value
+   */
+  finalize(): Promise<void>;
+  /**
+   * Ensure that the input value is finalized
+   */
+  ensureFinalized(): Promise<void>;
+  /**
+   * Ensure that the value of the self-node and all its child nodes is finalized
+   */
+  finalizeAll(): Promise<void>;
+  /**
+   * Set the value
+   *
+   * @param value - value
+   */
+  setValue(value: T | D): boolean;
+  protected _syncValueFromProps(value: any): void;
+  protected _resolveRules(): VerifiableRule[];
+  /**
+   * Set the validation execution necessity
+   *
+   * @param shouldValidate - The input value should be validated
+   */
+  setShouldValidate(shouldValidate: boolean): void;
+  /**
+   * Retrieve the default value when there is no input value
+   */
+  emptyValue(): T | D;
+  /**
+   * If the specified value is nullable, return `emptyValue`; otherwise, return the specified value as is
+   *
+   * @param value - Any value
+   */
+  safeModelValue(value: any): T | D;
+  /**
+   * Find and retrieve a rule corresponding to the specified name or a name matching the regular expression
+   *
+   * @param ruleName - Name or regular expression
+   */
+  findRule(ruleName: string | RegExp): VerifiableRule | undefined;
+  /**
+   * Reset the input value of this node to the initial value or the value at the last commit, whichever is applicable
+   *
+   * @see {@link FormNodeControl.initialValue initialValue}
+   *
+   * @remarks
+   * This method does not reset the validation state. Typically, consider using {@link FormNodeControl.resetSelf resetSelf}.
+   */
+  resetSelfValue(): void;
+  /**
+   * Reset the input value of this node and all its descendant nodes to the initial value or the value at the last commit, whichever is applicable
+   *
+   * @see {@link FormNodeControl.resetSelfValue resetSelfValue}
+   *
+   * @remarks
+   * This method does not reset the validation state. Typically, consider using {@link FormNodeControl.resetSelf reset}.
+   */
+  resetValue(): void;
+  /**
+   * Set the current input value as the initial value for this node.
+   *
+   * @remarks
+   * This method does not reset the validation state. Typically, consider using {@link FormNodeControl.commitSelf commitSelf}.
+   */
+  commitSelfValue(): void;
+  /**
+   * Set the current input value as the initial value for this node and all its descendant nodes
+   *
+   * @remarks
+   * This method does not reset the validation state. Typically, consider using {@link FormNodeControl.commit commit}.
+   */
+  commitValue(): void;
+  private _resetGuard;
+  /**
+   * Reset the validation state of this node
+   *
+   * @remarks
+   * This method does not perform a reset on descendant nodes. Typically, consider using {@link FormNodeControl.resetValidates resetValidates}.
+   */
+  resetSelfValidates(): void;
+  /**
+   * Reset the validation state of this node and all its descendant nodes
+   */
+  resetValidates(): void;
+  /**
+   * Reset the input value of this node to the initial value and reset the validation state
+   *
+   * @remarks
+   * This method does not reset the state of descendant nodes. Typically, consider using {@link FormNodeControl.reset reset}.
+   */
+  resetSelf(): void;
+  /**
+   * Execute any process while skipping ongoing asynchronous validation, if any
+   *
+   * @param fn - The function to be executed
+   */
+  skipValidation(fn: (...args: any) => any): Promise<void>;
+  /**
+   * Reset the input value of this node and all its descendant nodes to the initial value and reset the validation state
+   */
+  reset(): Promise<void>;
+  /**
+   * Clear the input value of this node
+   */
+  clearSelf(): void;
+  /**
+   * Clear the input value of this node and all its descendant nodes
+   */
+  clear(): void;
+  /**
+   * Set the current input value of this node as the initial value and reset the validation state
+   *
+   * @remarks
+   * This method does not reset the state of descendant nodes. Typically, consider using {@link FormNodeControl.commit commit}.
+   */
+  commitSelf(): void;
+  /**
+   * Set the current input value as the initial value for this node and all its descendant nodes, and reset the validation state
+   */
+  commit(): void;
+  focus(opts?: FocusOptions): void;
+  blur(): void;
+  protected _forceFinalize(): boolean | undefined;
+  /**
+   * Execute validation for this node and all its descendant nodes, and retrieve the validation results
+   *
+   * @param force - Force execution
+   * @param forceFinalize - Always finalize the value before validation
+   *
+   * @returns If validation is successful, return `true`.
+   */
+  validate(force?: boolean, forceFinalize?: boolean | undefined): Promise<boolean>;
+  /**
+   * Validate all nodes belonging to this node
+   *
+   * @remarks
+   * Typically, consider using {@link FormNodeControl.validate validate}.
+   *
+   * @param force - Force execution
+   * @param forceFinalize - Always finalize the value before validation
+   */
+  validateChildren(force?: boolean, forceFinalize?: boolean | undefined): Promise<boolean[]>;
+  protected _allowFinalize(): boolean;
+  /**
+   * Validate the input value of this node
+   *
+   * This method usually cancels execution and returns the previous result in the following conditions:
+   *
+   * - The value for validation has not changed since the last validation.
+   * - Currently, asynchronous validation is in progress.
+   *
+   * If you want to ignore this and force validation, specify `true` for the `force` argument
+   *
+   * @param force - Force execution
+   * @param forceFinalize - Always finalize the value before validation
+   *
+   * @returns Validation result (either the list of validation errors or null).
+   *
+   * @remarks
+   * This method does not perform a reset on descendant nodes. Typically, consider using {@link FormNodeControl.validate validate}.
+   */
+  validateSelf(force?: boolean, forceFinalize?: boolean | undefined): Promise<ValidationResult>;
+  private resolveValidateResolvers;
+  private clearValidateResolvers;
+  /** @internal */
+  _joinFromNode(node: FormNodeControl): void;
+  /** @internal */
+  _leaveFromNode(node: FormNodeControl): void;
+  focusHandler(ev: FocusEvent): void;
+  blurHandler(ev: FocusEvent): void;
+  /**
+   * Scroll to the visible position of the host element of this node
+   *
+   * @param options - options
+   */
+  scrollIntoView(options?: ScrollIntoViewOptions): void;
+  /**
+   * Generate a Proxy instance that extends the interface for this node.
+   *
+   * @param trait - trait object
+   * @returns Mixed-in Proxy
+   */
+  extend<U extends object>(trait: U): Mixin<this, U>;
+}
+//#endregion
+//#region src/composables/textable.d.ts
+type TextableFinalizerSpec = TextFinalizer | BuiltinTextFinalizerName | (TextFinalizer | BuiltinTextFinalizerName)[];
+//#endregion
+//#region src/plugin.d.ts
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $form: VueFormService;
+  }
+}
+//#endregion
+//#region src/components/VWysiwygEditor/VWysiwygEditor.d.ts
+interface VWysiwygEditorAPI {
+  readonly editor: Editor | undefined;
+  readonly control: TextableControl;
+}
+declare const VWysiwygEditor: vue2.DefineComponent<vue2.ExtractPropTypes<{
+  extensions: {
+    type: PropType<RawWysiwygExtension[]>;
+    default: () => never[];
+  };
+  tools: {
+    type: PropType<RawWysiwygEditorTool[]>;
+    default: () => never[];
+  };
+  floatingToolbar: BooleanConstructor;
+  disabledMinHeight: BooleanConstructor;
+  disabledMaxHeight: BooleanConstructor;
+  removeDefaultWrapper: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  'v-slots': PropType<{
+    [x: `error:${string}`]: (error: FormNodeError) => VNodeChild;
+    label?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    hint?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    infoAppends?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    error?: ((error: FormNodeError) => VNodeChild) | undefined;
+    default?: (() => VNodeChild) | undefined;
+    startAdornment?: (() => VNodeChild) | undefined;
+    endAdornment?: (() => VNodeChild) | undefined;
+  }>;
+  size: {
+    type: PropType<_fastkit_vui0.ControlSize>;
+    validator: (value: any) => boolean;
+  };
+  loading: BooleanConstructor;
+  variant: {
+    type: PropType<_fastkit_vui0.ControlFieldVariant>;
+    validator: (value: any) => boolean;
+  };
+  startAdornment: PropType<VNodeChildOrSlot>;
+  endAdornment: PropType<VNodeChildOrSlot>;
+  tabindex: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: number;
+  };
+  nodeControl: PropType<FormNodeControl>;
+  label: PropType<VNodeChildOrSlot>;
+  hint: PropType<VNodeChildOrSlot>;
+  hinttip: PropType<FormNodeWrapperHinttip>;
+  hinttipDelay: PropType<FormNodeWrapperHinttipDelay>;
+  infoAppends: PropType<VNodeChildOrSlot>;
+  hiddenInfo: BooleanConstructor;
+  requiredChip: PropType<RequiredChipSource>;
+  collectErrorMessages: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  minlength: (StringConstructor | NumberConstructor)[];
+  maxlength: (StringConstructor | NumberConstructor)[];
+  pattern: (StringConstructor | RegExpConstructor)[];
+  placeholder: StringConstructor;
+  autocapitalize: PropType<FormAutoCapitalize>;
+  finalizers: PropType<TextableFinalizerSpec>;
+  counter: PropType<boolean | string | number>;
+  counterValue: PropType<(value: string) => number>;
+  limit: BooleanConstructor;
+  autocomplete: {
+    type: PropType<FormAutoComplete | boolean>;
+    default: () => boolean | "off" | "on" | "name" | "honorific-prefix" | "given-name" | "additional-name" | "family-name" | "honorific-suffix" | "nickname" | "email" | "username" | "new-password" | "current-password" | "one-time-code" | "organization-title" | "organization" | "street-address" | "address-line1" | "address-line2" | "address-line3" | "address-level4" | "address-level3" | "address-level2" | "address-level1" | "country" | "country-name" | "postal-code" | "cc-name" | "cc-given-name" | "cc-additional-name" | "cc-family-name" | "cc-number" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-csc" | "cc-type" | "transaction-currency" | "transaction-amount" | "language" | "bday" | "bday-day" | "bday-month" | "bday-year" | "sex" | "tel" | "tel-country-code" | "tel-national" | "tel-area-code" | "tel-local" | "tel-extension" | "impp" | "url" | "photo" | undefined;
+  };
+  name: StringConstructor;
+  tag: StringConstructor;
+  modelValue: vue2.Prop<any, any>;
+  autofocus: BooleanConstructor;
+  disabled: BooleanConstructor;
+  readonly: BooleanConstructor;
+  viewonly: BooleanConstructor;
+  spellcheck: BooleanConstructor;
+  required: BooleanConstructor | PropType<boolean>;
+  clearable: BooleanConstructor;
+  validateTiming: {
+    type: PropType<ValidateTiming>;
+    default: ValidateTiming;
+  };
+  rules: {
+    type: PropType<RecursiveVerifiableRuleOrFn>;
+    default: () => never[];
+  };
+  validationDeps: PropType<(nodeControl: FormNodeControl) => any>;
+  error: BooleanConstructor;
+  errorMessages: PropType<string | string[]>;
+  showOwnErrors: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+  detach: BooleanConstructor;
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue2.ComponentOptionsMixin, vue2.ComponentOptionsMixin, {
+  'update:modelValue': (value: string) => boolean;
+  'update:errors': (errors: FormNodeError[]) => boolean;
+  change: (value: string) => boolean;
+  focus: (ev: FocusEvent) => boolean;
+  blur: (ev: FocusEvent) => boolean;
+}, string, vue2.PublicProps, Readonly<vue2.ExtractPropTypes<{
+  extensions: {
+    type: PropType<RawWysiwygExtension[]>;
+    default: () => never[];
+  };
+  tools: {
+    type: PropType<RawWysiwygEditorTool[]>;
+    default: () => never[];
+  };
+  floatingToolbar: BooleanConstructor;
+  disabledMinHeight: BooleanConstructor;
+  disabledMaxHeight: BooleanConstructor;
+  removeDefaultWrapper: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  'v-slots': PropType<{
+    [x: `error:${string}`]: (error: FormNodeError) => VNodeChild;
+    label?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    hint?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    infoAppends?: ((wrapper: FormNodeWrapper) => VNodeChild) | undefined;
+    error?: ((error: FormNodeError) => VNodeChild) | undefined;
+    default?: (() => VNodeChild) | undefined;
+    startAdornment?: (() => VNodeChild) | undefined;
+    endAdornment?: (() => VNodeChild) | undefined;
+  }>;
+  size: {
+    type: PropType<_fastkit_vui0.ControlSize>;
+    validator: (value: any) => boolean;
+  };
+  loading: BooleanConstructor;
+  variant: {
+    type: PropType<_fastkit_vui0.ControlFieldVariant>;
+    validator: (value: any) => boolean;
+  };
+  startAdornment: PropType<VNodeChildOrSlot>;
+  endAdornment: PropType<VNodeChildOrSlot>;
+  tabindex: {
+    type: (StringConstructor | NumberConstructor)[];
+    default: number;
+  };
+  nodeControl: PropType<FormNodeControl>;
+  label: PropType<VNodeChildOrSlot>;
+  hint: PropType<VNodeChildOrSlot>;
+  hinttip: PropType<FormNodeWrapperHinttip>;
+  hinttipDelay: PropType<FormNodeWrapperHinttipDelay>;
+  infoAppends: PropType<VNodeChildOrSlot>;
+  hiddenInfo: BooleanConstructor;
+  requiredChip: PropType<RequiredChipSource>;
+  collectErrorMessages: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  minlength: (StringConstructor | NumberConstructor)[];
+  maxlength: (StringConstructor | NumberConstructor)[];
+  pattern: (StringConstructor | RegExpConstructor)[];
+  placeholder: StringConstructor;
+  autocapitalize: PropType<FormAutoCapitalize>;
+  finalizers: PropType<TextableFinalizerSpec>;
+  counter: PropType<boolean | string | number>;
+  counterValue: PropType<(value: string) => number>;
+  limit: BooleanConstructor;
+  autocomplete: {
+    type: PropType<FormAutoComplete | boolean>;
+    default: () => boolean | "off" | "on" | "name" | "honorific-prefix" | "given-name" | "additional-name" | "family-name" | "honorific-suffix" | "nickname" | "email" | "username" | "new-password" | "current-password" | "one-time-code" | "organization-title" | "organization" | "street-address" | "address-line1" | "address-line2" | "address-line3" | "address-level4" | "address-level3" | "address-level2" | "address-level1" | "country" | "country-name" | "postal-code" | "cc-name" | "cc-given-name" | "cc-additional-name" | "cc-family-name" | "cc-number" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-csc" | "cc-type" | "transaction-currency" | "transaction-amount" | "language" | "bday" | "bday-day" | "bday-month" | "bday-year" | "sex" | "tel" | "tel-country-code" | "tel-national" | "tel-area-code" | "tel-local" | "tel-extension" | "impp" | "url" | "photo" | undefined;
+  };
+  name: StringConstructor;
+  tag: StringConstructor;
+  modelValue: vue2.Prop<any, any>;
+  autofocus: BooleanConstructor;
+  disabled: BooleanConstructor;
+  readonly: BooleanConstructor;
+  viewonly: BooleanConstructor;
+  spellcheck: BooleanConstructor;
+  required: BooleanConstructor | PropType<boolean>;
+  clearable: BooleanConstructor;
+  validateTiming: {
+    type: PropType<ValidateTiming>;
+    default: ValidateTiming;
+  };
+  rules: {
+    type: PropType<RecursiveVerifiableRuleOrFn>;
+    default: () => never[];
+  };
+  validationDeps: PropType<(nodeControl: FormNodeControl) => any>;
+  error: BooleanConstructor;
+  errorMessages: PropType<string | string[]>;
+  showOwnErrors: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+  detach: BooleanConstructor;
+}>> & Readonly<{
+  onFocus?: ((ev: FocusEvent) => any) | undefined;
+  onBlur?: ((ev: FocusEvent) => any) | undefined;
+  onChange?: ((value: string) => any) | undefined;
+  "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+  "onUpdate:errors"?: ((errors: FormNodeError[]) => any) | undefined;
+}>, {
+  error: boolean;
+  floatingToolbar: boolean;
+  disabledMinHeight: boolean;
+  disabledMaxHeight: boolean;
+  extensions: RawWysiwygExtension[];
+  tools: RawWysiwygEditorTool[];
+  removeDefaultWrapper: boolean;
+  loading: boolean;
+  tabindex: string | number;
+  hiddenInfo: boolean;
+  collectErrorMessages: boolean;
+  limit: boolean;
+  autocomplete: boolean | "name" | "off" | "on" | "honorific-prefix" | "given-name" | "additional-name" | "family-name" | "honorific-suffix" | "nickname" | "email" | "username" | "new-password" | "current-password" | "one-time-code" | "organization-title" | "organization" | "street-address" | "address-line1" | "address-line2" | "address-line3" | "address-level4" | "address-level3" | "address-level2" | "address-level1" | "country" | "country-name" | "postal-code" | "cc-name" | "cc-given-name" | "cc-additional-name" | "cc-family-name" | "cc-number" | "cc-exp" | "cc-exp-month" | "cc-exp-year" | "cc-csc" | "cc-type" | "transaction-currency" | "transaction-amount" | "language" | "bday" | "bday-day" | "bday-month" | "bday-year" | "sex" | "tel" | "tel-country-code" | "tel-national" | "tel-area-code" | "tel-local" | "tel-extension" | "impp" | "url" | "photo";
+  autofocus: boolean;
+  disabled: boolean;
+  readonly: boolean;
+  viewonly: boolean;
+  spellcheck: boolean;
+  clearable: boolean;
+  validateTiming: ValidateTiming;
+  rules: RecursiveVerifiableRuleOrFn;
+  showOwnErrors: boolean;
+  detach: boolean;
+}, DefinedSlots<{
+  [x: `error:${string}`]: (error: FormNodeError) => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[];
+  label?: ((wrapper: FormNodeWrapper) => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+  hint?: ((wrapper: FormNodeWrapper) => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+  infoAppends?: ((wrapper: FormNodeWrapper) => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+  error?: ((error: FormNodeError) => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+} & {
+  default?: (() => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+  startAdornment?: (() => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+  endAdornment?: (() => vue2.VNode<vue2.RendererNode, vue2.RendererElement, {
+    [key: string]: any;
+  }>[]) | undefined;
+}>, {}, {}, string, vue2.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { CreateWysiwygColorToolOptions, CreatedWysiwygExtension, RawWysiwygEditorTool, RawWysiwygExtension, ResolvedWysiwygEditorSettings, VUI_WYSIWYG_EDITOR_SYMBOL, VWysiwygEditor, VWysiwygEditorAPI, WYSIWYG_TEXT_ALIGN_VALUES, WysiwygBulletListTool, WysiwygColorExtension, WysiwygColorItem, WysiwygColorOptions, WysiwygCustomTagExtension, WysiwygCustomTagSettings, WysiwygCustomTagToolSettings, WysiwygEditorContext, WysiwygEditorEvent, WysiwygEditorEventsBucket, WysiwygEditorEventsOptions, WysiwygEditorInitializeContext, WysiwygEditorPrefixedEvent, WysiwygEditorTool, WysiwygEditorToolFactory, WysiwygEditorToolIcon, WysiwygExtensionFactory, WysiwygExtensionSource, WysiwygFormatBoldTool, WysiwygFormatItalicTool, WysiwygFormatUnderlineTool, WysiwygHistoryTool, WysiwygLinkTool, WysiwygLinter, WysiwygLinterBadWords, WysiwygLinterHeadingLevel, type WysiwygLinterOptions, WysiwygLinterPlugin, WysiwygLinterPunctuation, WysiwygOrderedListTool, WysiwygTextAlignOptions, WysiwygTextAlignTool, WysiwygTextAlignValue, createWysiwygColorTool, createWysiwygCustomTagMark, createWysiwygCustomTagTool, createWysiwygExtension, resolveRawWysiwygEditorTools, resolveRawWysiwygExtensions };
+//# sourceMappingURL=vui-wysiwyg.d.mts.map