import { AppendFlags, FactoryOpts, InputMask, InputMask as IMaskInstance, Masked, MaskedDynamic, MaskedDynamicOptions, MaskedEnum, MaskedFunction, MaskedRange, MaskedRegExp, PIPE_TYPE } from "imask";
import { Mixin, RecursiveArray } from "@fastkit/helpers";
import { App, ComponentInternalInstance, ComputedRef, DirectiveBinding, ExtractPropTypes, InjectionKey, InputHTMLAttributes, ObjectDirective, Prop, PropType, Ref, SetupContext, Slot, TextareaHTMLAttributes, VNode, VNodeArrayChildren, VNodeChild, WritableComputedRef } from "vue";
import { Rule, ValidationError, VerifiableRule, VerifiableRuleOrFn } from "@fastkit/rules";
import { DefineSlotsType, TypedSlot, VNodeChildOrSlot } from "@fastkit/vue-utils";
export * from "imask";
//#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
declare const TEXT_INPUT_TYPES: readonly ["color", "date", "datetime-local", "email", "month", "number", "password", "search", "tel", "text", "time", "url"];
type TextInputType = (typeof TEXT_INPUT_TYPES)[number];
declare const TEXT_INPUT_MODES: readonly ["decimal", "email", "none", "numeric", "search", "tel", "text", "url"];
type TextInputMode = (typeof TEXT_INPUT_MODES)[number];
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
type IMaskEventType = 'accept' | 'complete';
type AnyMaskedOptions = FactoryOpts;
type IMaskEvent = CustomEvent<InputMask>;
declare function createIMaskEvent(type: IMaskEventType, eventInitDict?: CustomEventInit<InputMask>): IMaskEvent;
type IMaskTypedValue = string | number | Date;
type IMaskRawInput = RegExp | Function | string;
type DynamicMaskedMeta = {
  /** Metadata assigned to dynamic mask options. */
  meta?: any;
};
type AnyMaskedOptionsWithMeta = AnyMaskedOptions & DynamicMaskedMeta;
type AnyMaskedWithMeta = Masked & DynamicMaskedMeta;
type MaskedDynamicWithMeta = Omit<MaskedDynamic, 'currentMask' | 'compiledMasks'> & {
  currentMask?: AnyMaskedWithMeta;
  compiledMasks: AnyMaskedWithMeta[];
};
type MaskedDynamicOptionsWithMeta = Omit<MaskedDynamicOptions, 'mask' | 'dispatch'> & {
  mask: AnyMaskedOptionsWithMeta[];
  dispatch?: (value: string, masked: MaskedDynamicWithMeta, flags: AppendFlags) => Masked;
};
type IMaskInput = Exclude<AnyMaskedOptions, MaskedDynamicOptions> | IMaskRawInput | Masked<any> | MaskedFunction | MaskedRegExp | MaskedEnum | MaskedRange | MaskedDynamicOptionsWithMeta | false | null | undefined | void;
declare function resolveIMaskInput(source?: IMaskInput): AnyMaskedOptions | undefined;
//#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: import("vue").Prop<unknown, unknown>;
  tabindex: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  autofocus: BooleanConstructor;
  disabled: BooleanConstructor;
  readonly: BooleanConstructor;
  viewonly: BooleanConstructor;
  spellcheck: BooleanConstructor;
  required: BooleanConstructor | import("vue").PropType<boolean>;
  clearable: BooleanConstructor;
  validateTiming: {
    type: import("vue").PropType<ValidateTiming>;
    default: ValidateTiming;
  };
  rules: {
    type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
    default: () => never[];
  };
  validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
  error: BooleanConstructor;
  errorMessages: import("vue").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;
};
declare function createFormGroupSettings(): {
  props: {
    /**
     * 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: import("vue").Prop<unknown, unknown>;
    tabindex: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    autofocus: BooleanConstructor;
    disabled: BooleanConstructor;
    readonly: BooleanConstructor;
    viewonly: BooleanConstructor;
    spellcheck: BooleanConstructor;
    required: BooleanConstructor | import("vue").PropType<boolean>;
    clearable: BooleanConstructor;
    validateTiming: {
      type: import("vue").PropType<ValidateTiming>;
      default: ValidateTiming;
    };
    rules: {
      type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
      default: () => never[];
    };
    validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
    error: BooleanConstructor;
    errorMessages: import("vue").PropType<string | string[]>;
    showOwnErrors: {
      type: BooleanConstructor;
      default: undefined;
    };
    detach: BooleanConstructor;
  };
  emits: {
    '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>;
}
declare function useFormGroup(props: FormGroupProps, ctx: FormGroupContext, options?: FormGroupOptions): FormGroupControl;
//#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 FormFunctionableAction = FormActionHandler;
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: import("vue").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;
};
type FormEmits = ReturnType<typeof createFormEmits>;
declare function createFormSettings(options?: FormOptions): {
  props: {
    /**
     * 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: import("vue").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;
  };
  emits: {
    /**
     * 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;
}
declare function useForm(props: FormProps, ctx: FormContext, options?: FormOptions): VueForm;
//#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;
type FormNodeWrapperSlots = DefineSlotsType<{
  /** label */
  label?: (wrapper: FormNodeWrapper) => any;
  /** hint message */
  hint?: (wrapper: FormNodeWrapper) => any;
  /** Elements to be added to the information message */
  infoAppends?: (wrapper: FormNodeWrapper) => any;
} & FormNodeErrorSlots>;
declare function createFormNodeWrapperProps(): {
  /**
   * 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>>;
declare function createFormNodeWrapperEmits(): {
  clickLabel: (ev: PointerEvent, wrapper: FormNodeWrapper) => boolean;
};
type FormNodeWrapperEmitOptions = ReturnType<typeof createFormNodeWrapperEmits>;
declare function createFormNodeWrapperSettings(): {
  props: {
    /**
     * 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;
    };
  };
  emits: {
    clickLabel: (ev: PointerEvent, wrapper: FormNodeWrapper) => boolean;
  };
};
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(): import("vue").VNodeArrayChildren | undefined;
  renderHint(allowNotFocused?: boolean): import("vue").VNodeArrayChildren | undefined;
  renderInfoAppends(): import("vue").VNodeArrayChildren | undefined;
  protected _getContextOrDie(): {
    attrs: import("vue").Attrs;
    slots: Readonly<{
      [name: string]: import("vue").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): import("vue").VNodeArrayChildren | undefined;
  renderMessage(allowNotFocused?: boolean): import("vue").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>;
}
declare function useFormNodeWrapper(props: FormNodeWrapperProps, ctx: FormNodeWrapperContext, options?: FormNodeWrapperOptions): FormNodeWrapper;
//#endregion
//#region src/composables/node.d.ts
type RecursiveVerifiableRuleOrFn = RecursiveArray<VerifiableRuleOrFn>;
type RecursiveVerifiableRuleOrFnArray = Exclude<RecursiveVerifiableRuleOrFn, VerifiableRuleOrFn>;
/**
 * Merge two specified recursive rule specifications into a single array and return it.
 *
 * @param baseRules - Base rules
 * @param mergeRules - Merge rules
 * @returns Array of merged rules
 */
declare function mergeFormNodeRules(baseRules: RecursiveVerifiableRuleOrFn | undefined, mergeRules: RecursiveVerifiableRuleOrFn | undefined): RecursiveVerifiableRuleOrFnArray;
type FormNodeType = string | number | symbol;
interface FormNodeError extends Omit<ValidationError, '$$symbol'> {}
type FormNodeErrors = FormNodeError[];
declare function toFormNodeError(source: string | ValidationError | FormNodeError): FormNodeError;
/**
 * 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; };
type FormNodeErrorSlots = DefineSlotsType<FormNodeErrorSlotsSource>;
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 function createFormNodeEmits<T, D = T>(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;
};
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']> {}
declare function createFormNodeSettings<T, D = T>(options: FormNodeControlOptions<T, D>): {
  options: FormNodeControlOptions<T, D, BooleanConstructor>;
  props: {
    /**
     * 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 | PropType<boolean>;
    /** 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;
  };
  emits: {
    /**
     * 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;
  };
};
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: import("vue").Attrs;
    slots: Readonly<{
      [name: string]: import("vue").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>;
}
declare function useParentFormNode(): FormNodeControl<any, any, BooleanConstructor> | null;
declare function useFormNodeControl<T = any, D = T>(props: FormNodeProps, ctx: FormNodeContext<T, D>, opts: FormNodeControlOptions<T, D>): FormNodeControl<T, D, BooleanConstructor>;
//#endregion
//#region src/composables/selector-item-group.d.ts
declare function createFormSelectorItemGroupProps(): {
  /** disabled state */
  disabled: BooleanConstructor;
  /** Group ID */
  groupId: {
    type: (StringConstructor | NumberConstructor)[];
    required: true;
  };
};
type FormSelectorItemGroupProps = ExtractPropTypes<ReturnType<typeof createFormSelectorItemGroupProps>>;
type FormSelectorItemGroupContext = SetupContext;
interface FormSelectorItemGroupControlOptions extends FormNodeControlBaseOptions {
  parentNodeType?: FormNodeType;
}
/**
 * Selection group node
 */
declare class FormSelectorItemGroupControl {
  readonly _props: FormSelectorItemGroupProps;
  readonly parentNodeType?: FormNodeType;
  protected _parentSelector: FormSelectorControl | null;
  readonly groupId: string | number;
  protected _notSelected: ComputedRef<boolean>;
  protected _allSelected: ComputedRef<boolean>;
  protected _indeterminate: ComputedRef<boolean>;
  /**
   * Selector node
   *
   * @see {@link FormSelectorControl}
   */
  get parentSelector(): FormSelectorControl;
  /**
   * Disabled state
   */
  get isDisabled(): boolean;
  /**
   * No items in this group are selected
   */
  get isNotSelected(): boolean;
  /**
   * All items in this group are selected
   */
  get isAllSelected(): boolean;
  /**
   * One or more items in this group are selected, but not all of them
   */
  get isIndeterminate(): boolean;
  /**
   * The parent selector is in multiple selection mode
   */
  get multiple(): boolean;
  constructor(props: FormSelectorItemGroupProps, ctx: FormSelectorItemGroupContext, options?: FormSelectorItemGroupControlOptions);
  /**
   * Toggle the selection state of this group
   *
   * - If there is at least one unselected item, select all.
   * - If all are selected, deselect all.
   */
  toggle(): void;
  /**
   * Select all items in this group
   */
  selectAll(): void;
  /**
   * Deselect all items in this group
   */
  unselectAll(): void;
}
declare function useParentFormSelectorItemGroup(parentSelector: FormSelectorControl): FormSelectorItemGroupControl | null;
declare function useFormSelectorItemGroupControl(props: FormSelectorItemGroupProps, ctx: FormSelectorItemGroupContext, options?: FormSelectorItemGroupControlOptions): FormSelectorItemGroupControl;
//#endregion
//#region src/composables/selector-item.d.ts
declare function createFormSelectorItemProps(): {
  /** selection value */
  value: {
    type: (StringConstructor | NumberConstructor)[];
  };
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<boolean, boolean>;
  tabindex: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  autofocus: BooleanConstructor;
  disabled: BooleanConstructor;
  readonly: BooleanConstructor;
  viewonly: BooleanConstructor;
  spellcheck: BooleanConstructor;
  required: BooleanConstructor | import("vue").PropType<boolean>;
  clearable: BooleanConstructor;
  validateTiming: {
    type: import("vue").PropType<ValidateTiming>;
    default: ValidateTiming;
  };
  rules: {
    type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
    default: () => never[];
  };
  validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
  error: BooleanConstructor;
  errorMessages: import("vue").PropType<string | string[]>;
  showOwnErrors: {
    type: BooleanConstructor;
    default: undefined;
  };
  detach: BooleanConstructor;
};
type FormSelectorItemProps = ExtractPropTypes<ReturnType<typeof createFormSelectorItemProps>>;
declare function createFormSelectorItemEmits(): {
  'update:modelValue': (value: boolean) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: boolean) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createFormSelectorItemSettings(): {
  props: {
    /** selection value */
    value: {
      type: (StringConstructor | NumberConstructor)[];
    };
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<boolean, boolean>;
    tabindex: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    autofocus: BooleanConstructor;
    disabled: BooleanConstructor;
    readonly: BooleanConstructor;
    viewonly: BooleanConstructor;
    spellcheck: BooleanConstructor;
    required: BooleanConstructor | import("vue").PropType<boolean>;
    clearable: BooleanConstructor;
    validateTiming: {
      type: import("vue").PropType<ValidateTiming>;
      default: ValidateTiming;
    };
    rules: {
      type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
      default: () => never[];
    };
    validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
    error: BooleanConstructor;
    errorMessages: import("vue").PropType<string | string[]>;
    showOwnErrors: {
      type: BooleanConstructor;
      default: undefined;
    };
    detach: BooleanConstructor;
  };
  emits: {
    'update:modelValue': (value: boolean) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: boolean) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
type FormSelectorItemInputType = 'checkbox' | 'radio';
interface FormSelectorItemEmitOptions extends ReturnType<typeof createFormSelectorItemEmits> {}
type FormSelectorItemContext = SetupContext<FormSelectorItemEmitOptions>;
interface FormSelectorItemControlOptions extends FormNodeControlBaseOptions {
  parentNodeType?: FormNodeType;
}
declare class FormSelectorItemControl extends FormNodeControl<boolean> {
  readonly _props: FormSelectorItemProps;
  readonly parentNodeType?: FormNodeType;
  protected _parentSelector: FormSelectorControl | null;
  protected _groupControl: FormSelectorItemGroupControl | null;
  readonly propValue?: string | number;
  protected _multiple: ComputedRef<boolean>;
  protected _hasValue: ComputedRef<boolean>;
  protected _defaultSlot: ComputedRef<Slot>;
  /**
   * Selector node
   *
   * @see {@link FormSelectorControl}
   */
  get parentSelector(): FormSelectorControl | null;
  /**
   * The parent selector is currently executing the selection guard process for this item
   */
  get isGuardInProgress(): boolean;
  /**
   * Selection group node
   *
   * @see {@link FormSelectorItemGroupControl}
   */
  get groupControl(): FormSelectorItemGroupControl | null;
  /**
   * Selection group ID
   */
  get groupId(): string | number | null;
  /**
   * Selection state
   */
  get selected(): boolean;
  set selected(selected: boolean);
  /**
   * The parent selector is in multiple selection mode
   */
  get multiple(): boolean;
  /**
   * Input type
   *
   * @see {@link FormSelectorItemInputType}
   */
  get inputType(): FormSelectorItemInputType;
  /** Has a value */
  get hasValue(): boolean;
  renderDefaultSlot(): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>[];
  constructor(props: FormSelectorItemProps, ctx: FormSelectorItemContext, options?: FormSelectorItemControlOptions);
  emptyValue(): boolean;
  protected _valueChangeHandler(value: boolean): void;
  /** Select */
  select(): void;
  /** Deselect */
  unselect(): void;
  /** Toggle selection state */
  toggle(): void;
  /** @internal */
  _setValueSilent(value: boolean): void;
  createInputElement(override?: Pick<InputHTMLAttributes, 'id' | 'class'> & {
    type?: FormSelectorItemInputType;
  }): import("vue/jsx-runtime").JSX.Element;
  handleChange(ev: Event): void;
  handleClickInputElement(ev: PointerEvent): void;
  handleClickElement(ev: PointerEvent): void;
  /**
   * @override
   */
  focusHandler(ev: FocusEvent): void;
  /**
   * @override
   */
  blurHandler(ev: FocusEvent): void;
}
declare function useFormSelectorItemControl(props: FormSelectorItemProps, ctx: FormSelectorItemContext, options?: FormSelectorItemControlOptions): FormSelectorItemControl;
//#endregion
//#region src/composables/selector.d.ts
declare const DEFAULT_FORM_SELECTOR_GROUP_ID = "__default__";
interface FormSelectorItem {
  /** selection value */
  value: string | number;
  /** label */
  label: VNodeChildOrSlot<FormSelectorControl>;
  /** disabled state */
  disabled?: boolean;
}
interface FormSelectorGroup {
  /** Group ID */
  id: string | number;
  /** label */
  label: VNodeChildOrSlot<FormSelectorControl>;
  /** disabled state */
  disabled?: boolean;
  /** List of choices */
  items: FormSelectorItem[];
}
interface ResolvedFormSelectorItem extends Omit<FormSelectorItem, 'label'> {
  label: TypedSlot<FormSelectorControl>;
}
interface ResolvedFormSelectorGroup extends Omit<FormSelectorGroup, 'label'> {
  label: TypedSlot<FormSelectorControl>;
  items: ResolvedFormSelectorItem[];
}
type FormSelectorValue = undefined | string | number | (string | number)[];
type FormSelectorItemOrGroups = (FormSelectorItem | FormSelectorGroup)[];
type RawFormSelectorItems = FormSelectorItemOrGroups | ((selectorControl: FormSelectorControl) => Promise<FormSelectorItemOrGroups>);
/** Guard function context */
interface FormSelectorGuardContext {
  /** @see {@link FormSelectorItemControl} */
  item: FormSelectorItemControl;
  /** @see {@link FormSelectorControl} */
  selector: FormSelectorControl;
  /** Choice click event */
  event: PointerEvent;
  /** Accept changes */
  accept: () => void;
}
/**
 * Handler to guard changes in selection state
 *
 * @param ctx - Guard function context
 *
 * @see {@link FormSelectorGuardContext}
 */
type FormSelectorGuard = (ctx: FormSelectorGuardContext) => boolean | void | Promise<boolean | void>;
declare function createFormSelectorProps(options?: FormSelectorControlOptions): {
  /**
   * Multiple selection mode
   */
  multiple: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * List of selection items, group list, or asynchronous loader
   *
   * @see {@link RawFormSelectorItems}
   */
  items: {
    type: PropType<RawFormSelectorItems>;
    default: () => never[];
  };
  /**
   * When true, maintains items order. When false (default), maintains user selection order.
   */
  preserveOrder: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Handler before a clickable option is clicked and the selection state is changed.
   *
   * - If `false` is returned, the operation will be canceled.
   * - When passing an asynchronous process, all options will remain inactive until the process is completed.
   *
   * @see {@link FormSelectorGuard}
   */
  onClickItem: PropType<FormSelectorGuard>;
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<FormSelectorValue, FormSelectorValue>;
  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 FormSelectorProps = ExtractPropTypes<ReturnType<typeof createFormSelectorProps>>;
declare function createFormSelectorEmits(): {
  'update:modelValue': (value: FormSelectorValue) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: FormSelectorValue) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createFormSelectorSettings(options?: FormSelectorControlOptions): {
  props: {
    /**
     * Multiple selection mode
     */
    multiple: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * List of selection items, group list, or asynchronous loader
     *
     * @see {@link RawFormSelectorItems}
     */
    items: {
      type: PropType<RawFormSelectorItems>;
      default: () => never[];
    };
    /**
     * When true, maintains items order. When false (default), maintains user selection order.
     */
    preserveOrder: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Handler before a clickable option is clicked and the selection state is changed.
     *
     * - If `false` is returned, the operation will be canceled.
     * - When passing an asynchronous process, all options will remain inactive until the process is completed.
     *
     * @see {@link FormSelectorGuard}
     */
    onClickItem: PropType<FormSelectorGuard>;
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<FormSelectorValue, FormSelectorValue>;
    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;
  };
  emits: {
    'update:modelValue': (value: FormSelectorValue) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: FormSelectorValue) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface FormSelectorEmitOptions extends ReturnType<typeof createFormSelectorEmits> {}
type FormSelectorContext = SetupContext<FormSelectorEmitOptions>;
interface FormSelectorControlOptions extends FormNodeControlBaseOptions {
  defaultMultiple?: boolean;
  defaultPreserveOrder?: boolean;
  onSelectItem?: (item: FormSelectorItemControl, ev: PointerEvent) => any;
  onCancelSelect?: (item: FormSelectorItemControl, ev: PointerEvent) => any;
}
type FormSelectorLoadState = 'ready' | 'loading' | 'error';
declare class FormSelectorControl extends FormNodeControl<FormSelectorValue> {
  readonly _props: FormSelectorProps;
  readonly parentNodeType?: FormNodeType;
  /**
   * When true, maintains items order. When false (default), maintains user selection order.
   */
  readonly preserveOrder: boolean;
  protected _items: Ref<FormSelectorItemControl[]>;
  protected _itemsLoadState: Ref<FormSelectorLoadState, FormSelectorLoadState>;
  protected _propGroups: Ref<ResolvedFormSelectorGroup[]>;
  protected _loadedItems: ComputedRef<ResolvedFormSelectorItem[]>;
  protected _selectedPropItems: ComputedRef<ResolvedFormSelectorItem[]>;
  protected _selectedValues: ComputedRef<(string | number)[]>;
  protected _selectedItems: ComputedRef<FormSelectorItemControl[]>;
  protected _guardingItem: Ref<(() => FormSelectorItemControl) | undefined>;
  protected onSelectItem?: (item: FormSelectorItemControl, ev: PointerEvent) => any;
  protected onCancelSelect?: (item: FormSelectorItemControl, ev: PointerEvent) => any;
  /**
   * List of selection item nodes
   *
   * @see {@link FormSelectorItemControl}
   */
  get items(): FormSelectorItemControl[];
  /**
   * Item currently undergoing selection guard process
   *
   * @see {@link FormSelectorItemControl}
   */
  get guardingItem(): FormSelectorItemControl | undefined;
  /**
   * In the process of selection guard
   */
  get isGuardInProgress(): boolean;
  /**
   * Not selected any
   */
  get notSelected(): boolean;
  /**
   * Selected all items, including those in a disabled state
   */
  get allSelected(): boolean;
  /**
   * One or more items, including those in a disabled state, are selected, but not all of them
   */
  get indeterminate(): boolean;
  /**
   * List of selection groups resolved from properties
   *
   * @see {@link ResolvedFormSelectorGroup}
   */
  get propGroups(): ResolvedFormSelectorGroup[];
  /**
   * List of loaded items
   *
   * @see {@link ResolvedFormSelectorItem}
   */
  get loadedItems(): ResolvedFormSelectorItem[];
  /**
   * List of selected property-specified items
   *
   * @see {@link ResolvedFormSelectorItem}
   */
  get selectedPropItems(): ResolvedFormSelectorItem[];
  /**
   * List of selected values
   */
  get selectedValues(): (string | number)[];
  /**
   * List of selected item nodes
   */
  get selectedItems(): FormSelectorItemControl[];
  /**
   * Loading state of selection items
   *
   * @see {@link FormSelectorLoadState}
   */
  get itemsLoadState(): FormSelectorLoadState;
  /**
   * Loading items
   */
  get itemsLoading(): boolean;
  /**
   * Items loaded
   */
  get itemsReady(): boolean;
  /**
   * Failed to load items
   */
  get itemsLoadFailed(): boolean;
  get isDisabled(): boolean;
  constructor(props: FormSelectorProps, ctx: FormSelectorContext, options?: FormSelectorControlOptions);
  emptyValue(): never[] | undefined;
  private _setPropItems;
  /**
   * Render selected property-specified items
   *
   * @param options - Options
   */
  renderSelectedPropItems(options?: {
    /**
     * Fallback specification for loading.
     */
    loading?: () => VNodeChild;
    /**
     * Fallback specification when nothing is selected
     */
    empty?: () => VNodeChild;
    /**
     * Separator for items when multiple selections are allowed
     */
    separator?: VNodeChild | (() => VNodeChild);
    /**
     * Renderer for customizing item rendering
     * @param item - Item
     * @param index - Index
     */
    item?: (item: ResolvedFormSelectorItem, index: number) => VNodeChild;
  }): VNodeChild;
  /**
   * Load items
   */
  loadItems(): void;
  protected _reCalcValues(changedSelectorItem?: FormSelectorItemControl): void;
  safeModelValue(value: any): undefined | string | number | (string | number)[];
  protected _safeMultipleValues(_value?: FormSelectorValue): (string | number)[];
  protected _safeSingleValue(_value?: FormSelectorValue): string | number | undefined;
  protected _syncValueForChoices(exclude?: FormSelectorItemControl): void;
  /**
   * Get the list of mounted selection nodes
   *
   * @param groupId - Group ID (for filtering)
   * @param ignoreDisabled - Ignore disabled items
   *
   * @see {@link FormSelectorItemControl}
   */
  getItems(groupId?: string | number | (string | number)[], ignoreDisabled?: boolean): FormSelectorItemControl[];
  /**
   * Get the list of values of mounted selection nodes
   *
   * @param groupId - Group ID (for filtering)
   * @param ignoreDisabled - Ignore disabled items
   */
  getItemValues(groupId?: string | number | (string | number)[], ignoreDisabled?: boolean): (string | number)[];
  /**
   * Sort the list of values in the order of currently mounted items
   * @param values - List of values to be sorted
   * @returns Sorted list of values
   */
  sortValues(values: (string | number)[]): (string | number)[];
  /**
   * Select all items
   *
   * @param groupId - Group ID (for filtering)
   * @param deselectOtherGroups - Deselect items other than those in the specified group
   */
  selectAll(groupId?: string | number | (string | number)[], deselectOtherGroups?: boolean): void;
  /**
   * Deselect items
   *
   * @param groupId - Group ID (for filtering)
   */
  unselectAll(groupId?: string | number | (string | number)[]): void;
  /**
   * Check if it is not selected
   *
   * @param groupId - Group ID (for filtering)
   */
  isNotSelected(groupId?: string | number | (string | number)[]): boolean;
  /**
   * Check if all are selected
   *
   * @param groupId - Group ID (for filtering)
   */
  isAllSelected(groupId?: string | number | (string | number)[]): boolean;
  /**
   * Check if the selection is in a partial state
   *
   * @param groupId - Group ID (for filtering)
   */
  isIndeterminate(groupId?: string | number | (string | number)[]): boolean;
  /**
   * Toggle the selection state
   *
   * - If there is at least one unselected item, select all.
   * - If all are selected, deselect all.
   *
   * @param groupId - Group ID (for filtering)
   *
   */
  toggle(groupId?: string | number | (string | number)[]): void;
  handleSelectItem(item: FormSelectorItemControl, ev: PointerEvent): void;
  clearGuard(): void;
  handleClickItem(item: FormSelectorItemControl, ev: PointerEvent): void;
  /**
   * Check if the specified value is selected
   *
   * @param value - Value to check
   */
  isSelected(value: string | number): boolean;
  /** @private */
  _joinFromSelectorItem(item: FormSelectorItemControl): void;
  /** @private */
  _leaveFromSelectorItem(item: FormSelectorItemControl): void;
  /** @private */
  _itemValueChangeHandler(changedSelectorItem: FormSelectorItemControl): void;
}
declare function useParentFormSelector(): FormSelectorControl | null;
declare function useFormSelectorControl(props: FormSelectorProps, ctx: FormSelectorContext, options?: FormSelectorControlOptions): FormSelectorControl;
//#endregion
//#region src/injections.d.ts
declare const FormNodeInjectionKey: InjectionKey<FormNodeControl | null>;
declare const FormSelectorInjectionKey: InjectionKey<FormSelectorControl | null>;
declare const FormSelectorItemGroupInjectionKey: InjectionKey<FormSelectorItemGroupControl | null>;
declare const FormNodeWrapperInjectionKey: InjectionKey<FormNodeWrapper | null>;
declare function useParentFormNodeWrapper(): FormNodeWrapper | null;
declare const FormGroupInjectionKey: InjectionKey<FormGroupControl | null>;
declare function useParentFormGroup(): FormGroupControl | null;
declare const FormInjectionKey: InjectionKey<VueForm | null>;
declare function useParentForm(): VueForm | null;
declare const FormServiceInjectionKey: InjectionKey<VueFormService>;
declare function useVueForm(): VueFormService;
//#endregion
//#region src/composables/number.d.ts
declare function createNumberInputNodeProps(): {
  value: StringConstructor;
  /** minimum value */
  min: (StringConstructor | NumberConstructor)[];
  /** greatest value */
  max: (StringConstructor | NumberConstructor)[];
  /** Input Value Steps */
  step: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  /** placeholder */
  placeholder: StringConstructor;
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<number, number>;
  tabindex: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  autofocus: BooleanConstructor;
  disabled: BooleanConstructor;
  readonly: BooleanConstructor;
  viewonly: BooleanConstructor;
  spellcheck: BooleanConstructor;
  required: BooleanConstructor | import("vue").PropType<boolean>;
  clearable: BooleanConstructor;
  validateTiming: {
    type: import("vue").PropType<ValidateTiming>;
    default: ValidateTiming;
  };
  rules: {
    type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
    default: () => never[];
  };
  validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
  error: BooleanConstructor;
  errorMessages: import("vue").PropType<string | string[]>;
  showOwnErrors: {
    type: BooleanConstructor;
    default: undefined;
  };
  detach: BooleanConstructor;
};
type NumberInputNodeProps = ExtractPropTypes<ReturnType<typeof createNumberInputNodeProps>>;
declare function createNumberInputNodeEmits(): {
  'update:modelValue': (value: number) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: number) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createNumberInputNodeSettings(): {
  props: {
    value: StringConstructor;
    /** minimum value */
    min: (StringConstructor | NumberConstructor)[];
    /** greatest value */
    max: (StringConstructor | NumberConstructor)[];
    /** Input Value Steps */
    step: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    /** placeholder */
    placeholder: StringConstructor;
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<number, number>;
    tabindex: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    autofocus: BooleanConstructor;
    disabled: BooleanConstructor;
    readonly: BooleanConstructor;
    viewonly: BooleanConstructor;
    spellcheck: BooleanConstructor;
    required: BooleanConstructor | import("vue").PropType<boolean>;
    clearable: BooleanConstructor;
    validateTiming: {
      type: import("vue").PropType<ValidateTiming>;
      default: ValidateTiming;
    };
    rules: {
      type: import("vue").PropType<RecursiveVerifiableRuleOrFn>;
      default: () => never[];
    };
    validationDeps: import("vue").PropType<(nodeControl: FormNodeControl) => any>;
    error: BooleanConstructor;
    errorMessages: import("vue").PropType<string | string[]>;
    showOwnErrors: {
      type: BooleanConstructor;
      default: undefined;
    };
    detach: BooleanConstructor;
  };
  emits: {
    'update:modelValue': (value: number) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: number) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface NumberInputNodeEmitOptions extends ReturnType<typeof createNumberInputNodeEmits> {}
type NumberInputNodeContext = SetupContext<NumberInputNodeEmitOptions>;
interface NumberInputNodeControlOptions extends FormNodeControlBaseOptions {}
declare class NumberInputNodeControl extends FormNodeControl<number, undefined> {
  readonly _props: NumberInputNodeProps;
  protected _min: ComputedRef<number | undefined>;
  protected _max: ComputedRef<number | undefined>;
  protected _step: ComputedRef<number>;
  get min(): number | undefined;
  get max(): number | undefined;
  get step(): number;
  get placeholder(): string | undefined;
  constructor(props: NumberInputNodeProps, ctx: NumberInputNodeContext, options?: NumberInputNodeControlOptions);
  emptyValue(): undefined;
  protected _resolveRules(): import("@fastkit/rules").VerifiableRule[];
}
declare function useNumberInputNodeControl(props: NumberInputNodeProps, ctx: NumberInputNodeContext, options?: NumberInputNodeControlOptions): NumberInputNodeControl;
//#endregion
//#region src/composables/autocompletable.d.ts
declare function createAutocompletableInputProps(): {
  /**
   * The HTML autocomplete attribute lets web developers specify what if any permission the [user agent](https://developer.mozilla.org/docs/Glossary/User_agent) has to provide automated assistance in filling out form field values, as well as guidance to the browser as to the type of information expected in the field.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Attributes/autocomplete
   */
  autocomplete: {
    type: PropType<FormAutoComplete | boolean>;
    default: () => 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" | undefined;
  };
};
type AutocompletableInputProps = ExtractPropTypes<ReturnType<typeof createAutocompletableInputProps>>;
declare function createAutocompletableInputControl(props: AutocompletableInputProps): {
  computedAutocomplete: import("vue").ComputedRef<"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">;
};
type AutocompletableInputControl = ReturnType<typeof createAutocompletableInputControl>;
//#endregion
//#region src/composables/textable.d.ts
type TextableFinalizerSpec = TextFinalizer | BuiltinTextFinalizerName | (TextFinalizer | BuiltinTextFinalizerName)[];
declare function createTextableProps(): {
  /** Minimum number of characters */
  minlength: (StringConstructor | NumberConstructor)[];
  /** maximum number of characters */
  maxlength: (StringConstructor | NumberConstructor)[];
  /** input pattern */
  pattern: (StringConstructor | RegExpConstructor)[];
  /** placeholder */
  placeholder: StringConstructor;
  /**
   * Perform capitalization of the input string's first letter when it is entered/edited by the user.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/autocapitalize
   */
  autocapitalize: PropType<FormAutoCapitalize>;
  /**
   * Text correction settings.
   */
  finalizers: PropType<TextableFinalizerSpec>;
  /**
   * Character counter.
   */
  counter: PropType<boolean | string | number>;
  /**
   * Calculation logic for performing custom character count.
   */
  counterValue: PropType<(value: string) => number>;
  /** Limit the input value based on the maximum character count. */
  limit: BooleanConstructor;
  autocomplete: {
    type: PropType<FormAutoComplete | boolean>;
    default: () => 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" | undefined;
  };
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<any, any>;
  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;
};
interface TextableCounterSettings {
  maxlength: number;
  counterValue: (value: string) => number;
}
interface TextableCounterResult {
  length: number;
  maxlength: number;
}
type TextableProps = ExtractPropTypes<ReturnType<typeof createTextableProps>>;
declare function createTextableEmits(): {
  'update:modelValue': (value: string) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: string) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createTextableSettings(): {
  props: {
    /** Minimum number of characters */
    minlength: (StringConstructor | NumberConstructor)[];
    /** maximum number of characters */
    maxlength: (StringConstructor | NumberConstructor)[];
    /** input pattern */
    pattern: (StringConstructor | RegExpConstructor)[];
    /** placeholder */
    placeholder: StringConstructor;
    /**
     * Perform capitalization of the input string's first letter when it is entered/edited by the user.
     *
     * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/autocapitalize
     */
    autocapitalize: PropType<FormAutoCapitalize>;
    /**
     * Text correction settings.
     */
    finalizers: PropType<TextableFinalizerSpec>;
    /**
     * Character counter.
     */
    counter: PropType<boolean | string | number>;
    /**
     * Calculation logic for performing custom character count.
     */
    counterValue: PropType<(value: string) => number>;
    /** Limit the input value based on the maximum character count. */
    limit: BooleanConstructor;
    autocomplete: {
      type: PropType<FormAutoComplete | boolean>;
      default: () => 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" | undefined;
    };
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<any, any>;
    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;
  };
  emits: {
    'update:modelValue': (value: string) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: string) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface TextableEmitOptions extends ReturnType<typeof createTextableEmits> {}
type TextableContext = SetupContext<TextableEmitOptions>;
interface TextableControlOptions extends FormNodeControlBaseOptions {}
declare class TextableControl extends FormNodeControl<string> {
  readonly _props: TextableProps;
  protected _minlength: ComputedRef<number | undefined>;
  protected _maxlength: ComputedRef<number | undefined>;
  protected _autocompletable: AutocompletableInputControl;
  protected _finalizers: ComputedRef<TextFinalizer[] | undefined>;
  protected _counterSettings: ComputedRef<TextableCounterSettings | undefined>;
  protected _counterResult: ComputedRef<TextableCounterResult | undefined>;
  protected _maxlengthLimit: ComputedRef<number | undefined>;
  /** Minimum number of characters */
  get minlength(): number | undefined;
  /** maximum number of characters */
  get maxlength(): number | undefined;
  /** input pattern */
  get pattern(): string | RegExp | undefined;
  /** placeholder */
  get placeholder(): string | undefined;
  /**
   * The HTML autocomplete attribute lets web developers specify what if any permission the [user agent](https://developer.mozilla.org/docs/Glossary/User_agent) has to provide automated assistance in filling out form field values, as well as guidance to the browser as to the type of information expected in the field.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Attributes/autocomplete
   */
  get autocomplete(): FormAutoComplete | undefined;
  /**
   * Perform capitalization of the input string's first letter when it is entered/edited by the user.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/autocapitalize
   */
  get autocapitalize(): FormAutoCapitalize | undefined;
  /**
   * Text correction settings.
   *
   * @see {@link TextFinalizer}
   */
  get finalizers(): TextFinalizer[] | undefined;
  /**
   * Character count setting
   *
   * @see {@link TextableCounterSettings}
   */
  get counterSettings(): TextableCounterSettings | undefined;
  /**
   * Character count result
   *
   * @see {@link TextableCounterResult}
   */
  get counterResult(): TextableCounterResult | undefined;
  /**
   * The maximum number of characters derived from `maxlength` and `counterSettings`
   */
  get maxlengthLimit(): number | undefined;
  constructor(props: TextableProps, ctx: TextableContext, options?: TextableControlOptions);
  emptyValue(): string;
  /**
   * @override
   */
  blurHandler(ev: FocusEvent): void;
  protected _finalize(): Promise<void>;
  protected _resolveRules(): import("@fastkit/rules").VerifiableRule[];
  protected _setTextValue(value: string): void;
}
declare function useTextableControl(props: TextableProps, ctx: TextableContext, options?: TextableControlOptions): TextableControl;
//#endregion
//#region src/composables/imask.d.ts
declare function createMaskedOptions<Opts extends Omit<Exclude<AnyMaskedOptions, MaskedDynamicOptions>, 'dispatch'> | MaskedDynamicOptionsWithMeta>(options: Opts): Opts;
declare function createMaskControlProps(): {
  /** Text Mask Settings */
  mask: PropType<IMaskInput>;
};
type IMaskControlProps = ExtractPropTypes<ReturnType<typeof createMaskControlProps>>;
type IMaskPipeTypeMap = typeof PIPE_TYPE;
type IMaskPipeType = IMaskPipeTypeMap[keyof IMaskPipeTypeMap];
type IMaskPipeValue = string | number | null | undefined;
declare function useIMaskControl(props: IMaskControlProps, opts: {
  el: Ref<HTMLInputElement | null>;
  onAccept?: (ev: IMaskEvent) => void;
  onAcceptDynamicMeta?: (meta?: any) => void;
  onComplete?: (ev: IMaskEvent) => void;
}): {
  maskInput: import("vue").ComputedRef<import("imask").FactoryOpts | undefined>;
  inputMask: Ref<InputMask<Record<string, unknown>> | null, InputMask<Record<string, unknown>> | null>;
  staticMask: Ref<Masked<any> | null, Masked<any> | null>;
  masked: Ref<string, string>;
  unmasked: Ref<string, string>;
  typed: Ref<string | number | Date | undefined, string | number | Date | undefined>;
  pipe: (value: IMaskPipeValue, from?: IMaskPipeType) => string;
};
type IMaskControl = ReturnType<typeof useIMaskControl>;
//#endregion
//#region src/composables/textinput.d.ts
type TextInputMaskModel = 'masked' | 'typed' | 'unmasked';
type TextInputListItemValue = string | number;
interface TextInputListItem {
  value: TextInputListItemValue;
  label?: string;
}
type RawTextInputListItem = TextInputListItemValue | TextInputListItem;
type TextInputListSpec = string | RawTextInputListItem[];
interface TextInputListDetails {
  id: string;
  items?: TextInputListItem[];
}
declare function createTextInputNodeProps(): {
  /**
   * Input type
   *
   * @default "text"
   */
  type: {
    type: PropType<TextInputType>;
    default: string;
  };
  /**
   * Enumerated attribute that hints at the type of data that might be entered by the user while editing the element or its contents.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/inputmode
   */
  inputmode: PropType<TextInputMode>;
  /**
   * The synchronization method for utilizing the masked modelValue.
   *
   * Typically, when using the mask option, the masked and formatted value is sent along with the event. By enabling this setting, it becomes possible to synchronize unmasked values or resolved values of types.
   */
  maskModel: {
    type: PropType<TextInputMaskModel>;
    default: string;
  };
  /**
   * The ID of the datalist, or a list of its items.
   *
   * @see {@link https://developer.mozilla.org/docs/Web/HTML/Element/datalist}
   */
  list: PropType<TextInputListSpec>;
  mask: PropType<IMaskInput>;
  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 | "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" | undefined;
  };
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<any, any>;
  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 TextInputNodeProps = ExtractPropTypes<ReturnType<typeof createTextInputNodeProps>>;
declare function createTextInputNodeEmits(): {
  /**
   * 'accept' event fired on input when mask value has changed
   *
   * @see https://imask.js.org/guide.html
   */
  acceptMask: (ev: IMaskEvent) => boolean;
  /**
   * Metadata event when the applied mask is changed in dynamic mask settings.
   */
  acceptDynamicMaskMeta: (meta?: any) => boolean;
  /**
   * 'complete' event fired when the value is completely filled
   *
   * @see https://imask.js.org/guide.html
   */
  completeMask: (ev: IMaskEvent) => boolean;
  /**
   * Updating the masked value.
   *
   * @param maskedValue - Masked value
   */
  'update:masked': (maskedValue: string) => boolean;
  /**
   * Updating the normalized value with the specified type.
   *
   * @param typedValue - Normalized value with the specified type
   */
  'update:typed': (typedValue: IMaskTypedValue | undefined) => boolean;
  /**
   * Updating the unmasked value.
   *
   * @param unmaskedValue - unmasked value
   */
  'update:unmasked': (unmaskedValue: string) => boolean;
  'update:modelValue': (value: string) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: string) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
type TextInputNodeEmits = ReturnType<typeof createTextInputNodeEmits>;
declare function createTextInputNodeSettings(): {
  props: {
    /**
     * Input type
     *
     * @default "text"
     */
    type: {
      type: PropType<TextInputType>;
      default: string;
    };
    /**
     * Enumerated attribute that hints at the type of data that might be entered by the user while editing the element or its contents.
     *
     * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/inputmode
     */
    inputmode: PropType<TextInputMode>;
    /**
     * The synchronization method for utilizing the masked modelValue.
     *
     * Typically, when using the mask option, the masked and formatted value is sent along with the event. By enabling this setting, it becomes possible to synchronize unmasked values or resolved values of types.
     */
    maskModel: {
      type: PropType<TextInputMaskModel>;
      default: string;
    };
    /**
     * The ID of the datalist, or a list of its items.
     *
     * @see {@link https://developer.mozilla.org/docs/Web/HTML/Element/datalist}
     */
    list: PropType<TextInputListSpec>;
    mask: PropType<IMaskInput>;
    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 | "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" | undefined;
    };
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<any, any>;
    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;
  };
  emits: {
    /**
     * 'accept' event fired on input when mask value has changed
     *
     * @see https://imask.js.org/guide.html
     */
    acceptMask: (ev: IMaskEvent) => boolean;
    /**
     * Metadata event when the applied mask is changed in dynamic mask settings.
     */
    acceptDynamicMaskMeta: (meta?: any) => boolean;
    /**
     * 'complete' event fired when the value is completely filled
     *
     * @see https://imask.js.org/guide.html
     */
    completeMask: (ev: IMaskEvent) => boolean;
    /**
     * Updating the masked value.
     *
     * @param maskedValue - Masked value
     */
    'update:masked': (maskedValue: string) => boolean;
    /**
     * Updating the normalized value with the specified type.
     *
     * @param typedValue - Normalized value with the specified type
     */
    'update:typed': (typedValue: IMaskTypedValue | undefined) => boolean;
    /**
     * Updating the unmasked value.
     *
     * @param unmaskedValue - unmasked value
     */
    'update:unmasked': (unmaskedValue: string) => boolean;
    'update:modelValue': (value: string) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: string) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface TextInputNodeEmitOptions extends ReturnType<typeof createTextInputNodeEmits> {}
type TextInputNodeContext = SetupContext<TextInputNodeEmitOptions>;
interface TextInputNodeControlOptions extends TextableControlOptions {}
declare class TextInputNodeControl extends TextableControl {
  readonly _props: TextInputNodeProps;
  protected _inputElement: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
  protected readonly _getMaskInput: () => AnyMaskedOptions | undefined;
  protected readonly _getMask: () => IMaskInstance | null;
  readonly mask: IMaskControl;
  protected _passwordVisibility: import("vue").Ref<boolean, boolean>;
  protected _maskedValue: ComputedRef<string>;
  protected _list: ComputedRef<TextInputListDetails | undefined>;
  /**
   * Input type
   *
   * @see {@link TextInputType}
   */
  get type(): TextInputType;
  /**
   * Enumerated attribute that hints at the type of data that might be entered by the user while editing the element or its contents.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Global_attributes/inputmode
   */
  get inputmode(): TextInputMode | undefined;
  /**
   * `<input />` Element
   */
  get inputElement(): HTMLInputElement | null;
  /**
   * Show password
   */
  get isVisiblePassword(): boolean;
  /**
   * Masked text
   */
  get maskedValue(): string;
  /**
   * Use the unmasked value
   */
  get useUnmaskedValue(): boolean;
  /**
   * Use the type-corrected value
   */
  get useTypedValue(): boolean;
  /**
   * datalist
   *
   * @see {@link TextInputListDetails}
   */
  get datalist(): TextInputListDetails | undefined;
  constructor(props: TextInputNodeProps, ctx: TextInputNodeContext, options?: TextInputNodeControlOptions);
  emptyValue(): string;
  /**
   * Set the visibility state of the password
   *
   * @param visibility - Password visibility state
   */
  setPasswordVisibility(visibility: boolean): void;
  /**
   * Toggle the visibility state of the password
   */
  togglePasswordVisibility(): void;
  protected _handleNodeInput(ev: Event): void;
  createInputElement(override?: Pick<InputHTMLAttributes, 'class' | 'type'>): import("vue/jsx-runtime").JSX.Element;
  createDatalist(): import("vue/jsx-runtime").JSX.Element | undefined;
  focus(opts?: FocusOptions): void;
  blur(): void;
}
declare function useTextInputNodeControl(props: TextInputNodeProps, ctx: TextInputNodeContext, options?: TextInputNodeControlOptions): TextInputNodeControl;
//#endregion
//#region src/components/VTextareaAutosize/VTextareaAutosize.d.ts
interface VTextareaAutosizeRef {
  value: string;
  focus(opts?: FocusOptions): void;
  blur(): void;
}
declare const VTextareaAutosize: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  autocomplete: StringConstructor;
  autofocus: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  disabled: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  form: StringConstructor;
  maxlength: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  minlength: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  name: StringConstructor;
  placeholder: StringConstructor;
  readonly: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  required: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  modelValue: {
    type: StringConstructor;
    default: string;
  };
  minRows: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  maxRows: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
}>, {
  value: import("vue").WritableComputedRef<string, string>;
  handleInput: (event: InputEvent) => void;
  inputRef: () => import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
  shadowRef: () => import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
  state: {
    fallbackRows?: number | undefined;
    overflow?: boolean | undefined;
    outerHeightStyle?: number | undefined;
  };
  focus: (opts?: FocusOptions) => void;
  blur: () => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  input: (event: InputEvent) => true;
  'update:modelValue': (modelValue: string) => true;
  focus: (event: FocusEvent) => true;
  blur: (event: FocusEvent) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  autocomplete: StringConstructor;
  autofocus: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  disabled: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  form: StringConstructor;
  maxlength: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  minlength: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  name: StringConstructor;
  placeholder: StringConstructor;
  readonly: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  required: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Booleanish>;
    default: boolean;
  };
  modelValue: {
    type: StringConstructor;
    default: string;
  };
  minRows: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
  maxRows: {
    type: import("vue").PropType<import("@fastkit/vue-utils").Numberish>;
  };
}>> & Readonly<{
  onBlur?: ((event: FocusEvent) => any) | undefined;
  "onUpdate:modelValue"?: ((modelValue: string) => any) | undefined;
  onFocus?: ((event: FocusEvent) => any) | undefined;
  onInput?: ((event: InputEvent) => any) | undefined;
}>, {
  autofocus: import("@fastkit/vue-utils").Booleanish;
  disabled: import("@fastkit/vue-utils").Booleanish;
  readonly: import("@fastkit/vue-utils").Booleanish;
  required: import("@fastkit/vue-utils").Booleanish;
  modelValue: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//#endregion
//#region src/composables/textarea.d.ts
interface TextareaAutosizeSettings {
  minRows?: number;
  maxRows?: number;
}
type RawTextareaAutosizeSettings = undefined | boolean | TextareaAutosizeSettings;
declare function createTextareaNodeProps(options?: TextareaNodeControlOptions): {
  /** Automatically adjust the height of the box based on the number of input lines. */
  autosize: PropType<RawTextareaAutosizeSettings>;
  /** Size (number of lines) of the input box. */
  rows: {
    default: number | undefined;
    type: PropType<import("@fastkit/vue-utils").Numberish>;
  };
  mask: PropType<IMaskInput>;
  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 | "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" | undefined;
  };
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<any, any>;
  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 TextareaNodeProps = ExtractPropTypes<ReturnType<typeof createTextareaNodeProps>>;
declare function createTextareaNodeEmits(): {
  'update:modelValue': (value: string) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: string) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createTextareaNodeSettings(options?: TextareaNodeControlOptions): {
  props: {
    /** Automatically adjust the height of the box based on the number of input lines. */
    autosize: PropType<RawTextareaAutosizeSettings>;
    /** Size (number of lines) of the input box. */
    rows: {
      default: number | undefined;
      type: PropType<import("@fastkit/vue-utils").Numberish>;
    };
    mask: PropType<IMaskInput>;
    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 | "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" | undefined;
    };
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<any, any>;
    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;
  };
  emits: {
    'update:modelValue': (value: string) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: string) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface TextareaNodeEmitOptions extends ReturnType<typeof createTextareaNodeEmits> {}
type TextareaNodeContext = SetupContext<TextareaNodeEmitOptions>;
interface TextareaNodeControlOptions extends TextableControlOptions {
  defaultRows?: number;
}
declare class TextareaNodeControl extends TextableControl {
  readonly _props: TextareaNodeProps;
  protected _inputElement: import("vue").Ref<HTMLTextAreaElement | {
    value: string;
    focus: (opts?: FocusOptions) => void;
    blur: () => void;
  } | null, HTMLTextAreaElement | VTextareaAutosizeRef | {
    value: string;
    focus: (opts?: FocusOptions) => void;
    blur: () => void;
  } | null>;
  protected _autosize: ComputedRef<TextareaAutosizeSettings | undefined>;
  protected _rows: ComputedRef<number | undefined>;
  /**
   * `<textarea />` element or `<VTextareaAutosizeRef />`
   */
  get inputElement(): HTMLTextAreaElement | VTextareaAutosizeRef | null;
  /**
   * Auto-sizing setting
   *
   * @see {@link TextareaAutosizeSettings}
   */
  get autosizeSettings(): TextareaAutosizeSettings | undefined;
  /** Size (number of lines) of the input box. */
  get rows(): number | undefined;
  constructor(props: TextareaNodeProps, ctx: TextareaNodeContext, options?: TextareaNodeControlOptions);
  emptyValue(): string;
  createInputElement(override?: Pick<TextareaHTMLAttributes, 'class'>): VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
  }>;
  focus(opts?: FocusOptions): void;
  blur(): void;
}
declare function useTextareaNodeControl(props: TextareaNodeProps, ctx: TextareaNodeContext, options?: TextareaNodeControlOptions): TextareaNodeControl;
//#endregion
//#region src/composables/boundable-input.d.ts
type BoundableValue = number | string;
/**
 * Required criteria for Boundable inputs
 *
 * - `start` Input of start value is mandatory
 * - `end` Input of end value is mandatory
 * - `any` At least one input is required
 * - `both` Both inputs are mandatory
 */
type BoundableRequiredConstraints = 'start' | 'end' | 'any' | 'both';
/**
 * Specify of Required criteria for Boundable inputs
 */
type BoundableRequiredConstraintsSpec = boolean | BoundableRequiredConstraints;
declare const boundableRequired: import("@fastkit/rules").Rule<BoundableRequiredConstraints>;
declare const boundableMin: import("@fastkit/rules").Rule<BoundableValue>;
declare const boundableMax: import("@fastkit/rules").Rule<BoundableValue>;
interface BoundableInputControlPropsOptions<T extends BoundableValue = BoundableValue, D extends T | null = null, DS extends T | null = null, DE extends T | null = null, Min extends T | null = null, Max extends T | null = null> extends Pick<FormNodeControlBaseOptions, 'defaultValidateTiming'> {
  type: PropType<T>;
  defaultValue?: D;
  defaultStartValue?: DS;
  defaultEndValue?: DE;
  defaultMin?: Min;
  defaultMax?: Max;
  range?: boolean;
}
declare const REQUIRED_PROP_OPTIONS: {
  readonly type: PropType<boolean | BoundableRequiredConstraints>;
  readonly default: false;
};
declare function createBoundableInputProps<T extends BoundableValue = BoundableValue, D extends T | null = null, DS extends T | null = null, DE extends T | null = null, Min extends T | null = null, Max extends T | null = null>(options: BoundableInputControlPropsOptions<T, D, DS, DE, Min, Max>): {
  startValue: {
    type: PropType<T | DS>;
    default: null;
  };
  endValue: {
    type: PropType<T | DE>;
    default: null;
  };
  min: {
    type: PropType<T | Min>;
    default: null;
  };
  max: {
    type: PropType<T | Max>;
    default: null;
  };
  startName: StringConstructor;
  endName: StringConstructor;
  range: {
    type: BooleanConstructor;
    default: boolean | undefined;
  };
  /**
   * Required condition
   *
   * @default false
   *
   * @see {@link BoundableRequiredConstraints}
   */
  required: typeof REQUIRED_PROP_OPTIONS;
  modelValue: {
    type: PropType<T | D>;
    default: null;
  };
  name: StringConstructor;
  tag: StringConstructor;
  tabindex: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  autofocus: BooleanConstructor;
  disabled: BooleanConstructor;
  readonly: BooleanConstructor;
  viewonly: BooleanConstructor;
  spellcheck: BooleanConstructor;
  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;
};
declare function createBoundableInputEmits<T extends BoundableValue = BoundableValue, D extends T | null = null, DS extends T | null = null, DE extends T | null = null, Min extends T | null = null, Max extends T | null = null>(_options: BoundableInputControlPropsOptions<T, D, DS, DE, Min, Max>): {
  'update:startValue': (value: T | DS) => boolean;
  'update:endValue': (value: T | DE) => boolean;
  'update:modelValue': (value: T | D) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: T | D) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createBoundableInputSettings<T extends BoundableValue = BoundableValue, D extends T | null = null, DS extends T | null = null, DE extends T | null = null, Min extends T | null = null, Max extends T | null = null>(options: BoundableInputControlPropsOptions<T, D, DS, DE, Min, Max>): {
  props: {
    startValue: {
      type: PropType<T | DS>;
      default: null;
    };
    endValue: {
      type: PropType<T | DE>;
      default: null;
    };
    min: {
      type: PropType<T | Min>;
      default: null;
    };
    max: {
      type: PropType<T | Max>;
      default: null;
    };
    startName: StringConstructor;
    endName: StringConstructor;
    range: {
      type: BooleanConstructor;
      default: boolean | undefined;
    };
    /**
     * Required condition
     *
     * @default false
     *
     * @see {@link BoundableRequiredConstraints}
     */
    required: typeof REQUIRED_PROP_OPTIONS;
    modelValue: {
      type: PropType<T | D>;
      default: null;
    };
    name: StringConstructor;
    tag: StringConstructor;
    tabindex: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    autofocus: BooleanConstructor;
    disabled: BooleanConstructor;
    readonly: BooleanConstructor;
    viewonly: BooleanConstructor;
    spellcheck: BooleanConstructor;
    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;
  };
  emits: {
    'update:startValue': (value: T | DS) => boolean;
    'update:endValue': (value: T | DE) => boolean;
    'update:modelValue': (value: T | D) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: T | D) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface ResolvedProps<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null, Min extends T | null = null, Max extends T | null = null> {
  readonly modelValue: MV;
  readonly required: BoundableRequiredConstraintsSpec;
  readonly startValue: SV;
  readonly endValue: EV;
  readonly min: Min;
  readonly max: Max;
  readonly startName?: string;
  readonly endName?: string;
  readonly range: boolean;
}
type BoundableInputProps<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null, Min extends T | null = null, Max extends T | null = null> = ExtractPropTypes<Omit<ReturnType<typeof createFormNodeProps>, 'modelValue' | 'required'>> & ResolvedProps<T, MV, SV, EV, Min, Max>;
interface ResolvedEmits<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null> {
  'update:modelValue': (value: MV) => boolean;
  'update:startValue': (value: SV) => boolean;
  'update:endValue': (value: EV) => boolean;
  change: (value: MV) => boolean;
}
type BoundableInputEmits<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null> = Omit<ReturnType<typeof createFormNodeEmits>, 'update:modelValue' | 'change'> & ResolvedEmits<T, MV, SV, EV>;
type BoundableInputContext<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null> = SetupContext<BoundableInputEmits<T, MV, SV, EV>>;
interface BoundableInputControlOptions<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null, Min extends T | null = null, Max extends T | null = null> extends Omit<BoundableInputControlPropsOptions<T, MV, SV, EV, Min, Max>, 'type'>, Pick<FormNodeControlBaseOptions, 'nodeType'> {}
declare class BoundableInputControl<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null, Min extends T | null = null, Max extends T | null = null> extends FormNodeControl<MV, MV, typeof REQUIRED_PROP_OPTIONS> {
  readonly _props: BoundableInputProps<T, MV, SV, EV, Min, Max>;
  protected _boundableOptions: BoundableInputControlOptions<T, MV, SV, EV, Min, Max>;
  protected _startValue: Ref<SV>;
  protected _endValue: Ref<EV>;
  protected _initialStartValue: Ref<SV>;
  protected _initialEndValue: Ref<EV>;
  protected _currentStartValue: WritableComputedRef<SV>;
  protected _currentEndValue: WritableComputedRef<EV>;
  protected _startName: ComputedRef<string | undefined>;
  protected _endName: ComputedRef<string | undefined>;
  protected _isRange: Ref<boolean>;
  protected _min: Ref<Min>;
  protected _max: Ref<Max>;
  get isRange(): boolean;
  get startName(): string | undefined;
  get endName(): string | undefined;
  get startValue(): SV;
  set startValue(startValue: SV);
  get endValue(): EV;
  set endValue(endValue: EV);
  get validationValue(): any;
  get initialStartValue(): SV;
  get initialEndValue(): EV;
  get min(): Min;
  get max(): Max;
  constructor(props: BoundableInputProps<T, MV, SV, EV, Min, Max>, ctx: BoundableInputContext<T, MV, SV, EV>, options: BoundableInputControlOptions<T, MV, SV, EV, Min, Max>);
  commitSelfValue(): void;
  resetSelfValue(): void;
  emptyStartValue(): SV;
  emptyEndValue(): EV;
  clearSelf(): void;
  protected _resolveRules(): import("@fastkit/rules").VerifiableRule[];
}
declare function useBoundableInputControl<T extends BoundableValue = BoundableValue, MV extends T | null = T | null, SV extends T | null = T | null, EV extends T | null = T | null, Min extends T | null = null, Max extends T | null = null>(props: BoundableInputProps<T, MV, SV, EV, Min, Max>, ctx: BoundableInputContext<T, MV, SV, EV>, options: BoundableInputControlOptions<T, MV, SV, EV, Min, Max>): BoundableInputControl<T, MV, SV, EV, Min, Max>;
//#endregion
//#region src/composables/date-input.d.ts
type DateInputValue = string;
interface DateInputNodeControlPropsOptions<D extends DateInputValue | null = null, DS extends DateInputValue | null = null, DE extends DateInputValue | null = null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null> extends Omit<BoundableInputControlPropsOptions<DateInputValue, D, DS, DE, Min, Max>, 'type'> {
  omitEndYearFormat?: boolean;
}
type DateInputFormat = Intl.DateTimeFormatOptions | ((value: DateInputValue) => string);
type FormatLocales = string | string[];
declare function createDateInputNodeProps<D extends DateInputValue | null = null, DS extends DateInputValue | null = null, DE extends DateInputValue | null = null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null>(options?: DateInputNodeControlPropsOptions<D, DS, DE, Min, Max>): {
  /**
   * {@link Intl.DateTimeFormatOptions}
   */
  format: PropType<Intl.DateTimeFormatOptions>;
  /**
   * Omit the western calendar year of the end date.
   */
  omitEndYearFormat: {
    type: BooleanConstructor;
    default: boolean;
  };
  /**
   * Format locales
   */
  formatLocales: PropType<FormatLocales | (() => FormatLocales)>;
  startValue: {
    type: PropType<BoundableValue | DS>;
    default: null;
  };
  endValue: {
    type: PropType<BoundableValue | DE>;
    default: null;
  };
  min: {
    type: PropType<BoundableValue | Min>;
    default: null;
  };
  max: {
    type: PropType<BoundableValue | Max>;
    default: null;
  };
  startName: StringConstructor;
  endName: StringConstructor;
  range: {
    type: BooleanConstructor;
    default: boolean | undefined;
  };
  required: {
    readonly type: PropType<boolean | BoundableRequiredConstraints>;
    readonly default: false;
  };
  modelValue: {
    type: PropType<BoundableValue | D>;
    default: null;
  };
  name: StringConstructor;
  tag: StringConstructor;
  tabindex: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  autofocus: BooleanConstructor;
  disabled: BooleanConstructor;
  readonly: BooleanConstructor;
  viewonly: BooleanConstructor;
  spellcheck: BooleanConstructor;
  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;
};
declare function createDateInputNodeEmits<D extends DateInputValue | null = null, DS extends DateInputValue | null = null, DE extends DateInputValue | null = null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null>(options?: DateInputNodeControlPropsOptions<D, DS, DE, Min, Max>): {
  'update:startValue': (value: BoundableValue | DS) => boolean;
  'update:endValue': (value: BoundableValue | DE) => boolean;
  'update:modelValue': (value: BoundableValue | D) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: BoundableValue | D) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createDateInputNodeSettings<D extends DateInputValue | null = null, DS extends DateInputValue | null = null, DE extends DateInputValue | null = null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null>(options: DateInputNodeControlPropsOptions<D, DS, DE, Min, Max>): {
  props: {
    /**
     * {@link Intl.DateTimeFormatOptions}
     */
    format: PropType<Intl.DateTimeFormatOptions>;
    /**
     * Omit the western calendar year of the end date.
     */
    omitEndYearFormat: {
      type: BooleanConstructor;
      default: boolean;
    };
    /**
     * Format locales
     */
    formatLocales: PropType<FormatLocales | (() => FormatLocales)>;
    startValue: {
      type: PropType<BoundableValue | DS>;
      default: null;
    };
    endValue: {
      type: PropType<BoundableValue | DE>;
      default: null;
    };
    min: {
      type: PropType<BoundableValue | Min>;
      default: null;
    };
    max: {
      type: PropType<BoundableValue | Max>;
      default: null;
    };
    startName: StringConstructor;
    endName: StringConstructor;
    range: {
      type: BooleanConstructor;
      default: boolean | undefined;
    };
    required: {
      readonly type: PropType<boolean | BoundableRequiredConstraints>;
      readonly default: false;
    };
    modelValue: {
      type: PropType<BoundableValue | D>;
      default: null;
    };
    name: StringConstructor;
    tag: StringConstructor;
    tabindex: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    autofocus: BooleanConstructor;
    disabled: BooleanConstructor;
    readonly: BooleanConstructor;
    viewonly: BooleanConstructor;
    spellcheck: BooleanConstructor;
    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;
  };
  emits: {
    'update:startValue': (value: BoundableValue | DS) => boolean;
    'update:endValue': (value: BoundableValue | DE) => boolean;
    'update:modelValue': (value: BoundableValue | D) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: BoundableValue | D) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface DateInputNodeControlOptions<MV extends DateInputValue | null = DateInputValue | null, SV extends DateInputValue | null = DateInputValue | null, EV extends DateInputValue | null = DateInputValue | null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null> extends BoundableInputControlOptions<DateInputValue, MV, SV, EV, Min, Max> {
  /**
   * {@link Intl.DateTimeFormatOptions}
   */
  format?: Intl.DateTimeFormatOptions;
  /**
   * Format locales
   *
   * Used when {@link Intl.DateTimeFormatOptions} is specified in format prop.
   */
  formatLocales?: FormatLocales | (() => FormatLocales);
}
type DateInputNodeProps<MV extends DateInputValue | null = DateInputValue | null, SV extends DateInputValue | null = DateInputValue | null, EV extends DateInputValue | null = DateInputValue | null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null> = BoundableInputProps<DateInputValue, MV, SV, EV, Min, Max> & {
  readonly format?: Intl.DateTimeFormatOptions;
  readonly omitEndYearFormat: boolean;
  readonly formatLocales?: FormatLocales | (() => FormatLocales);
};
type DateInputNodeContext<MV extends DateInputValue | null = DateInputValue | null, SV extends DateInputValue | null = DateInputValue | null, EV extends DateInputValue | null = DateInputValue | null> = BoundableInputContext<DateInputValue, MV, SV, EV>;
declare class DateInputNodeControl<MV extends DateInputValue | null = DateInputValue | null, SV extends DateInputValue | null = DateInputValue | null, EV extends DateInputValue | null = DateInputValue | null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null> extends BoundableInputControl<DateInputValue, MV, SV, EV, Min, Max> {
  readonly _props: DateInputNodeProps<MV, SV, EV, Min, Max>;
  protected _formatLocales: ComputedRef<string | string[] | undefined>;
  protected _formatOptions: ComputedRef<Intl.DateTimeFormatOptions>;
  protected _omitYearFormatOptions: ComputedRef<Intl.DateTimeFormatOptions>;
  protected _formatter: ComputedRef<Intl.DateTimeFormat>;
  protected _omitYearFormatter: ComputedRef<Intl.DateTimeFormat>;
  protected _formattedValue: ComputedRef<string>;
  protected _formattedStartValue: ComputedRef<string>;
  protected _formattedEndValue: ComputedRef<string>;
  protected _isAnySelected: ComputedRef<boolean>;
  get formatLocales(): string | string[] | undefined;
  get formatOptions(): Intl.DateTimeFormatOptions;
  get omitYearFormatOptions(): Intl.DateTimeFormatOptions;
  get formatter(): Intl.DateTimeFormat;
  get omitYearFormatter(): Intl.DateTimeFormat;
  get formattedValue(): string;
  get formattedStartValue(): string;
  get formattedEndValue(): string;
  get isAnySelected(): boolean;
  get omitEndYearFormat(): boolean;
  constructor(props: DateInputNodeProps<MV, SV, EV, Min, Max>, ctx: DateInputNodeContext<MV, SV, EV>, options: DateInputNodeControlOptions<MV, SV, EV, Min, Max>);
  formatValue(value: DateInputValue | Date): string;
  formatValueToParts(value: DateInputValue | Date): Intl.DateTimeFormatPart[];
  omitYearFormatValue(value: DateInputValue | Date): string;
  omitYearFormatValueToParts(value: DateInputValue | Date): Intl.DateTimeFormatPart[];
}
declare function useDateInputNodeControl<MV extends DateInputValue | null = DateInputValue | null, SV extends DateInputValue | null = DateInputValue | null, EV extends DateInputValue | null = DateInputValue | null, Min extends DateInputValue | null = null, Max extends DateInputValue | null = null>(props: DateInputNodeProps<MV, SV, EV, Min, Max>, ctx: DateInputNodeContext<MV, SV, EV>, options: DateInputNodeControlOptions<MV, SV, EV, Min, Max>): DateInputNodeControl<MV, SV, EV, Min, Max>;
//#endregion
//#region src/composables/file.d.ts
interface FileInputNodeControlOptions extends FormNodeControlBaseOptions {
  defaultMultiple?: boolean;
}
interface FileInputNodeFile extends Pick<File, 'name' | 'type' | 'size' | 'lastModified'> {
  readonly _file: File;
  readonly truncatedName: string;
  readonly readableSize: string;
}
interface FileInputNodeSelectionContext {
  files: FileInputNodeFile[];
  totalSize: number;
  totalReadableSize: string;
}
declare function createFileInputNodeProps(options?: FileInputNodeControlOptions): {
  /**
   * Defines the file types that the file input field accepts.
   *
   * @example ".doc,.docx,.xml,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document"
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#accept
   */
  accept: StringConstructor;
  /**
   * When the `accept` attribute indicates that the input is intended for image
   * or video data, specifies which camera to use for capturing the data.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#capture
   */
  capture: PropType<InputHTMLAttributes["capture"]>;
  /**
   * Allows selecting multiple files.
   *
   * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#multiple
   */
  multiple: {
    type: BooleanConstructor;
    default: boolean | undefined;
  };
  /**
   * The number of characters after which the file name will be truncated.
   *
   * @default 22
   */
  truncateLength: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
  };
  /** placeholder */
  placeholder: StringConstructor;
  name: StringConstructor;
  tag: StringConstructor;
  modelValue: import("vue").Prop<File[], File[]>;
  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 FileInputNodeProps = ExtractPropTypes<ReturnType<typeof createFileInputNodeProps>>;
declare function createFileInputNodeEmits(options?: FileInputNodeControlOptions): {
  'update:modelValue': (value: File[]) => boolean;
  'update:errors': (errors: FormNodeError[]) => boolean;
  change: (value: File[]) => boolean;
  focus: (ev: FocusEvent) => boolean;
  blur: (ev: FocusEvent) => boolean;
};
declare function createFileInputNodeSettings(options?: FileInputNodeControlOptions): {
  props: {
    /**
     * Defines the file types that the file input field accepts.
     *
     * @example ".doc,.docx,.xml,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document"
     *
     * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#accept
     */
    accept: StringConstructor;
    /**
     * When the `accept` attribute indicates that the input is intended for image
     * or video data, specifies which camera to use for capturing the data.
     *
     * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#capture
     */
    capture: PropType<InputHTMLAttributes["capture"]>;
    /**
     * Allows selecting multiple files.
     *
     * @see https://developer.mozilla.org/docs/Web/HTML/Reference/Elements/input/file#multiple
     */
    multiple: {
      type: BooleanConstructor;
      default: boolean | undefined;
    };
    /**
     * The number of characters after which the file name will be truncated.
     *
     * @default 22
     */
    truncateLength: {
      type: (StringConstructor | NumberConstructor)[];
      default: number;
    };
    /** placeholder */
    placeholder: StringConstructor;
    name: StringConstructor;
    tag: StringConstructor;
    modelValue: import("vue").Prop<File[], File[]>;
    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;
  };
  emits: {
    'update:modelValue': (value: File[]) => boolean;
    'update:errors': (errors: FormNodeError[]) => boolean;
    change: (value: File[]) => boolean;
    focus: (ev: FocusEvent) => boolean;
    blur: (ev: FocusEvent) => boolean;
  };
};
interface FileInputNodeEmits extends ReturnType<typeof createFileInputNodeEmits> {}
type FileInputNodeContext = SetupContext<FileInputNodeEmits>;
declare class FileInputNodeControl extends FormNodeControl<File[], File[]> {
  readonly _props: FileInputNodeProps;
  protected _inputElement: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
  protected _files: ComputedRef<FileInputNodeFile[]>;
  protected _selectionContext: ComputedRef<FileInputNodeSelectionContext>;
  /**
   * `<input />` Element
   */
  get inputElement(): HTMLInputElement | null;
  get multiple(): boolean;
  get accept(): string | undefined;
  get capture(): boolean | "user" | "environment" | undefined;
  get truncateLength(): number;
  get files(): FileInputNodeFile[];
  get selectionContext(): FileInputNodeSelectionContext;
  get placeholder(): string | undefined;
  constructor(props: FileInputNodeProps, ctx: FileInputNodeContext, options?: FileInputNodeControlOptions);
  emptyValue(): never[];
  protected _handleNodeChange(ev: Event): void;
  createInputElement(override?: Omit<InputHTMLAttributes, 'type'>): import("vue/jsx-runtime").JSX.Element;
  focus(opts?: FocusOptions): void;
  blur(): void;
}
declare function useFileInputNodeControl(props: FileInputNodeProps, ctx: FileInputNodeContext, options?: FileInputNodeControlOptions): FileInputNodeControl;
//#endregion
//#region src/directives/imask.d.ts
type IMaskDirectiveBindingValue = IMaskInput;
type IMaskDirectiveBinding = DirectiveBinding<IMaskDirectiveBindingValue>;
interface IMaskElement extends HTMLInputElement {
  maskRef?: InputMask<any>;
}
type IMaskDirective = ObjectDirective<IMaskElement, IMaskDirectiveBindingValue>;
declare const imaskDirective: IMaskDirective;
declare function imaskDirectiveArgument(bindingValue?: IMaskDirectiveBindingValue): [IMaskDirective, IMaskDirectiveBindingValue];
//#endregion
//#region src/plugin.d.ts
declare module 'vue' {
  interface ComponentCustomProperties {
    $form: VueFormService;
  }
}
declare class VueFormPlugin {
  static install(app: App, opts?: VueFormServiceOptions): void;
}
declare function installVueFormPlugin(app: App, opts?: VueFormServiceOptions): App<any>;
//#endregion
export { AnyMaskedOptions, BUILTIN_TEXT_FINALIZERS, BoundableInputContext, BoundableInputControl, BoundableInputControlOptions, BoundableInputControlPropsOptions, BoundableInputEmits, BoundableInputProps, BoundableRequiredConstraints, BoundableRequiredConstraintsSpec, BoundableValue, BuiltinTextFinalizerName, DEFAULT_FORM_SELECTOR_GROUP_ID, DateInputFormat, DateInputNodeContext, DateInputNodeControl, DateInputNodeControlOptions, DateInputNodeControlPropsOptions, DateInputNodeProps, DispatchFormActionOptions, FORM_AUTO_COMPLETES, FileInputNodeContext, FileInputNodeControl, FileInputNodeControlOptions, FileInputNodeEmits, FileInputNodeFile, FileInputNodeProps, FileInputNodeSelectionContext, FormAcceptInvalidSubmissionSpec, FormAction, FormActionContext, FormActionHandler, FormAutoCapitalize, FormAutoComplete, FormContext, FormEmitOptions, FormEmits, FormErrorMessageResolver, FormFunctionableAction, FormGroupContext, FormGroupControl, FormGroupEmitOptions, FormGroupInjectionKey, FormGroupOptions, FormGroupProps, FormInjectionKey, FormInvalidSubmissionAcceptor, FormInvalidSubmissionAcceptorContext, FormNodeContext, FormNodeControl, FormNodeControlBaseOptions, FormNodeControlOptions, FormNodeEmitOptions, FormNodeError, FormNodeErrorMessageSource, FormNodeErrorSlots, FormNodeErrorSlotsSource, FormNodeErrors, FormNodeInjectionKey, FormNodeProps, FormNodeStateExtension, FormNodeStateExtensions, FormNodeType, FormNodeWrapper, FormNodeWrapperContext, FormNodeWrapperEmitOptions, FormNodeWrapperHinttip, FormNodeWrapperHinttipDelay, FormNodeWrapperInjectionKey, FormNodeWrapperOptions, FormNodeWrapperProps, FormNodeWrapperSlots, FormOptions, FormProps, FormSelectorContext, FormSelectorControl, FormSelectorControlOptions, FormSelectorEmitOptions, FormSelectorGroup, FormSelectorGuard, FormSelectorGuardContext, FormSelectorInjectionKey, FormSelectorItem, FormSelectorItemContext, FormSelectorItemControl, FormSelectorItemControlOptions, FormSelectorItemEmitOptions, FormSelectorItemGroupContext, FormSelectorItemGroupControl, FormSelectorItemGroupControlOptions, FormSelectorItemGroupInjectionKey, FormSelectorItemGroupProps, FormSelectorItemInputType, FormSelectorItemOrGroups, FormSelectorItemProps, FormSelectorLoadState, FormSelectorProps, FormSelectorValue, FormServiceInjectionKey, IMaskControl, IMaskControlProps, IMaskDirective, IMaskDirectiveBinding, IMaskDirectiveBindingValue, IMaskElement, IMaskEvent, IMaskEventType, IMaskInput, type IMaskInstance, IMaskPipeType, IMaskTypedValue, MaskedDynamicOptionsWithMeta, NumberInputNodeContext, NumberInputNodeControl, NumberInputNodeControlOptions, NumberInputNodeEmitOptions, NumberInputNodeProps, PrepareFormSubmissionOptions, RawFormSelectorItems, RawTextInputListItem, RawTextareaAutosizeSettings, RecursiveVerifiableRuleOrFn, RecursiveVerifiableRuleOrFnArray, RequiredChipSource, ResolvedFormSelectorGroup, ResolvedFormSelectorItem, TEXT_INPUT_MODES, TEXT_INPUT_TYPES, TextFinalizer, TextInputListDetails, TextInputListItem, TextInputListItemValue, TextInputListSpec, TextInputMaskModel, TextInputMode, TextInputNodeContext, TextInputNodeControl, TextInputNodeControlOptions, TextInputNodeEmitOptions, TextInputNodeEmits, TextInputNodeProps, TextInputType, TextableContext, TextableControl, TextableControlOptions, TextableCounterResult, TextableCounterSettings, TextableEmitOptions, TextableFinalizerSpec, TextableProps, TextareaAutosizeSettings, TextareaNodeContext, TextareaNodeControl, TextareaNodeControlOptions, TextareaNodeEmitOptions, TextareaNodeProps, VTextareaAutosize, VTextareaAutosizeRef, ValidateTiming, ValidationResult, VueForm, VueFormPlugin, VueFormScrollOptions, VueFormService, VueFormServiceOptions, boundableMax, boundableMin, boundableRequired, createBoundableInputEmits, createBoundableInputProps, createBoundableInputSettings, createDateInputNodeEmits, createDateInputNodeProps, createDateInputNodeSettings, createFileInputNodeEmits, createFileInputNodeProps, createFileInputNodeSettings, createFormEmits, createFormGroupEmits, createFormGroupProps, createFormGroupSettings, createFormNodeEmits, createFormNodeProps, createFormNodeSettings, createFormNodeWrapperEmits, createFormNodeWrapperProps, createFormNodeWrapperSettings, createFormProps, createFormSelectorEmits, createFormSelectorItemEmits, createFormSelectorItemGroupProps, createFormSelectorItemProps, createFormSelectorItemSettings, createFormSelectorProps, createFormSelectorSettings, createFormSettings, createIMaskEvent, createMaskControlProps, createMaskedOptions, createNumberInputNodeEmits, createNumberInputNodeProps, createNumberInputNodeSettings, createTextInputNodeEmits, createTextInputNodeProps, createTextInputNodeSettings, createTextableEmits, createTextableProps, createTextableSettings, createTextareaNodeEmits, createTextareaNodeProps, createTextareaNodeSettings, imaskDirective, imaskDirectiveArgument, installVueFormPlugin, mergeFormNodeRules, resolveIMaskInput, toFormNodeError, useBoundableInputControl, useDateInputNodeControl, useFileInputNodeControl, useForm, useFormGroup, useFormNodeControl, useFormNodeWrapper, useFormSelectorControl, useFormSelectorItemControl, useFormSelectorItemGroupControl, useIMaskControl, useNumberInputNodeControl, useParentForm, useParentFormGroup, useParentFormNode, useParentFormNodeWrapper, useParentFormSelector, useParentFormSelectorItemGroup, useTextInputNodeControl, useTextableControl, useTextareaNodeControl, useVueForm };