@aerogel/core 0.0.0-next.08ce43db6eedda463e336bacd33f6c9a741096f4

package/dist/aerogel-core.d.ts

@@ -0,0 +1,2963 @@
+import { AcceptableValue } from 'reka-ui';
+import { AllowedComponentProps } from 'vue';
+import { App as App_2 } from 'vue';
+import { AsTag } from 'reka-ui';
+import { ClassValue } from 'clsx';
+import { Component } from 'vue';
+import { ComponentCustomProperties } from 'vue';
+import { ComponentCustomProps } from 'vue';
+import { ComponentInternalInstance } from 'vue';
+import { ComponentOptionsBase } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComponentPublicInstance } from 'vue';
+import { ComputedGetter } from 'vue';
+import { ComputedRef } from 'vue';
+import { Constructor } from '@noeldemartin/utils';
+import { cva } from 'class-variance-authority';
+import { DebuggerEvent } from 'vue';
+import { DeepReadonly } from 'vue';
+import { DefineComponent } from 'vue';
+import { DefineStoreOptions } from 'pinia';
+import { DialogContent } from 'reka-ui';
+import { DialogContentProps } from 'reka-ui';
+import { DialogDescriptionProps } from 'reka-ui';
+import { DialogOverlayProps } from 'reka-ui';
+import { DialogTitleProps } from 'reka-ui';
+import { Directive } from 'vue';
+import { DropdownMenuContentProps } from 'reka-ui';
+import { Facade } from '@noeldemartin/utils';
+import { GetClosureArgs } from '@noeldemartin/utils';
+import { GetClosureResult } from '@noeldemartin/utils';
+import { _GettersTree } from 'pinia';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { HTMLAttributes } from 'vue';
+import { InjectionKey } from 'vue';
+import { JSError } from '@noeldemartin/utils';
+import { LabelProps } from 'reka-ui';
+import { Listeners } from '@noeldemartin/utils';
+import { ListenersManager } from '@noeldemartin/utils';
+import { MagicObject } from '@noeldemartin/utils';
+import { MaybeRef } from 'vue';
+import { nextTick } from 'vue';
+import { Nullable } from '@noeldemartin/utils';
+import { ObjectValues } from '@noeldemartin/utils';
+import { OnCleanup } from '@vue/reactivity';
+import { Pinia } from 'pinia';
+import { PrimitiveProps } from 'reka-ui';
+import { PromisedValue } from '@noeldemartin/utils';
+import { PropType } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { SelectContentProps } from 'reka-ui';
+import { SelectItemProps } from 'reka-ui';
+import { ShallowUnwrapRef } from 'vue';
+import { Slot } from 'vue';
+import { StateTree } from 'pinia';
+import { Store } from 'pinia';
+import { UnwrapNestedRefs } from 'vue';
+import { VNode } from 'vue';
+import { VNodeProps } from 'vue';
+import { WatchOptions } from 'vue';
+import { WatchStopHandle } from 'vue';
+
+declare const __VLS_component: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+declare const __VLS_component_10: DefineComponent<DialogTitleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_11: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_12: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_13: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_14: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_15: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_16: DefineComponent<ToastProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToastProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_17: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDetailsElement>;
+
+declare const __VLS_component_18: DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_19: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: Nullable<FormFieldValue>) => any;
+}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+$inputRef: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly name?: string | undefined;
+readonly label?: string | undefined;
+readonly description?: string | undefined;
+readonly modelValue?: Nullable<FormFieldValue>;
+readonly as?: string | undefined;
+readonly "onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: (event: "update:modelValue", value: Nullable<FormFieldValue>) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<InputProps<Nullable<FormFieldValue>> & {
+as?: string;
+}> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, {
+id: string;
+name: ComputedRef<string | undefined>;
+label: ComputedRef<string | undefined>;
+description: ComputedRef<string | undefined>;
+value: ComputedRef<Nullable<FormFieldValue>>;
+errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+required: ComputedRef<boolean | undefined>;
+update(value: Nullable<FormFieldValue>): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: Nullable<FormFieldValue>) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<InputProps<Nullable<FormFieldValue>> & {
+as?: string;
+}> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, "id" | "value" | "name" | "description" | "errors" | "required" | "label" | "update"> & ShallowUnwrapRef<    {
+id: string;
+name: ComputedRef<string | undefined>;
+label: ComputedRef<string | undefined>;
+description: ComputedRef<string | undefined>;
+value: ComputedRef<Nullable<FormFieldValue>>;
+errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+required: ComputedRef<boolean | undefined>;
+update(value: Nullable<FormFieldValue>): void;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+};
+}) | null;
+}, any>;
+
+declare const __VLS_component_2: DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_20: DefineComponent<DropdownMenuProps, {
+align: "start" | "center" | "end" | undefined;
+side: "top" | "right" | "bottom" | "left" | undefined;
+options: ComputedRef<DropdownMenuOptionData[] | undefined>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DropdownMenuProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_21: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+select: () => any;
+}, string, PublicProps, Readonly<{}> & Readonly<{
+onSelect?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_22: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_23: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+update: (value: string | number) => any;
+save: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{
+onUpdate?: ((value: string | number) => any) | undefined;
+onSave?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+$inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+
+declare const __VLS_component_24: DefineComponent<__VLS_Props_9, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_9> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare const __VLS_component_25: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+submit: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
+onSubmit?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLFormElement>;
+
+declare const __VLS_component_26: DefineComponent<__VLS_Props_13, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_13> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_27: DefineComponent<__VLS_Props_14, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_14> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_28: DefineComponent<__VLS_Props_15, {
+close: ((result?: unknown) => Promise<void>) | Ref<(result?: unknown) => Promise<void>, (result?: unknown) => Promise<void>>;
+$content: Ref<undefined, undefined> | ModalContentInstance | Ref<null, null> | Ref<{
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly forceMount?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly disableOutsidePointerEvents?: boolean | undefined;
+readonly asChild?: boolean | undefined;
+readonly as?: (AsTag | Component) | undefined;
+readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+readonly onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined | undefined;
+readonly onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => void) & ((event: "focusOutside", event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "interactOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+$el: any;
+$options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+escapeKeyDown: (event: KeyboardEvent) => any;
+pointerDownOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any;
+focusOutside: (event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+interactOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+openAutoFocus: (event: Event) => any;
+closeAutoFocus: (event: Event) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}, {
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly forceMount?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly disableOutsidePointerEvents?: boolean | undefined;
+readonly asChild?: boolean | undefined;
+readonly as?: (AsTag | Component) | undefined;
+readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+readonly onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined | undefined;
+readonly onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => void) & ((event: "focusOutside", event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "interactOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+$el: any;
+$options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+escapeKeyDown: (event: KeyboardEvent) => any;
+pointerDownOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any;
+focusOutside: (event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+interactOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+openAutoFocus: (event: Event) => any;
+closeAutoFocus: (event: Event) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_15> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_29: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_3: DefineComponent<__VLS_Props, {
+id: string;
+name: ComputedRef<string | undefined>;
+label: ComputedRef<string | undefined>;
+description: ComputedRef<string | undefined>;
+value: ComputedRef<Nullable<FormFieldValue>>;
+errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+required: ComputedRef<boolean | undefined>;
+update(value: Nullable<FormFieldValue>): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: Nullable<FormFieldValue>) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_30: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_31: DefineComponent<__VLS_Props_19, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_4: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_5: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_6: DefineComponent<ModalProps, {
+close: ((result?: unknown) => Promise<void>) | Ref<(result?: unknown) => Promise<void>, (result?: unknown) => Promise<void>>;
+$content: Ref<undefined, undefined> | ModalContentInstance | Ref<null, null> | Ref<    {
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly forceMount?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly disableOutsidePointerEvents?: boolean | undefined;
+readonly asChild?: boolean | undefined;
+readonly as?: (AsTag | Component) | undefined;
+readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+readonly onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined | undefined;
+readonly onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => void) & ((event: "focusOutside", event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "interactOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+$el: any;
+$options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+escapeKeyDown: (event: KeyboardEvent) => any;
+pointerDownOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any;
+focusOutside: (event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+interactOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+openAutoFocus: (event: Event) => any;
+closeAutoFocus: (event: Event) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}, {
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly forceMount?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly disableOutsidePointerEvents?: boolean | undefined;
+readonly asChild?: boolean | undefined;
+readonly as?: (AsTag | Component) | undefined;
+readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+readonly onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined | undefined;
+readonly onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => void) & ((event: "focusOutside", event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "interactOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+$el: any;
+$options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+escapeKeyDown: (event: KeyboardEvent) => any;
+pointerDownOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any;
+focusOutside: (event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+interactOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+openAutoFocus: (event: Event) => any;
+closeAutoFocus: (event: Event) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_7: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$contentRef: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly forceMount?: boolean | undefined;
+readonly trapFocus?: boolean | undefined;
+readonly disableOutsidePointerEvents?: boolean | undefined;
+readonly asChild?: boolean | undefined;
+readonly as?: (AsTag | Component) | undefined;
+readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+readonly onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined | undefined;
+readonly onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined | undefined;
+readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => void) & ((event: "focusOutside", event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "interactOutside", event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+$el: any;
+$options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+escapeKeyDown: (event: KeyboardEvent) => any;
+pointerDownOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any;
+focusOutside: (event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+interactOutside: (event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any;
+openAutoFocus: (event: Event) => any;
+closeAutoFocus: (event: Event) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+onPointerDownOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}>) => any) | undefined;
+onFocusOutside?: ((event: CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onInteractOutside?: ((event: CustomEvent<{
+originalEvent: PointerEvent;
+}> | CustomEvent<{
+originalEvent: FocusEvent;
+}>) => any) | undefined;
+onOpenAutoFocus?: ((event: Event) => any) | undefined;
+onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}) | null;
+}, any>;
+
+declare const __VLS_component_8: DefineComponent<DialogDescriptionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_9: DefineComponent<DialogOverlayProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type __VLS_PrettifyLocal_2<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare type __VLS_Props = InputProps & {
+    as?: string;
+};
+
+declare type __VLS_Props_10 = {
+    report: ErrorReport;
+    currentReport?: number;
+    totalReports?: number;
+};
+
+declare type __VLS_Props_11 = {
+    form?: FormController;
+};
+
+declare type __VLS_Props_12 = InputProps & {
+    inputClass?: HTMLAttributes['class'];
+    wrapperClass?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_13 = Omit<ButtonProps, 'variant'>;
+
+declare type __VLS_Props_14 = {
+    as?: string;
+    inline?: boolean;
+    langKey?: string;
+    langParams?: number | Record<string, unknown>;
+    langDefault?: string;
+    text?: string;
+    actions?: Record<string, () => unknown>;
+};
+
+declare type __VLS_Props_15 = ModalProps & {
+    dismissable?: boolean;
+    wrapperClass?: HTMLAttributes['class'];
+    class?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_16 = {
+    modal: UIModal;
+    childIndex?: number;
+};
+
+declare type __VLS_Props_17 = {
+    filledClass?: string;
+    progress?: number;
+    job?: Falsifiable<Job>;
+};
+
+declare type __VLS_Props_18 = {
+    value: AcceptableValue;
+    class?: HTMLAttributes['class'];
+    innerClass?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_19 = {
+    class?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_2 = {
+    type?: string;
+};
+
+declare type __VLS_Props_20 = {
+    class?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_21 = ToastProps & {
+    class?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_3 = Omit<LabelProps, 'for'>;
+
+declare type __VLS_Props_4 = SelectItemProps;
+
+declare type __VLS_Props_5 = {
+    class?: HTMLAttributes['class'];
+    innerClass?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_6 = InputProps & {
+    inputClass?: HTMLAttributes['class'];
+    labelClass?: HTMLAttributes['class'];
+};
+
+declare type __VLS_Props_7 = {
+    type?: string;
+    contentClass?: HTMLAttributes['class'];
+    ariaLabel?: string;
+    formAriaHidden?: boolean;
+    tabindex?: string;
+    text: string;
+    disabled?: boolean;
+};
+
+declare type __VLS_Props_8 = {
+    error: ErrorSource;
+};
+
+declare type __VLS_Props_9 = {
+    report: ErrorReport;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'startup-crash'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_10(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_11(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_12(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_13(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_14(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_15(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_16(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_17(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDetailsElement;
+};
+
+declare function __VLS_template_18(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_19(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        $inputRef: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly name?: string | undefined;
+                readonly label?: string | undefined;
+                readonly description?: string | undefined;
+                readonly modelValue?: Nullable<FormFieldValue>;
+                readonly as?: string | undefined;
+                readonly "onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "update:modelValue", value: Nullable<FormFieldValue>) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<InputProps<Nullable<FormFieldValue>> & {
+            as?: string;
+            }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+            }>, {
+            id: string;
+            name: ComputedRef<string | undefined>;
+            label: ComputedRef<string | undefined>;
+            description: ComputedRef<string | undefined>;
+            value: ComputedRef<Nullable<FormFieldValue>>;
+            errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+            required: ComputedRef<boolean | undefined>;
+            update(value: Nullable<FormFieldValue>): void;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            "update:modelValue": (value: Nullable<FormFieldValue>) => any;
+            }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<InputProps<Nullable<FormFieldValue>> & {
+            as?: string;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+        }>, "id" | "value" | "name" | "description" | "errors" | "required" | "label" | "update"> & ShallowUnwrapRef<    {
+        id: string;
+        name: ComputedRef<string | undefined>;
+        label: ComputedRef<string | undefined>;
+        description: ComputedRef<string | undefined>;
+        value: ComputedRef<Nullable<FormFieldValue>>;
+        errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+        required: ComputedRef<boolean | undefined>;
+        update(value: Nullable<FormFieldValue>): void;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_20(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        options?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_21(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_22(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_23(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        $inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_24(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(props: ErrorReportModalButtonsDefaultSlotProps): unknown;
+    }> & {
+        default(props: ErrorReportModalButtonsDefaultSlotProps): unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_25(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLFormElement;
+};
+
+declare function __VLS_template_26(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_27(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?(): VNode[];
+    }> & {
+        default?(): VNode[];
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_28(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ModalSlots> & ModalSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_29(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_30(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_31(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_4(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            id: string;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_5(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_6(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ModalSlots> & ModalSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_7(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        $contentRef: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly forceMount?: boolean | undefined;
+                readonly trapFocus?: boolean | undefined;
+                readonly disableOutsidePointerEvents?: boolean | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (AsTag | Component) | undefined;
+                readonly onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined | undefined;
+                readonly onPointerDownOutside?: ((event: CustomEvent<{
+                    originalEvent: PointerEvent;
+                }>) => any) | undefined | undefined;
+                readonly onFocusOutside?: ((event: CustomEvent<{
+                    originalEvent: FocusEvent;
+                }>) => any) | undefined | undefined;
+                readonly onInteractOutside?: ((event: CustomEvent<{
+                    originalEvent: PointerEvent;
+                }> | CustomEvent<{
+                    originalEvent: FocusEvent;
+                }>) => any) | undefined | undefined;
+                readonly onOpenAutoFocus?: ((event: Event) => any) | undefined | undefined;
+                readonly onCloseAutoFocus?: ((event: Event) => any) | undefined | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "escapeKeyDown", event: KeyboardEvent) => void) & ((event: "pointerDownOutside", event: CustomEvent<{
+                originalEvent: PointerEvent;
+            }>) => void) & ((event: "focusOutside", event: CustomEvent<{
+                originalEvent: FocusEvent;
+            }>) => void) & ((event: "interactOutside", event: CustomEvent<{
+                originalEvent: PointerEvent;
+            }> | CustomEvent<{
+                originalEvent: FocusEvent;
+            }>) => void) & ((event: "openAutoFocus", event: Event) => void) & ((event: "closeAutoFocus", event: Event) => void);
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+            onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+            onPointerDownOutside?: ((event: CustomEvent<{
+            originalEvent: PointerEvent;
+            }>) => any) | undefined;
+            onFocusOutside?: ((event: CustomEvent<{
+            originalEvent: FocusEvent;
+            }>) => any) | undefined;
+            onInteractOutside?: ((event: CustomEvent<{
+            originalEvent: PointerEvent;
+            }> | CustomEvent<{
+            originalEvent: FocusEvent;
+            }>) => any) | undefined;
+            onOpenAutoFocus?: ((event: Event) => any) | undefined;
+            onCloseAutoFocus?: ((event: Event) => any) | undefined;
+            }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            escapeKeyDown: (event: KeyboardEvent) => any;
+            pointerDownOutside: (event: CustomEvent<{
+            originalEvent: PointerEvent;
+            }>) => any;
+            focusOutside: (event: CustomEvent<{
+            originalEvent: FocusEvent;
+            }>) => any;
+            interactOutside: (event: CustomEvent<{
+            originalEvent: PointerEvent;
+            }> | CustomEvent<{
+            originalEvent: FocusEvent;
+            }>) => any;
+            openAutoFocus: (event: Event) => any;
+            closeAutoFocus: (event: Event) => any;
+            }, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<DialogContentProps> & Readonly<{
+            onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+            onPointerDownOutside?: ((event: CustomEvent<{
+                originalEvent: PointerEvent;
+            }>) => any) | undefined;
+            onFocusOutside?: ((event: CustomEvent<{
+                originalEvent: FocusEvent;
+            }>) => any) | undefined;
+            onInteractOutside?: ((event: CustomEvent<{
+                originalEvent: PointerEvent;
+            }> | CustomEvent<{
+                originalEvent: FocusEvent;
+            }>) => any) | undefined;
+            onOpenAutoFocus?: ((event: Event) => any) | undefined;
+            onCloseAutoFocus?: ((event: Event) => any) | undefined;
+        }>, never> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_8(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_9(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;
+
+declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;
+
+declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;
+
+declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;
+
+declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;
+
+declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;
+
+declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;
+
+declare type __VLS_TemplateResult_17 = ReturnType<typeof __VLS_template_17>;
+
+declare type __VLS_TemplateResult_18 = ReturnType<typeof __VLS_template_18>;
+
+declare type __VLS_TemplateResult_19 = ReturnType<typeof __VLS_template_19>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_TemplateResult_20 = ReturnType<typeof __VLS_template_20>;
+
+declare type __VLS_TemplateResult_21 = ReturnType<typeof __VLS_template_21>;
+
+declare type __VLS_TemplateResult_22 = ReturnType<typeof __VLS_template_22>;
+
+declare type __VLS_TemplateResult_23 = ReturnType<typeof __VLS_template_23>;
+
+declare type __VLS_TemplateResult_24 = ReturnType<typeof __VLS_template_24>;
+
+declare type __VLS_TemplateResult_25 = ReturnType<typeof __VLS_template_25>;
+
+declare type __VLS_TemplateResult_26 = ReturnType<typeof __VLS_template_26>;
+
+declare type __VLS_TemplateResult_27 = ReturnType<typeof __VLS_template_27>;
+
+declare type __VLS_TemplateResult_28 = ReturnType<typeof __VLS_template_28>;
+
+declare type __VLS_TemplateResult_29 = ReturnType<typeof __VLS_template_29>;
+
+declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
+
+declare type __VLS_TemplateResult_30 = ReturnType<typeof __VLS_template_30>;
+
+declare type __VLS_TemplateResult_31 = ReturnType<typeof __VLS_template_31>;
+
+declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;
+
+declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
+
+declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;
+
+declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;
+
+declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;
+
+declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_10<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_11<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_12<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_13<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_14<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_15<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_16<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_17<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_18<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_19<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_20<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_21<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_22<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_23<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_24<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_25<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_26<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_27<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_28<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_29<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_3<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_30<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_31<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_4<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_6<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_7<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_8<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_9<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare type AcceptRefs<T> = {
+    [K in keyof T]: T[K] | RefUnion<T[K]>;
+};
+
+export declare const AdvancedOptions: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;
+
+export declare type AerogelGlobalEvents = Partial<{
+    [Event in EventWithoutPayload]: () => unknown;
+}> & Partial<{
+    [Event in EventWithPayload]: EventListener_2<EventsPayload[Event]>;
+}>;
+
+export declare interface AerogelOptions {
+    plugins?: Plugin_2[];
+    install?(app: App_2): void | Promise<void>;
+}
+
+export declare interface AerogelTestingRuntime {
+    on: (typeof Events)['on'];
+}
+
+export declare const AlertModal: DefineComponent<AlertModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AlertModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface AlertModalProps {
+    title?: string;
+    message: string;
+}
+
+export declare const App: Facade<AppService>;
+
+export declare const AppLayout: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const AppModals: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const AppOverlays: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare class AppService extends _default_3 {
+    readonly name: string;
+    readonly ready: PromisedValue<void>;
+    readonly mounted: PromisedValue<void>;
+    isReady(): boolean;
+    isMounted(): boolean;
+    addSetting(setting: AppSetting): void;
+    whenReady<T>(callback: () => T): Promise<T>;
+    reload(queryParameters?: Record<string, string | undefined>): Promise<void>;
+    plugin<T extends Plugin_2 = Plugin_2>(name: string): T | null;
+    service<T extends keyof Services>(name: T): Services[T] | null;
+    protected boot(): Promise<void>;
+}
+
+export declare interface AppSetting {
+    component: Component;
+    priority: number;
+}
+
+export declare const AppToasts: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare function booleanInput(defaultValue?: boolean, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Boolean>;
+
+export declare function bootServices(app: App_2, services: Record<string, Service>): Promise<void>;
+
+export declare function bootstrap(rootComponent: Component, options?: AerogelOptions): Promise<void>;
+
+export declare function bootstrapApplication(app: App_2, options?: AerogelOptions): Promise<void>;
+
+export declare const Button: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;
+
+export declare interface ButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    disabled?: boolean;
+    href?: string;
+    route?: string;
+    routeParams?: object;
+    routeQuery?: object;
+    size?: ButtonSize;
+    submit?: boolean;
+    variant?: ButtonVariant;
+}
+
+export declare type ButtonSize = 'default' | 'small' | 'large' | 'icon';
+
+export declare type ButtonVariant = 'default' | 'secondary' | 'danger' | 'ghost' | 'outline' | 'link';
+
+declare const Cache_2: Facade<CacheService>;
+export { Cache_2 as Cache }
+
+export declare class CacheService extends Service {
+    private cache?;
+    get(url: string): Promise<Response | null>;
+    store(url: string, response: Response): Promise<void>;
+    replace(url: string, response: Response): Promise<void>;
+    protected open(): Promise<Cache>;
+}
+
+export declare const Checkbox: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;
+
+export declare function classes(...inputs: ClassValue[]): string;
+
+export declare type ComponentPropDefinitions<T> = {
+    [K in keyof T]: {
+        type?: PropType<T[K]>;
+        default: T[K] | (() => T[K]) | null;
+    };
+};
+
+export declare function computedAsync<T>(getter: () => Promise<T>): Ref<T | undefined>;
+
+export declare function computedDebounce<T>(options: ComputedDebounceOptions<T>, getter: ComputedGetter<T>): ComputedRef<T>;
+
+export declare function computedDebounce<T>(getter: ComputedGetter<T>): ComputedRef<T | null>;
+
+export declare interface ComputedDebounceOptions<T> {
+    initial?: T;
+    delay?: number;
+}
+
+export declare type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
+    [K in keyof TComputedState]: (state: Unref<TState>) => TComputedState[K];
+} & ThisType<{
+    readonly [K in keyof TComputedState]: TComputedState[K];
+}>;
+
+export declare function computedVariantClasses<T>(value: RefsObject<{
+    baseClasses?: string;
+} & CVAProps<T>>, config: {
+    baseClasses?: string;
+} & CVAConfig<T>): ComputedRef<string>;
+
+export declare const ConfirmModal: DefineComponent<ConfirmModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ConfirmModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare type ConfirmModalCheckboxes = Record<string, {
+    label: string;
+    default?: boolean;
+    required?: boolean;
+}>;
+
+export declare interface ConfirmModalProps {
+    title?: string;
+    message: string;
+    acceptText?: string;
+    acceptVariant?: ButtonVariant;
+    cancelText?: string;
+    cancelVariant?: ButtonVariant;
+    checkboxes?: ConfirmModalCheckboxes;
+    actions?: Record<string, () => unknown>;
+    required?: boolean;
+}
+
+export declare type ConfirmOptions = AcceptRefs<{
+    acceptText?: string;
+    acceptVariant?: ButtonVariant;
+    cancelText?: string;
+    cancelVariant?: ButtonVariant;
+    actions?: Record<string, () => unknown>;
+    required?: boolean;
+}>;
+
+export declare interface ConfirmOptionsWithCheckboxes<T extends ConfirmModalCheckboxes = ConfirmModalCheckboxes> extends ConfirmOptions {
+    checkboxes?: T;
+}
+
+export declare type CVAConfig<T> = NonNullable<GetClosureArgs<typeof cva<T>>[1]>;
+
+export declare type CVAProps<T> = NonNullable<GetClosureArgs<GetClosureResult<typeof cva<T>>>[0]>;
+
+export declare function dateInput(defaultValue?: Date, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Date>;
+
+declare const _default: ServiceWithState<    {
+logs: ErrorReportLog[];
+startupErrors: ErrorReport[];
+}, {
+hasErrors: boolean;
+hasNewErrors: boolean;
+hasStartupErrors: boolean;
+}, Partial<{
+logs: ErrorReportLog[];
+startupErrors: ErrorReport[];
+}>>;
+
+declare const _default_2: ServiceWithState<    {
+locale: string | null;
+locales: string[];
+fallbackLocale: string;
+}, {}, Partial<{
+locale: string | null;
+locales: string[];
+fallbackLocale: string;
+}>>;
+
+declare const _default_3: ServiceWithState<    {
+plugins: Record<string, Plugin_2>;
+instance: App_2 | null;
+environment: string;
+version: string;
+sourceUrl: string | undefined;
+settings: AppSetting[];
+}, {
+development: boolean;
+staging: boolean;
+testing: boolean;
+versionName: string;
+versionUrl: string;
+}, Partial<{
+plugins: Record<string, Plugin_2>;
+instance: App_2 | null;
+environment: string;
+version: string;
+sourceUrl: string | undefined;
+settings: AppSetting[];
+}>>;
+
+declare const _default_4: ServiceWithState<    {
+modals: UIModal[];
+toasts: UIToast[];
+layout: Layout;
+}, {
+desktop: boolean;
+mobile: boolean;
+openModals: UIModal<unknown>[];
+}, Partial<{
+modals: UIModal[];
+toasts: UIToast[];
+layout: Layout;
+}>>;
+
+export declare type DefaultServices = typeof defaultServices;
+
+declare const defaultServices: {
+    $app: Facade<AppService>;
+    $events: Facade<EventsService>;
+    $storage: Facade<StorageService>;
+};
+
+export declare type DefaultServiceState = any;
+
+export declare function defineDirective(directive: Directive): Directive;
+
+export declare function defineFormValidationRule<T>(rule: string, validator: FormFieldValidator<T>): void;
+
+export declare function definePlugin<T extends Plugin_2>(plugin: T): T;
+
+export declare function defineServiceState<State extends ServiceState = ServiceState, ComputedState extends ServiceState = {}, ServiceStorage = Partial<State>>(options: {
+    name: string;
+    initialState: State | (() => State);
+    persist?: (keyof State)[];
+    watch?: StateWatchers<Service, State>;
+    computed?: ComputedStateDefinition<State, ComputedState>;
+    serialize?: (state: Partial<State>) => ServiceStorage;
+    restore?: (state: ServiceStorage) => Partial<State>;
+}): ServiceWithState<State, ComputedState, ServiceStorage>;
+
+export declare function defineServiceStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(name: Id, options: Omit<DefineStoreOptions<Id, S, G, A>, 'id'>): Store<Id, S, G, A>;
+
+export declare function defineSettings<T extends AppSetting[]>(settings: T): T;
+
+export declare function dispatch(job: Job): Promise<void>;
+
+export declare const DropdownMenu: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;
+
+export declare interface DropdownMenuExpose {
+    align?: DropdownMenuContentProps['align'];
+    side?: DropdownMenuContentProps['side'];
+    options?: DropdownMenuOptionData[];
+}
+
+export declare const DropdownMenuOption: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;
+
+export declare type DropdownMenuOptionData = {
+    label: string;
+    click: () => unknown;
+};
+
+export declare const DropdownMenuOptions: __VLS_WithTemplateSlots_22<typeof __VLS_component_22, __VLS_TemplateResult_22["slots"]>;
+
+export declare interface DropdownMenuProps {
+    align?: DropdownMenuContentProps['align'];
+    side?: DropdownMenuContentProps['side'];
+    options?: Falsifiable<DropdownMenuOptionData>[];
+}
+
+export declare const EditableContent: __VLS_WithTemplateSlots_23<typeof __VLS_component_23, __VLS_TemplateResult_23["slots"]>;
+
+export declare interface ElementSize {
+    width: number;
+    height: number;
+}
+
+export declare type ErrorHandler = (error: ErrorSource) => boolean;
+
+declare type ErrorHandler_2 = (error: ErrorSource) => string | undefined;
+
+export declare const ErrorMessage: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface ErrorReport {
+    title: string;
+    description?: string;
+    details?: string;
+    error?: Error | JSError | unknown;
+}
+
+export declare interface ErrorReportLog {
+    report: ErrorReport;
+    seen: boolean;
+    date: Date;
+}
+
+export declare const ErrorReportModal: DefineComponent<ErrorReportModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ErrorReportModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const ErrorReportModalButtons: __VLS_WithTemplateSlots_24<typeof __VLS_component_24, __VLS_TemplateResult_24["slots"]>;
+
+declare interface ErrorReportModalButtonsDefaultSlotProps {
+    id: string;
+    description: string;
+    iconComponent: Component;
+    url?: string;
+    click?(): void;
+}
+
+export declare interface ErrorReportModalProps {
+    reports: ErrorReport[];
+}
+
+export declare const ErrorReportModalTitle: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare const Errors: Facade<ErrorsService>;
+
+export declare type ErrorSource = string | Error | JSError | unknown;
+
+declare class ErrorsService extends _default {
+    forceReporting: boolean;
+    private enabled;
+    enable(): void;
+    disable(): void;
+    inspect(error: ErrorSource | ErrorReport[]): Promise<void>;
+    report(error: ErrorSource, message?: string): Promise<void>;
+    see(report: ErrorReport): void;
+    seeAll(): void;
+    private logError;
+    private createErrorReport;
+    private createStartupErrorReport;
+    private createErrorReportFromError;
+}
+
+export declare type ErrorsServices = typeof services;
+
+declare type EventListener_2<T = unknown> = (payload: T) => unknown;
+export { EventListener_2 as EventListener }
+
+declare interface EventListenerOptions_2 {
+    priority: EventListenerPriority;
+}
+export { EventListenerOptions_2 as EventListenerOptions }
+
+export declare const EventListenerPriorities: {
+    readonly Low: -256;
+    readonly Default: 0;
+    readonly High: 256;
+};
+
+export declare type EventListenerPriority = (typeof EventListenerPriorities)[keyof typeof EventListenerPriorities];
+
+export declare const Events: Facade<EventsService>;
+
+export declare interface EventsPayload {
+}
+
+export declare class EventsService extends Service {
+    private listeners;
+    protected boot(): Promise<void>;
+    emit<Event extends EventWithoutPayload>(event: Event): Promise<void>;
+    emit<Event extends EventWithPayload>(event: Event, payload: EventsPayload[Event]): Promise<void>;
+    on<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): () => void;
+    on<Event extends EventWithoutPayload>(event: Event, priority: EventListenerPriority, listener: () => unknown): () => void;
+    on<Event extends EventWithoutPayload>(event: Event, options: Partial<EventListenerOptions_2>, listener: () => unknown): () => void;
+    on<Event extends EventWithPayload>(event: Event, listener: EventListener_2<EventsPayload[Event]>): () => void | void;
+    on<Event extends EventWithPayload>(event: Event, priority: EventListenerPriority, listener: EventListener_2<EventsPayload[Event]>): () => void | void;
+    on<Event extends EventWithPayload>(event: Event, options: Partial<EventListenerOptions_2>, listener: EventListener_2<EventsPayload[Event]>): () => void | void;
+    once<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): () => void;
+    once<Event extends EventWithoutPayload>(event: Event, options: Partial<EventListenerOptions_2>, listener: () => unknown): () => void;
+    once<Event extends EventWithPayload>(event: Event, listener: EventListener_2<EventsPayload[Event]>): () => void | void;
+    once<Event extends EventWithPayload>(event: Event, options: Partial<EventListenerOptions_2>, listener: EventListener_2<EventsPayload[Event]>): () => void | void;
+    off(event: string, listener: EventListener_2): void;
+    protected registerListener(event: string, options: Partial<EventListenerOptions_2>, handler: EventListener_2): void;
+}
+
+export declare type EventWithoutPayload = {
+    [K in keyof EventsPayload]: EventsPayload[K] extends void ? K : never;
+}[keyof EventsPayload];
+
+export declare type EventWithPayload = {
+    [K in keyof EventsPayload]: EventsPayload[K] extends void ? never : K;
+}[keyof EventsPayload];
+
+export declare type Falsifiable<T> = Nullable<T> | false;
+
+export declare type FocusFormListener = (input: string) => unknown;
+
+export declare const Form: __VLS_WithTemplateSlots_25<typeof __VLS_component_25, __VLS_TemplateResult_25["slots"]>;
+
+export declare class FormController<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
+    errors: DeepReadonly<UnwrapNestedRefs<FormErrors<Fields>>>;
+    private _fields;
+    private _data;
+    private _submitted;
+    private _errors;
+    private _listeners;
+    constructor(fields: Fields);
+    get valid(): boolean;
+    get submitted(): boolean;
+    setFieldValue<T extends keyof Fields>(field: T, value: FormData_2<Fields>[T]): void;
+    getFieldValue<T extends keyof Fields>(field: T): GetFormFieldValue<Fields[T]['type']>;
+    getFieldRules<T extends keyof Fields>(field: T): string[];
+    data(): FormData_2<Fields>;
+    validate(): boolean;
+    reset(options?: {
+        keepData?: boolean;
+        keepErrors?: boolean;
+    }): void;
+    submit(): boolean;
+    on(event: 'focus', listener: FocusFormListener): () => void;
+    on(event: 'submit', listener: SubmitFormListener): () => void;
+    off(event: 'focus', listener: FocusFormListener): void;
+    off(event: 'submit', listener: SubmitFormListener): void;
+    focus(input: string): Promise<void>;
+    protected __get(property: string): unknown;
+    protected __set(property: string, value: unknown): void;
+    private getFieldErrors;
+    private getInitialData;
+    private getInitialErrors;
+    private resetData;
+    private resetErrors;
+}
+
+declare type FormData_2<T> = {
+    -readonly [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules> ? TRules extends 'required' ? GetFormFieldValue<TType> : GetFormFieldValue<TType> | null : never;
+};
+export { FormData_2 as FormData }
+
+export declare type FormErrors<T> = {
+    [k in keyof T]: string[] | null;
+};
+
+export declare interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
+    type: TType;
+    trim?: boolean;
+    default?: GetFormFieldValue<TType>;
+    rules?: TRules;
+}
+
+export declare type FormFieldDefinitions = Record<string, FormFieldDefinition>;
+
+export declare type FormFieldType = ObjectValues<typeof FormFieldTypes>;
+
+export declare const FormFieldTypes: {
+    readonly String: "string";
+    readonly Number: "number";
+    readonly Boolean: "boolean";
+    readonly Object: "object";
+    readonly Date: "date";
+};
+
+export declare type FormFieldValidator<T = unknown> = (value: T) => string | string[] | undefined;
+
+export declare type FormFieldValue = GetFormFieldValue<FormFieldType>;
+
+export declare function getCurrentLayout(): Layout;
+
+export declare function getErrorMessage(error: ErrorSource): string;
+
+export declare type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.String ? string : TType extends typeof FormFieldTypes.Number ? number : TType extends typeof FormFieldTypes.Boolean ? boolean : TType extends typeof FormFieldTypes.Object ? object : TType extends typeof FormFieldTypes.Date ? Date : never;
+
+export declare function getPiniaStore(): Pinia;
+
+export declare interface HasSelectOptionLabel {
+    label: string | (() => string);
+}
+
+export declare function hasSelectOptionLabel(option: unknown): option is HasSelectOptionLabel;
+
+export declare const HeadlessButton: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare const HeadlessInput: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare const HeadlessInputDescription: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
+
+export declare const HeadlessInputError: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const HeadlessInputInput: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+$inputRef: HTMLInputElement;
+}, HTMLInputElement>;
+
+export declare const HeadlessInputLabel: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
+
+export declare const HeadlessInputTextArea: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$textAreaRef: HTMLTextAreaElement;
+}, HTMLTextAreaElement>;
+
+export declare const HeadlessModal: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;
+
+export declare const HeadlessModalContent: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
+
+export declare const HeadlessModalDescription: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
+
+export declare const HeadlessModalOverlay: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
+
+export declare const HeadlessModalTitle: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;
+
+export declare const HeadlessSelect: <T extends Nullable<FormFieldValue>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue"> & SelectProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {
+    labelClass: any;
+    optionsClass: any;
+    align: "start" | "center" | "end" | undefined;
+    side: "top" | "right" | "bottom" | "left" | undefined;
+    value: ComputedRef<T>;
+    id: string;
+    name: ComputedRef<string | undefined>;
+    label: ComputedRef<string | undefined>;
+    description: ComputedRef<string | undefined>;
+    placeholder: ComputedRef<string>;
+    options: ComputedRef<    {
+    key: string;
+    label: string;
+    value: AcceptableValue;
+    }[] | null>;
+    selectedOption: ComputedRef<    {
+    key: string;
+    label: string;
+    value: AcceptableValue;
+    } | undefined>;
+    errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+    required: ComputedRef<boolean | undefined>;
+    update(value: T): void;
+    }>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            modelValue: T | undefined;
+            open: boolean;
+        }): any;
+    };
+    emit: (evt: "update:modelValue", value: T) => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
+export declare const HeadlessSelectLabel: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;
+
+export declare const HeadlessSelectOption: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;
+
+export declare const HeadlessSelectOptions: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;
+
+export declare const HeadlessSelectTrigger: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;
+
+export declare const HeadlessSelectValue: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;
+
+export declare const HeadlessToast: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;
+
+export declare function injectOrFail<T>(key: InjectionKey<T> | string, errorMessage?: string): T;
+
+export declare function injectReactive<T extends object>(key: InjectionKey<T> | string): UnwrapNestedRefs<T> | undefined;
+
+export declare function injectReactiveOrFail<T extends object>(key: InjectionKey<T> | string, errorMessage?: string): UnwrapNestedRefs<T>;
+
+export declare const Input: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: Nullable<FormFieldValue>) => any;
+}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+$inputRef: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: {
+readonly name?: string | undefined;
+readonly label?: string | undefined;
+readonly description?: string | undefined;
+readonly modelValue?: Nullable<FormFieldValue>;
+readonly as?: string | undefined;
+readonly "onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$attrs: {
+[x: string]: unknown;
+};
+$refs: {
+[x: string]: unknown;
+};
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: (event: "update:modelValue", value: Nullable<FormFieldValue>) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<InputProps<Nullable<FormFieldValue>> & {
+as?: string;
+}> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, {
+id: string;
+name: ComputedRef<string | undefined>;
+label: ComputedRef<string | undefined>;
+description: ComputedRef<string | undefined>;
+value: ComputedRef<Nullable<FormFieldValue>>;
+errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+required: ComputedRef<boolean | undefined>;
+update(value: Nullable<FormFieldValue>): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: Nullable<FormFieldValue>) => any;
+}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+beforeCreate?: (() => void) | (() => void)[];
+created?: (() => void) | (() => void)[];
+beforeMount?: (() => void) | (() => void)[];
+mounted?: (() => void) | (() => void)[];
+beforeUpdate?: (() => void) | (() => void)[];
+updated?: (() => void) | (() => void)[];
+activated?: (() => void) | (() => void)[];
+deactivated?: (() => void) | (() => void)[];
+beforeDestroy?: (() => void) | (() => void)[];
+beforeUnmount?: (() => void) | (() => void)[];
+destroyed?: (() => void) | (() => void)[];
+unmounted?: (() => void) | (() => void)[];
+renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+};
+$forceUpdate: () => void;
+$nextTick: typeof nextTick;
+$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & Readonly<{}> & Omit<Readonly<InputProps<Nullable<FormFieldValue>> & {
+as?: string;
+}> & Readonly<{
+"onUpdate:modelValue"?: ((value: Nullable<FormFieldValue>) => any) | undefined;
+}>, "id" | "value" | "name" | "description" | "errors" | "required" | "label" | "update"> & ShallowUnwrapRef<    {
+id: string;
+name: ComputedRef<string | undefined>;
+label: ComputedRef<string | undefined>;
+description: ComputedRef<string | undefined>;
+value: ComputedRef<Nullable<FormFieldValue>>;
+errors: Readonly<Ref<readonly string[] | null, readonly string[] | null>>;
+required: ComputedRef<boolean | undefined>;
+update(value: Nullable<FormFieldValue>): void;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+};
+}) | null;
+}, any>;
+
+export declare interface InputEmits<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> {
+    'update:modelValue': [value: T];
+}
+
+export declare interface InputExpose<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> {
+    id: string;
+    name: ComputedRef<Nullable<string>>;
+    label: ComputedRef<Nullable<string>>;
+    description: ComputedRef<Nullable<string | boolean>>;
+    value: ComputedRef<T>;
+    required: ComputedRef<Nullable<boolean>>;
+    errors: DeepReadonly<Ref<Nullable<string[]>>>;
+    update(value: T): void;
+}
+
+export declare interface InputProps<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> {
+    name?: string;
+    label?: string;
+    description?: string;
+    modelValue?: T;
+}
+
+export declare function installPlugins(plugins: Plugin_2[], ...args: GetClosureArgs<Plugin_2['install']>): Promise<void>;
+
+export declare abstract class Job<Listener extends JobListener = JobListener, Status extends JobStatus = JobStatus, SerializedStatus extends JobStatus = JobStatus> {
+    protected status: Status;
+    protected _listeners: ListenersManager<JobListener>;
+    protected _progress?: number;
+    protected _cancelled?: PromisedValue<void>;
+    protected _started: PromisedValue<void>;
+    protected _completed: PromisedValue<void>;
+    constructor();
+    start(): Promise<void>;
+    cancel(): Promise<void>;
+    serialize(): SerializedStatus;
+    get listeners(): Listeners<Listener>;
+    get progress(): number;
+    get cancelled(): boolean;
+    get started(): Promise<void>;
+    get completed(): Promise<void>;
+    protected abstract run(): Promise<void>;
+    protected getInitialStatus(): Status;
+    protected beforeStart(): void;
+    protected assertNotCancelled(): void;
+    protected calculateCurrentProgress(status?: JobStatus): number;
+    protected updateProgress(update?: (status: Status) => unknown): Promise<void>;
+    protected serializeStatus(status: Status): SerializedStatus;
+}
+
+export declare class JobCancelledError extends JSError {
+}
+
+export declare interface JobListener {
+    onUpdated?(progress: number): unknown;
+}
+
+export declare interface JobStatus {
+    completed: boolean;
+    children?: JobStatus[];
+}
+
+export declare const Lang: Facade<LangService>;
+
+export declare interface LangProvider {
+    getLocale(): string;
+    setLocale(locale: string): Promise<void>;
+    getFallbackLocale(): string;
+    setFallbackLocale(fallbackLocale: string): Promise<void>;
+    getLocales(): string[];
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
+}
+
+declare class LangService extends _default_2 {
+    private provider;
+    constructor();
+    setProvider(provider: LangProvider): Promise<void>;
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
+    getBrowserLocale(): string;
+    protected boot(): Promise<void>;
+}
+
+export declare type LangServices = typeof services_2;
+
+export declare type Layout = (typeof Layouts)[keyof typeof Layouts];
+
+export declare const Layouts: {
+    readonly Mobile: "mobile";
+    readonly Desktop: "desktop";
+};
+
+export declare const Link: __VLS_WithTemplateSlots_26<typeof __VLS_component_26, __VLS_TemplateResult_26["slots"]>;
+
+export declare const LoadingModal: DefineComponent<LoadingModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<LoadingModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface LoadingModalProps {
+    title?: string;
+    message?: string;
+    progress?: number;
+    job?: Job;
+}
+
+export declare type LoadingOptions = AcceptRefs<{
+    title?: string;
+    message?: string;
+    progress?: number;
+}>;
+
+export declare const Markdown: __VLS_WithTemplateSlots_27<typeof __VLS_component_27, __VLS_TemplateResult_27["slots"]>;
+
+export declare type MeasureDirectiveListener = (size: ElementSize) => unknown;
+
+export declare const MOBILE_BREAKPOINT = 768;
+
+export declare const Modal: __VLS_WithTemplateSlots_28<typeof __VLS_component_28, __VLS_TemplateResult_28["slots"]>;
+
+declare interface ModalComponent<Properties extends object = object, Result = unknown> {
+}
+
+export declare type ModalContentInstance = Nullable<InstanceType<typeof DialogContent>>;
+
+export declare const ModalContext: DefineComponent<__VLS_Props_16, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_16> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface ModalExpose {
+    close(result?: unknown): Promise<void>;
+    $content: ModalContentInstance;
+}
+
+declare type ModalProperties<TComponent> = TComponent extends ModalComponent<infer TProperties, unknown> ? TProperties : never;
+
+export declare interface ModalProps {
+    persistent?: boolean;
+    title?: string;
+    titleHidden?: boolean;
+    description?: string;
+    descriptionHidden?: boolean;
+}
+
+declare type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string, unknown>, infer TResult> ? TResult : never;
+
+export declare interface ModalSlots {
+    default(props: {
+        close(result?: unknown): Promise<void>;
+    }): unknown;
+}
+
+export declare function numberInput(defaultValue?: number, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Number>;
+
+export declare function onCleanMounted(operation: () => Function): void;
+
+export declare function onFormFocus(input: {
+    name: Nullable<string>;
+}, listener: () => unknown): void;
+
+export declare function persistent<T extends object>(name: string, defaults: T): UnwrapNestedRefs<T>;
+
+export declare type PickComponentProps<TValues, TDefinitions> = {
+    [K in keyof TValues]: K extends keyof TDefinitions ? TValues[K] : never;
+};
+
+declare interface Plugin_2 {
+    name?: string;
+    install(app: App_2, options: AerogelOptions): void | Promise<void>;
+}
+export { Plugin_2 as Plugin }
+
+export declare const ProgressBar: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare const PromptModal: DefineComponent<PromptModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PromptModalProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface PromptModalProps {
+    title?: string;
+    message: string;
+    label?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    acceptText?: string;
+    acceptVariant?: ButtonVariant;
+    cancelText?: string;
+    cancelVariant?: ButtonVariant;
+}
+
+export declare type PromptOptions = AcceptRefs<{
+    label?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    acceptText?: string;
+    acceptVariant?: ButtonVariant;
+    cancelText?: string;
+    cancelVariant?: ButtonVariant;
+    trim?: boolean;
+}>;
+
+export declare type RefsObject<T> = {
+    [K in keyof T]: Ref<T[K]> | T[K];
+};
+
+export declare type RefUnion<T> = T extends infer R ? Ref<R> : never;
+
+export declare function registerErrorHandler(handler: ErrorHandler_2): void;
+
+export declare function renderMarkdown(markdown: string): string;
+
+export declare function renderVNode(node: VNode | string): string;
+
+export declare type Replace<TOriginal extends Record<string, unknown>, TReplacements extends Partial<Record<keyof TOriginal, unknown>>> = {
+    [K in keyof TOriginal]: TReplacements extends Record<K, infer Replacement> ? Replacement : TOriginal[K];
+};
+
+export declare function replaceExisting<TOriginal extends Record<string, unknown>, TReplacements extends Partial<Record<keyof TOriginal, unknown>>>(original: TOriginal, replacements: TReplacements): Replace<TOriginal, TReplacements>;
+
+export declare function requiredBooleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'>;
+
+export declare function requiredDateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date>;
+
+export declare function requiredNumberInput(defaultValue?: number): FormFieldDefinition<typeof FormFieldTypes.Number, 'required'>;
+
+export declare function requiredStringInput(defaultValue?: string): FormFieldDefinition<typeof FormFieldTypes.String, 'required'>;
+
+export declare function resetPiniaStore(): Pinia;
+
+export declare function safeHtml(html: string): string;
+
+export declare const Select: <T extends Nullable<FormFieldValue>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal_2<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue"> & SelectProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<    {}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (evt: "update:modelValue", value: T) => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+
+export declare interface SelectEmits<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> extends InputEmits<T> {
+}
+
+export declare interface SelectExpose<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> extends InputExpose<T> {
+    options: ComputedRef<Nullable<SelectOptionData[]>>;
+    selectedOption: ComputedRef<Nullable<SelectOptionData>>;
+    placeholder: ComputedRef<string>;
+    labelClass?: HTMLAttributes['class'];
+    optionsClass?: HTMLAttributes['class'];
+    align?: SelectContentProps['align'];
+    side?: SelectContentProps['side'];
+}
+
+export declare const SelectLabel: __VLS_WithTemplateSlots_29<typeof __VLS_component_29, __VLS_TemplateResult_29["slots"]>;
+
+export declare const SelectOption: __VLS_WithTemplateSlots_30<typeof __VLS_component_30, __VLS_TemplateResult_30["slots"]>;
+
+export declare type SelectOptionData = {
+    key: string;
+    label: string;
+    value: AcceptableValue;
+};
+
+export declare const SelectOptions: __VLS_WithTemplateSlots_31<typeof __VLS_component_31, __VLS_TemplateResult_31["slots"]>;
+
+export declare interface SelectProps<T extends Nullable<FormFieldValue> = Nullable<FormFieldValue>> extends InputProps<T> {
+    as?: AsTag | Component;
+    options?: T[];
+    placeholder?: string;
+    renderOption?: (option: T) => string;
+    labelClass?: HTMLAttributes['class'];
+    optionsClass?: HTMLAttributes['class'];
+    align?: SelectContentProps['align'];
+    side?: SelectContentProps['side'];
+}
+
+export declare const SelectTrigger: DefineComponent<__VLS_Props_20, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_20> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare class Service<State extends ServiceState = DefaultServiceState, ComputedState extends ServiceState = {}, ServiceStorage = Partial<State>> extends MagicObject {
+    static persist: string[];
+    protected _name: string;
+    private _booted;
+    private _computedStateKeys;
+    private _watchers;
+    private _store;
+    constructor();
+    get booted(): PromisedValue<void>;
+    static<T extends typeof Service>(): T;
+    static<T extends typeof Service, K extends keyof T>(property: K): T[K];
+    launch(): Promise<void>;
+    hasPersistedState(): boolean;
+    hasState<P extends keyof State>(property: P): boolean;
+    getState(): State;
+    getState<P extends keyof State>(property: P): State[P];
+    setState<P extends keyof State>(property: P, value: State[P]): void;
+    setState(state: Partial<State>): void;
+    updatePersistedState<T extends keyof State>(key: T): void;
+    updatePersistedState<T extends keyof State>(keys: T[]): void;
+    protected __get(property: string): unknown;
+    protected __set(property: string, value: unknown): void;
+    protected onStateUpdated(update: Partial<State>, old: Partial<State>): void;
+    protected onPersistentStateUpdated(persisted: Partial<State>): void;
+    protected usesStore(): boolean;
+    protected getName(): string | null;
+    protected getInitialState(): State;
+    protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState>;
+    protected getStateWatchers(): StateWatchers<Service, State>;
+    protected serializePersistedState(state: Partial<State>): ServiceStorage;
+    protected deserializePersistedState(state: ServiceStorage): Partial<State>;
+    protected frameworkBoot(): Promise<void>;
+    protected boot(): Promise<void>;
+    protected restorePersistedState(): void;
+    protected requireStore(): Store<string, State, ComputedState, {}>;
+}
+
+export declare class ServiceBootError extends JSError {
+    constructor(serviceNamespace: string, cause: unknown);
+}
+
+export declare type ServiceConstructor<T extends Service = Service> = Constructor<T> & typeof Service;
+
+export declare interface Services extends DefaultServices {
+}
+
+declare const services: {
+    $errors: Facade<ErrorsService>;
+};
+
+declare const services_2: {
+    $lang: Facade<LangService>;
+};
+
+declare const services_3: {
+    $ui: Facade<UIService>;
+};
+
+export declare type ServiceState = Record<string, any>;
+
+export declare type ServiceWithState<State extends ServiceState = ServiceState, ComputedState extends ServiceState = {}, ServiceStorage = Partial<State>> = Constructor<Unref<State>> & Constructor<ComputedState> & Constructor<Service<Unref<State>, ComputedState, Unref<ServiceStorage>>>;
+
+export declare const SettingsModal: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const StartupCrash: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare type StateWatchers<TService extends Service, TState extends ServiceState> = {
+    [K in keyof TState]?: (this: TService, value: TState[K], oldValue: TState[K]) => unknown;
+};
+
+declare const Storage_2: Facade<StorageService>;
+export { Storage_2 as Storage }
+
+declare class StorageService extends Service {
+    purge(): Promise<void>;
+}
+
+export declare function stringInput(defaultValue?: string, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.String>;
+
+export declare type SubmitFormListener = () => unknown;
+
+export declare const Toast: DefineComponent<__VLS_Props_21, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_21> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+export declare interface ToastAction {
+    label: string;
+    dismiss?: boolean;
+    click?(): unknown;
+}
+
+export declare interface ToastOptions {
+    component?: Component;
+    variant?: ToastVariant;
+    actions?: ToastAction[];
+}
+
+export declare interface ToastProps {
+    message?: string;
+    actions?: ToastAction[];
+    variant?: ToastVariant;
+}
+
+export declare type ToastVariant = 'secondary' | 'danger';
+
+export declare const translate: (key: string, parameters?: Record<string, unknown> | number) => string;
+
+export declare const translateWithDefault: (key: string, defaultMessage: string, parameters?: Record<string, unknown> | number) => string;
+
+export declare const UI: Facade<UIService>;
+
+export declare type UIComponent = ObjectValues<typeof UIComponents>;
+
+export declare const UIComponents: {
+    readonly AlertModal: "alert-modal";
+    readonly ConfirmModal: "confirm-modal";
+    readonly ErrorReportModal: "error-report-modal";
+    readonly LoadingModal: "loading-modal";
+    readonly PromptModal: "prompt-modal";
+    readonly Toast: "toast";
+    readonly StartupCrash: "startup-crash";
+    readonly RouterLink: "router-link";
+};
+
+declare interface UIModal<T = unknown> {
+    id: string;
+    properties: Record<string, unknown>;
+    component: Component;
+    closing: boolean;
+    beforeClose: Promise<T | undefined>;
+    afterClose: Promise<T | undefined>;
+}
+
+export declare class UIService extends _default_4 {
+    private modalCallbacks;
+    private components;
+    resolveComponent(name: UIComponent): Component | null;
+    requireComponent(name: UIComponent): Component;
+    alert(message: string): void;
+    alert(title: string, message: string): void;
+    confirm(message: string, options?: ConfirmOptions): Promise<boolean>;
+    confirm(title: string, message: string, options?: ConfirmOptions): Promise<boolean>;
+    confirm<T extends ConfirmModalCheckboxes>(message: string, options?: ConfirmOptionsWithCheckboxes<T>): Promise<[boolean, Record<keyof T, boolean>]>;
+    confirm<T extends ConfirmModalCheckboxes>(title: string, message: string, options?: ConfirmOptionsWithCheckboxes<T>): Promise<[boolean, Record<keyof T, boolean>]>;
+    prompt(message: string, options?: PromptOptions): Promise<string | null>;
+    prompt(title: string, message: string, options?: PromptOptions): Promise<string | null>;
+    loading<T>(operation: Promise<T> | (() => T)): Promise<T>;
+    loading<T>(message: string, operation: Promise<T> | (() => T)): Promise<T>;
+    loading<T>(options: LoadingOptions, operation: Promise<T> | (() => T)): Promise<T>;
+    toast(message: string, options?: ToastOptions): void;
+    registerComponent(name: UIComponent, component: Component): void;
+    openModal<TModalComponent extends ModalComponent>(component: TModalComponent, properties?: ModalProperties<TModalComponent>): Promise<UIModal<ModalResult<TModalComponent>>>;
+    closeModal(id: string, result?: unknown): Promise<void>;
+    closeAllModals(): Promise<void>;
+    protected boot(): Promise<void>;
+    private removeModal;
+    private watchModalEvents;
+    private watchMountedEvent;
+    private watchViewportBreakpoints;
+}
+
+export declare type UIServices = typeof services_3;
+
+declare interface UIToast {
+    id: string;
+    component: Component;
+    properties: Record<string, unknown>;
+}
+
+export declare type Unref<T> = {
+    [K in keyof T]: T[K] extends MaybeRef<infer Value> ? Value : T[K];
+};
+
+export declare function useConfirmModal(props: ConfirmModalProps): {
+    form: FormController<    {
+    [x: string]: FormFieldDefinition<FormFieldType, string> | {
+    type: "boolean";
+    default: boolean | undefined;
+    required: string | undefined;
+    };
+    }> & FormData_2<    {
+    [x: string]: FormFieldDefinition<FormFieldType, string> | {
+    type: "boolean";
+    default: boolean | undefined;
+    required: string | undefined;
+    };
+    }>;
+    renderedAcceptText: ComputedRef<string>;
+    renderedCancelText: ComputedRef<string>;
+};
+
+export declare function useErrorReportModal(props: ErrorReportModalProps): {
+    activeReportIndex: Ref<number, number>;
+    details: ComputedRef<string>;
+    nextReportText: string;
+    previousReportText: string;
+    report: ComputedRef<ErrorReport>;
+};
+
+export declare function useEvent<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): void;
+
+export declare function useEvent<Event extends EventWithPayload>(event: Event, listener: EventListener_2<EventsPayload[Event]>): void;
+
+export declare function useForm<const T extends FormFieldDefinitions>(fields: T): FormController<T> & FormData_2<T>;
+
+export declare function useInputAttrs(): [ComputedRef<{}>, ComputedRef<ClassValue>];
+
+export declare function useLoadingModal(props: LoadingModalProps): {
+    renderedTitle: ComputedRef<string>;
+    renderedMessage: ComputedRef<string>;
+    titleHidden: ComputedRef<boolean>;
+    showProgress: ComputedRef<boolean>;
+};
+
+export declare function usePromptModal(props: PromptModalProps): {
+    form: FormController<    {
+    readonly draft: FormFieldDefinition<"string", "required">;
+    }> & FormData_2<    {
+    readonly draft: FormFieldDefinition<"string", "required">;
+    }>;
+    renderedTitle: ComputedRef<string>;
+    renderedMessage: ComputedRef<string | null>;
+    renderedAcceptText: ComputedRef<string>;
+    renderedCancelText: ComputedRef<string>;
+};
+
+export declare function validate(value: unknown, rule: string): string[];
+
+export declare const validators: Record<string, FormFieldValidator>;
+
+export declare type Variants<T extends Record<string, string | boolean>> = Required<{
+    [K in keyof T]: Exclude<T[K], undefined> extends string ? {
+        [key in Exclude<T[K], undefined>]: string | null;
+    } : {
+        true: string | null;
+        false: string | null;
+    };
+}>;
+
+export { }
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'application-ready': void;
+        'application-mounted': void;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface AerogelOptions {
+        directives?: Record<string, Directive>;
+    }
+}
+
+
+declare module 'vue' {
+    interface ComponentCustomDirectives {
+        measure: Directive<string, string>;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface AerogelOptions {
+        handleError?(error: ErrorSource): boolean;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface Services extends ErrorsServices {
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface Services extends LangServices {
+    }
+}
+
+
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $td: typeof translateWithDefault;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface AerogelOptions {
+        services?: Record<string, Service>;
+        settings?: AppSetting[];
+    }
+}
+
+
+declare module 'vue' {
+    interface ComponentCustomProperties extends Services {
+    }
+}
+
+
+declare global {
+    var testingRuntime: AerogelTestingRuntime | undefined;
+}
+
+
+declare module '@aerogel/core' {
+    interface AerogelOptions {
+        components?: Partial<Record<UIComponent, Component>>;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface Services extends UIServices {
+    }
+}
+
+
+declare global {
+    var __aerogelEvents__: AerogelGlobalEvents | undefined;
+}
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        error: {
+            error: ErrorSource;
+            message?: string;
+        };
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'purge-storage': void;
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'close-modal': {
+            id: string;
+            result?: unknown;
+        };
+        'modal-will-close': {
+            modal: UIModal;
+            result?: unknown;
+        };
+        'modal-has-closed': {
+            modal: UIModal;
+            result?: unknown;
+        };
+    }
+}