@aerogel/core 0.0.0-next.d7394c3aa6aac799b0971e63819a8713d05a5123 → 0.0.0-next.eed7a057cf5b844cd9f7fc6bda2d8df49fcd6736

package/dist/aerogel-core.d.ts

@@ -1,412 +1,720 @@
 import { ListboxOptions as AGHeadlessSelectOptions } from '@headlessui/vue';
-import type { App as App_2 } from 'vue';
-import type { Component } from 'vue';
+import { AllowedComponentProps } from 'vue';
+import { App as App_2 } from 'vue';
+import { Component } from 'vue';
+import { ComponentCustomProperties } from '@vue/runtime-core';
+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 { ComputedRef } from 'vue';
 import { Constructor } from '@noeldemartin/utils';
-import type { DeepReadonly } from 'vue';
+import { DebuggerEvent } from 'vue';
+import { DeepReadonly } from 'vue';
 import { DefineComponent } from 'vue';
-import type { DefineStoreOptions } from 'pinia';
-import type { Directive } from 'vue';
+import { DefineStoreOptions } from 'pinia';
+import { Directive } from 'vue';
 import { ExtractPropTypes } from 'vue';
 import { Facade } from '@noeldemartin/utils';
-import type { GetClosureArgs } from '@noeldemartin/utils';
-import type { _GettersTree } from 'pinia';
-import type { InjectionKey } from 'vue';
-import type { JSError } from '@noeldemartin/utils';
+import { GetClosureArgs } from '@noeldemartin/utils';
+import { _GettersTree } from 'pinia';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { InjectionKey } from 'vue';
+import { JSError } from '@noeldemartin/utils';
+import { Listeners } from '@noeldemartin/utils';
+import { ListenersManager } from '@noeldemartin/utils';
 import { MagicObject } from '@noeldemartin/utils';
-import type { MaybeRef } from 'vue';
-import type { ObjectValues } from '@noeldemartin/utils';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
-import type { Pinia } from 'pinia';
+import { MaybeRef } from 'vue';
+import { nextTick } from 'vue';
+import { ObjectValues } from '@noeldemartin/utils';
+import { ObjectWithout } from '@noeldemartin/utils';
+import { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import { OnCleanup } from '@vue/reactivity';
+import { Pinia } from 'pinia';
+import { Pretty } from '@noeldemartin/utils';
 import { PromisedValue } from '@noeldemartin/utils';
 import { PropType } from 'vue';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
-import { RendererElement } from 'vue';
-import { RendererNode } from 'vue';
-import type { StateTree } from 'pinia';
-import type { Store } from 'pinia';
-import type { SubPartial } from '@noeldemartin/utils';
-import type { UnwrapNestedRefs } from 'vue';
+import { ShallowUnwrapRef } from 'vue';
+import { Slot } from 'vue';
+import { StateTree } from 'pinia';
+import { Store } from 'pinia';
+import { SubPartial } from '@noeldemartin/utils';
+import { UnwrapNestedRefs } from 'vue';
 import { VNode } from 'vue';
-import type { Writable } from '@noeldemartin/utils';
+import { VNodeProps } from 'vue';
+import { WatchOptions } from 'vue';
+import { WatchStopHandle } from 'vue';
+import { Writable } from '@noeldemartin/utils';
 
 export declare interface __SetsElement {
     __setElement(element?: HTMLElement): void;
 }
 
-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'];
-}
+declare const __VLS_component: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 
-export declare const AGAlertModal: DefineComponent<    {
-title: {
+declare const __VLS_component_10: DefineComponent<ExtractPropTypes<    {
+textClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-message: {
-type?: PropType<string> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-title: {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+textClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-message: {
-type?: PropType<string> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-}>>, {
-title: string | null;
-}, {}>;
-
-export declare type AGAlertModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof alertModalProps>>;
-
-export declare const AGAppLayout: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+}>> & Readonly<{}>, {
+textClass: string | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGAppOverlays: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+declare const __VLS_component_11: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGButton: DefineComponent<    {
-color: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+declare const __VLS_component_12: DefineComponent<ExtractPropTypes<    {
+value: {
+type?: PropType<FormFieldValue> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+required: true;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-color: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+selectedClass: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: string | (() => string | null) | null;
 };
-}>>, {
-color: "primary" | "secondary" | "danger" | "clear";
-}, {}>;
-
-export declare const AGCheckbox: DefineComponent<    {
-name: {
+unselectedClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
-name: {
+activeClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}>> & {
-"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
-name: string | null;
-}, {}>;
-
-export declare const AGConfirmModal: DefineComponent<    {
-title: {
+inactiveClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-message: {
-type?: PropType<string> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+value: {
+type?: PropType<FormFieldValue> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
-acceptText: {
+selectedClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-acceptColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+unselectedClass: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: string | (() => string | null) | null;
 };
-cancelText: {
+activeClass: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-cancelColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+inactiveClass: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-title: {
-type?: PropType<string | null> | undefined;
+}>> & Readonly<{}>, {
+selectedClass: string | null;
+unselectedClass: string | null;
+activeClass: string | null;
+inactiveClass: string | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_13: DefineComponent<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: boolean | (() => boolean) | null;
 };
-message: {
-type?: PropType<string> | undefined;
+inline: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: boolean | (() => boolean) | null;
 };
-acceptText: {
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-acceptColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+}>, {
+inline: Ref<boolean>;
+cancellable: Ref<boolean>;
+close(result?: unknown): Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: boolean | (() => boolean) | null;
 };
-cancelText: {
-type?: PropType<string | null> | undefined;
+inline: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: boolean | (() => boolean) | null;
 };
-cancelColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+title: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: string | (() => string | null) | null;
 };
-}>>, {
+}>> & Readonly<{}>, {
 title: string | null;
-acceptText: string | null;
-acceptColor: "primary" | "secondary" | "danger" | "clear";
-cancelText: string | null;
-cancelColor: "primary" | "secondary" | "danger" | "clear";
-}, {}>;
+inline: boolean;
+cancellable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$root: unknown;
+}, any>;
 
-export declare type AGConfirmModalProps = SubPartial<ObjectWithoutEmpty<ExtractPropTypes<typeof confirmModalProps>>, 'acceptColor' | 'cancelColor'>;
+declare const __VLS_component_14: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGErrorMessage: DefineComponent<    {
-error: {
-type?: PropType<unknown> | undefined;
+declare const __VLS_component_15: DefineComponent<ExtractPropTypes<    {
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: string | (() => string) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-error: {
-type?: PropType<unknown> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: string | (() => string) | null;
 };
-}>>, {}, {}>;
+}>> & Readonly<{}>, {
+as: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGErrorReportModalButtons: DefineComponent<    {
-report: {
-type?: PropType<ErrorReport> | undefined;
+declare const __VLS_component_16: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+declare const __VLS_component_17: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_18: DefineComponent<ExtractPropTypes<    {
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: string | (() => string) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-report: {
-type?: PropType<ErrorReport> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: string | (() => string) | null;
 };
-}>>, {}, {}>;
-
-export declare type AGErrorReportModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof errorReportModalProps>>;
+}>> & Readonly<{}>, {
+as: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGErrorReportModalTitle: DefineComponent<    {
+declare const __VLS_component_19: DefineComponent<ExtractPropTypes<    {
 report: {
 type?: PropType<ErrorReport> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
-currentReport: {
-type?: PropType<number | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: number | (() => number | null) | null;
-};
-totalReports: {
-type?: PropType<number | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: number | (() => number | null) | null;
-};
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
 report: {
 type?: PropType<ErrorReport> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
-currentReport: {
-type?: PropType<number | null> | undefined;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+declare const __VLS_component_2: DefineComponent<ExtractPropTypes<    {
+color: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: number | (() => number | null) | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
-totalReports: {
-type?: PropType<number | null> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+color: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: number | (() => number | null) | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
-}>>, {
-currentReport: number | null;
-totalReports: number | null;
-}, {}>;
+}>> & Readonly<{}>, {
+color: "clear" | "primary" | "secondary" | "danger";
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGForm: DefineComponent<    {
-form: {
-type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
+declare const __VLS_component_20: DefineComponent<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
+default: boolean | (() => boolean) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "submit"[], "submit", PublicProps, Readonly<ExtractPropTypes<    {
-form: {
-type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
+inline: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
+default: boolean | (() => boolean) | null;
 };
-}>> & {
-onSubmit?: ((...args: any[]) => any) | undefined;
-}, {
-form: Form<FormFieldDefinitions> | null;
-}, {}>;
-
-export declare const AGHeadlessButton: DefineComponent<    {
-as: {
-type?: PropType<Object | null> | undefined;
+title: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Object | (() => Object | null) | null;
+default: string | (() => string | null) | null;
 };
-href: {
-type?: PropType<string | null> | undefined;
+}>, {
+inline: Ref<boolean>;
+cancellable: Ref<boolean>;
+close(result?: unknown): Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: boolean | (() => boolean) | null;
 };
-url: {
-type?: PropType<string | null> | undefined;
+inline: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: boolean | (() => boolean) | null;
 };
-route: {
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-routeParams: {
-type?: PropType<    {}> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: {} | (() => {}) | null;
+}>> & Readonly<{}>, {
+title: string | null;
+inline: boolean;
+cancellable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$modal: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: Partial<{
+title: string | null;
+inline: boolean;
+cancellable: boolean;
+}> & Omit<{
+readonly title: string | null;
+readonly inline: boolean;
+readonly cancellable: boolean;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "title" | "inline" | "cancellable">;
+$attrs: {
+[x: string]: unknown;
 };
-routeQuery: {
-type?: PropType<    {}> | undefined;
-validator?(value: unknown): boolean;
+$refs: {
+[x: string]: unknown;
 } & {
-default: {} | (() => {}) | null;
+$root: unknown;
 };
-submit: {
+$slots: Readonly<{
+[name: string]: Slot<any> | undefined;
+}>;
+$root: ComponentPublicInstance | null;
+$parent: ComponentPublicInstance | null;
+$host: Element | null;
+$emit: (event: string, ...args: any[]) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+cancellable: {
 type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-as: {
-type?: PropType<Object | null> | undefined;
+inline: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Object | (() => Object | null) | null;
+default: boolean | (() => boolean) | null;
 };
-href: {
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-url: {
-type?: PropType<string | null> | undefined;
+}>> & Readonly<{}>, {
+inline: Ref<boolean>;
+cancellable: Ref<boolean>;
+close(result?: unknown): Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+title: string | null;
+inline: boolean;
+cancellable: boolean;
+}, {}, 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: 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<{
+title: string | null;
+inline: boolean;
+cancellable: boolean;
+}> & Omit<Readonly<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: boolean | (() => boolean) | null;
 };
-route: {
+inline: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-routeParams: {
-type?: PropType<    {}> | undefined;
+}>> & Readonly<{}>, "close" | ("title" | "inline" | "cancellable")> & ShallowUnwrapRef<    {
+inline: Ref<boolean>;
+cancellable: Ref<boolean>;
+close(result?: unknown): Promise<void>;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: Readonly<{
+default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+}> & {
+default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+};
+}) | null;
+}, any>;
+
+declare const __VLS_component_21: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_3: DefineComponent<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: {} | (() => {}) | null;
+default: string | (() => string | null) | null;
 };
-routeQuery: {
-type?: PropType<    {}> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: {} | (() => {}) | null;
+default: string | (() => string | null) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+name: string | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$input: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: Partial<{
+description: string | null;
+name: string | null;
+label: string | null;
+as: string;
+modelValue: FormFieldValue | null;
+}> & Omit<{
+readonly description: string | null;
+readonly name: string | null;
+readonly label: string | null;
+readonly as: string;
+readonly modelValue: FormFieldValue | null;
+readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "description" | "name" | "label" | "as" | "modelValue">;
+$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", ...args: any[]) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+label: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+description: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+as: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+id: string;
+name: ComputedRef<string | null>;
+label: ComputedRef<string | null>;
+description: ComputedRef<string | boolean | null>;
+value: ComputedRef<FormFieldValue | null>;
+required: ComputedRef<boolean | null>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue | null): void;
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, {
+description: string | null;
+name: string | null;
+label: string | null;
+as: string;
+modelValue: FormFieldValue | null;
+}, {}, 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: 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<{
+description: string | null;
+name: string | null;
+label: string | null;
+as: string;
+modelValue: FormFieldValue | null;
+}> & Omit<Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+label: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+description: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+as: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, "id" | "value" | "required" | "errors" | "$el" | "update" | ("description" | "name" | "label" | "as" | "modelValue")> & ShallowUnwrapRef<    {
+id: string;
+name: ComputedRef<string | null>;
+label: ComputedRef<string | null>;
+description: ComputedRef<string | boolean | null>;
+value: ComputedRef<FormFieldValue | null>;
+required: ComputedRef<boolean | null>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue | null): void;
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}) | null;
+}, any>;
+
+declare const __VLS_component_4: DefineComponent<ExtractPropTypes<    {
+form: {
+type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+submit: () => any;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
+form: {
+type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
+};
+}>> & Readonly<{
+onSubmit?: (() => any) | undefined;
+}>, {
+form: Form<FormFieldDefinitions> | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLFormElement>;
+
+declare const __VLS_component_5: DefineComponent<ExtractPropTypes<    {
+as: {
+type?: PropType<Object | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Object | (() => Object | null) | null;
+};
+href: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+url: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+route: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+routeParams: {
+type?: PropType<    {}> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: {} | (() => {}) | null;
+};
+routeQuery: {
+type?: PropType<    {}> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: {} | (() => {}) | null;
+};
+submit: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+}>, {
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+as: {
+type?: PropType<Object | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Object | (() => Object | null) | null;
+};
+href: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+url: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+route: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+routeParams: {
+type?: PropType<    {}> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: {} | (() => {}) | null;
+};
+routeQuery: {
+type?: PropType<    {}> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: {} | (() => {}) | null;
 };
 submit: {
 type?: PropType<boolean> | undefined;
@@ -414,7 +722,7 @@ validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
 };
-}>>, {
+}>> & Readonly<{}>, {
 as: Object | null;
 href: string | null;
 url: string | null;
@@ -422,9 +730,11 @@ route: string | null;
 routeParams: {};
 routeQuery: {};
 submit: boolean;
-}, {}>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$root: unknown;
+}, any>;
 
-export declare const AGHeadlessInput: DefineComponent<    {
+declare const __VLS_component_6: DefineComponent<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -455,9 +765,19 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
+}>, {
+id: string;
+name: ComputedRef<string | null>;
+label: ComputedRef<string | null>;
+description: ComputedRef<string | boolean | null>;
+value: ComputedRef<FormFieldValue | null>;
+required: ComputedRef<boolean | null>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue | null): void;
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -488,110 +808,1075 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
 };
-}>> & {
+}>> & Readonly<{
 "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
-as: string;
+}>, {
+description: string | null;
 name: string | null;
 label: string | null;
-description: string | null;
+as: string;
 modelValue: FormFieldValue | null;
-}, {}>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGHeadlessInputDescription: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+declare const __VLS_component_7: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGHeadlessInputError: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+declare const __VLS_component_8: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGHeadlessInputInput: DefineComponent<    {
-type: {
-type?: PropType<string> | undefined;
+declare const __VLS_component_9: DefineComponent<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-type: {
-type?: PropType<string> | undefined;
+label: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+default: string | (() => string | null) | null;
 };
-}>>, {
-type: string;
-}, {}>;
-
-export declare const AGHeadlessInputLabel: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGHeadlessInputTextArea: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGHeadlessModal: DefineComponent<    {
-cancellable: {
-type?: PropType<boolean> | undefined;
+options: {
+type?: PropType<FormFieldValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+noSelectionText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+optionsText: {
+type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+}>, {
+id: string;
+label: ComputedRef<string | null>;
+noSelectionText: ComputedRef<string>;
+buttonText: ComputedRef<string>;
+renderText: ComputedRef<(value: FormFieldValue) => string>;
+selectedOption: ComputedRef<FormFieldValue | null>;
+options: ComputedRef<FormFieldValue[]>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+label: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+options: {
+type?: PropType<FormFieldValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+noSelectionText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+optionsText: {
+type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+name: string | null;
+label: string | null;
+modelValue: FormFieldValue | null;
+noSelectionText: string | null;
+optionsText: string | ((option: FormFieldValue) => string) | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'startup-crash'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_10(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            value: unknown;
+            open: unknown;
+            disabled: unknown;
+        }): any;
+        icon?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_11(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            open: unknown;
+            disabled: unknown;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_12(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            active: unknown;
+            selected: unknown;
+            disabled: unknown;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_13(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+    }> & {
+        default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+    };
+    refs: {
+        $root: unknown;
+    };
+    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: HTMLDivElement;
+};
+
+declare function __VLS_template_17(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_18(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_19(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            key: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_20(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            close: (result?: unknown) => Promise<void>;
+        }): any;
+    };
+    refs: {
+        $modal: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                title: string | null;
+                inline: boolean;
+                cancellable: boolean;
+            }> & Omit<{
+                readonly title: string | null;
+                readonly inline: boolean;
+                readonly cancellable: boolean;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "title" | "inline" | "cancellable">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                $root: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+            cancellable: {
+            type?: PropType<boolean> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: boolean | (() => boolean) | null;
+            };
+            inline: {
+            type?: PropType<boolean> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: boolean | (() => boolean) | null;
+            };
+            title: {
+            type?: PropType<string | null> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: string | (() => string | null) | null;
+            };
+            }>> & Readonly<{}>, {
+            inline: Ref<boolean>;
+            cancellable: Ref<boolean>;
+            close(result?: unknown): Promise<void>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            title: string | null;
+            inline: boolean;
+            cancellable: boolean;
+            }, {}, 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: 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<{
+            title: string | null;
+            inline: boolean;
+            cancellable: boolean;
+        }> & Omit<Readonly<ExtractPropTypes<    {
+        cancellable: {
+        type?: PropType<boolean> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: boolean | (() => boolean) | null;
+        };
+        inline: {
+        type?: PropType<boolean> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: boolean | (() => boolean) | null;
+        };
+        title: {
+        type?: PropType<string | null> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: string | (() => string | null) | null;
+        };
+        }>> & Readonly<{}>, "close" | ("title" | "inline" | "cancellable")> & ShallowUnwrapRef<    {
+        inline: Ref<boolean>;
+        cancellable: Ref<boolean>;
+        close(result?: unknown): Promise<void>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: Readonly<{
+                default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+            }> & {
+                default(props: IAGHeadlessModalDefaultSlotProps): VNode[];
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_21(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_3(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        $input: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                description: string | null;
+                name: string | null;
+                label: string | null;
+                as: string;
+                modelValue: FormFieldValue | null;
+            }> & Omit<{
+                readonly description: string | null;
+                readonly name: string | null;
+                readonly label: string | null;
+                readonly as: string;
+                readonly modelValue: FormFieldValue | null;
+                readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "description" | "name" | "label" | "as" | "modelValue">;
+            $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", ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+            name: {
+            type?: PropType<string | null> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: string | (() => string | null) | null;
+            };
+            label: {
+            type?: PropType<string | null> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: string | (() => string | null) | null;
+            };
+            description: {
+            type?: PropType<string | null> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: string | (() => string | null) | null;
+            };
+            modelValue: {
+            type?: PropType<FormFieldValue | null> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: FormFieldValue | (() => FormFieldValue | null) | null;
+            };
+            as: {
+            type?: PropType<string> | undefined;
+            validator?(value: unknown): boolean;
+            } & {
+            default: string | (() => string) | null;
+            };
+            }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            }>, {
+            id: string;
+            name: ComputedRef<string | null>;
+            label: ComputedRef<string | null>;
+            description: ComputedRef<string | boolean | null>;
+            value: ComputedRef<FormFieldValue | null>;
+            required: ComputedRef<boolean | null>;
+            errors: DeepReadonly<Ref<string[] | null>>;
+            update(value: FormFieldValue | null): void;
+            $el: Readonly<Ref<HTMLElement | undefined>>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            "update:modelValue": (...args: any[]) => void;
+            }, string, {
+            description: string | null;
+            name: string | null;
+            label: string | null;
+            as: string;
+            modelValue: FormFieldValue | null;
+            }, {}, 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: 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<{
+            description: string | null;
+            name: string | null;
+            label: string | null;
+            as: string;
+            modelValue: FormFieldValue | null;
+        }> & Omit<Readonly<ExtractPropTypes<    {
+        name: {
+        type?: PropType<string | null> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: string | (() => string | null) | null;
+        };
+        label: {
+        type?: PropType<string | null> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: string | (() => string | null) | null;
+        };
+        description: {
+        type?: PropType<string | null> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: string | (() => string | null) | null;
+        };
+        modelValue: {
+        type?: PropType<FormFieldValue | null> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: FormFieldValue | (() => FormFieldValue | null) | null;
+        };
+        as: {
+        type?: PropType<string> | undefined;
+        validator?(value: unknown): boolean;
+        } & {
+        default: string | (() => string) | null;
+        };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        }>, "id" | "value" | "required" | "errors" | "$el" | "update" | ("description" | "name" | "label" | "as" | "modelValue")> & ShallowUnwrapRef<    {
+        id: string;
+        name: ComputedRef<string | null>;
+        label: ComputedRef<string | null>;
+        description: ComputedRef<string | boolean | null>;
+        value: ComputedRef<FormFieldValue | null>;
+        required: ComputedRef<boolean | null>;
+        errors: DeepReadonly<Ref<string[] | null>>;
+        update(value: FormFieldValue | null): void;
+        $el: Readonly<Ref<HTMLElement | undefined>>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_4(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLFormElement;
+};
+
+declare function __VLS_template_5(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        $root: unknown;
+    };
+    rootEl: any;
+};
+
+declare function __VLS_template_6(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_7(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            id: string;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_8(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_9(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            value: unknown;
+            open: unknown;
+            disabled: unknown;
+        }): 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_3 = ReturnType<typeof __VLS_template_3>;
+
+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_3<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 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 AGAlertModal: DefineComponent<ExtractPropTypes<    {
+title: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+title: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>> & Readonly<{}>, {
+title: string | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare type AGAlertModalProps = Pretty<AcceptRefs<ObjectWithout<ExtractPropTypes<typeof alertModalProps>, null | undefined>>>;
+
+export declare const AGAppLayout: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const AGAppOverlays: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$backdrop: HTMLDivElement;
+}, any>;
+
+export declare const AGButton: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare const AGCheckbox: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
+
+export declare const AGConfirmModal: DefineComponent<ExtractPropTypes<    {
+title: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+acceptText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+acceptColor: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
+};
+cancelText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+cancelColor: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
+};
+checkboxes: {
+type?: PropType<ConfirmCheckboxes | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: ConfirmCheckboxes | (() => ConfirmCheckboxes | null) | null;
+};
+actions: {
+type?: PropType<Record<string, () => unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, () => unknown> | (() => Record<string, () => unknown> | null) | null;
+};
+required: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+title: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+acceptText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+acceptColor: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
+};
+cancelText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+cancelColor: {
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
+};
+checkboxes: {
+type?: PropType<ConfirmCheckboxes | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: ConfirmCheckboxes | (() => ConfirmCheckboxes | null) | null;
+};
+actions: {
+type?: PropType<Record<string, () => unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, () => unknown> | (() => Record<string, () => unknown> | null) | null;
+};
+required: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+}>> & Readonly<{}>, {
+actions: Record<string, () => unknown> | null;
+required: boolean;
+title: string | null;
+acceptText: string | null;
+acceptColor: "clear" | "primary" | "secondary" | "danger";
+cancelText: string | null;
+cancelColor: "clear" | "primary" | "secondary" | "danger";
+checkboxes: ConfirmCheckboxes | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare type AGConfirmModalProps = Pretty<AcceptRefs<SubPartial<ObjectWithout<ExtractPropTypes<typeof confirmModalProps>, null | undefined>, 'acceptColor' | 'cancelColor'>>>;
+
+export declare const AGErrorMessage: DefineComponent<ExtractPropTypes<    {
+error: {
+type?: PropType<unknown> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+error: {
+type?: PropType<unknown> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const AGErrorReportModalButtons: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;
+
+export declare type AGErrorReportModalProps = Pretty<AcceptRefs<ObjectWithout<ExtractPropTypes<typeof errorReportModalProps>, null | undefined>>>;
+
+export declare const AGErrorReportModalTitle: DefineComponent<ExtractPropTypes<    {
+report: {
+type?: PropType<ErrorReport> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+currentReport: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: boolean | (() => boolean) | null;
+default: number | (() => number | null) | null;
 };
-title: {
-type?: PropType<string | null> | undefined;
+totalReports: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: number | (() => number | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-cancellable: {
-type?: PropType<boolean> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+report: {
+type?: PropType<ErrorReport> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: boolean | (() => boolean) | null;
+required: true;
 };
-title: {
-type?: PropType<string | null> | undefined;
+currentReport: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: number | (() => number | null) | null;
 };
-}>>, {
-cancellable: boolean;
-title: string | null;
-}, {}>;
+totalReports: {
+type?: PropType<number | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: number | (() => number | null) | null;
+};
+}>> & Readonly<{}>, {
+currentReport: number | null;
+totalReports: number | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGHeadlessModalPanel: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+export declare const AGForm: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
 
-export declare const AGHeadlessModalTitle: DefineComponent<    {
-as: {
+export declare const AGHeadlessButton: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
+
+export declare const AGHeadlessInput: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;
+
+export declare const AGHeadlessInputDescription: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
+
+export declare const AGHeadlessInputError: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const AGHeadlessInputInput: DefineComponent<ExtractPropTypes<    {
+type: {
 type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-as: {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+type: {
 type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
 };
-}>>, {
-as: string;
-}, {}>;
+}>> & Readonly<{}>, {
+type: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$input: HTMLInputElement;
+}, HTMLInputElement>;
+
+export declare const AGHeadlessInputLabel: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
+
+export declare const AGHeadlessInputTextArea: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$textArea: HTMLTextAreaElement;
+}, HTMLTextAreaElement>;
+
+export declare const AGHeadlessModal: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;
+
+export declare const AGHeadlessModalPanel: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;
+
+export declare const AGHeadlessModalTitle: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;
+
+export declare const AGHeadlessSelect: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
+
+export declare const AGHeadlessSelectButton: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;
 
-export declare const AGHeadlessSelect: DefineComponent<    {
+export declare const AGHeadlessSelectError: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const AGHeadlessSelectLabel: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;
+
+export declare const AGHeadlessSelectOption: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;
+
+export { AGHeadlessSelectOptions }
+
+export declare const AGHeadlessSnackbar: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;
+
+export declare const AGInput: DefineComponent<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -604,33 +1889,21 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-options: {
-type?: PropType<FormFieldValue[]> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-noSelectionText: {
+description: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-optionsText: {
-type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
-};
 modelValue: {
 type?: PropType<FormFieldValue | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: FormFieldValue | (() => FormFieldValue | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ["update:modelValue"], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -643,146 +1916,135 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-options: {
-type?: PropType<FormFieldValue[]> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-noSelectionText: {
+description: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-optionsText: {
-type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
-};
 modelValue: {
 type?: PropType<FormFieldValue | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: FormFieldValue | (() => FormFieldValue | null) | null;
 };
-}>> & {
+}>> & Readonly<{
 "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
+description: string | null;
+name: string | null;
+label: string | null;
 modelValue: FormFieldValue | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$input: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: Partial<{
+description: string | null;
 name: string | null;
 label: string | null;
-noSelectionText: string | null;
-optionsText: string | ((option: FormFieldValue) => string) | null;
-}, {}>;
-
-export declare const AGHeadlessSelectButton: DefineComponent<    {
-textClass: {
-type?: PropType<string | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | (() => string | null) | null;
-};
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-textClass: {
-type?: PropType<string | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | (() => string | null) | null;
-};
-}>>, {
-textClass: string | null;
-}, {}>;
-
-export declare const AGHeadlessSelectError: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGHeadlessSelectLabel: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGHeadlessSelectOption: DefineComponent<    {
-value: {
-type?: PropType<FormFieldValue> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-selectedClass: {
-type?: PropType<string | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | (() => string | null) | null;
-};
-unselectedClass: {
-type?: PropType<string | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | (() => string | null) | null;
-};
-activeClass: {
-type?: PropType<string | null> | undefined;
-validator?(value: unknown): boolean;
-} & {
-default: string | (() => string | null) | null;
-};
-inactiveClass: {
+as: string;
+modelValue: FormFieldValue | null;
+}> & Omit<{
+readonly description: string | null;
+readonly name: string | null;
+readonly label: string | null;
+readonly as: string;
+readonly modelValue: FormFieldValue | null;
+readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "description" | "name" | "label" | "as" | "modelValue">;
+$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", ...args: any[]) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-value: {
-type?: PropType<FormFieldValue> | undefined;
-validator?(value: unknown): boolean;
-} & {
-required: true;
-};
-selectedClass: {
+label: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-unselectedClass: {
+description: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-activeClass: {
-type?: PropType<string | null> | undefined;
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: FormFieldValue | (() => FormFieldValue | null) | null;
 };
-inactiveClass: {
-type?: PropType<string | null> | undefined;
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | (() => string) | null;
 };
-}>>, {
-selectedClass: string | null;
-unselectedClass: string | null;
-activeClass: string | null;
-inactiveClass: string | null;
-}, {}>;
-
-export { AGHeadlessSelectOptions }
-
-export declare const AGHeadlessSnackbar: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGInput: DefineComponent<    {
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+id: string;
+name: ComputedRef<string | null>;
+label: ComputedRef<string | null>;
+description: ComputedRef<string | boolean | null>;
+value: ComputedRef<FormFieldValue | null>;
+required: ComputedRef<boolean | null>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue | null): void;
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, {
+description: string | null;
+name: string | null;
+label: string | null;
+as: string;
+modelValue: FormFieldValue | null;
+}, {}, 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: 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<{
+description: string | null;
+name: string | null;
+label: string | null;
+as: string;
+modelValue: FormFieldValue | null;
+}> & Omit<Readonly<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -807,67 +2069,81 @@ validator?(value: unknown): boolean;
 } & {
 default: FormFieldValue | (() => FormFieldValue | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-name: {
-type?: PropType<string | null> | undefined;
+as: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | (() => string) | null;
 };
-label: {
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, "id" | "value" | "required" | "errors" | "$el" | "update" | ("description" | "name" | "label" | "as" | "modelValue")> & ShallowUnwrapRef<    {
+id: string;
+name: ComputedRef<string | null>;
+label: ComputedRef<string | null>;
+description: ComputedRef<string | boolean | null>;
+value: ComputedRef<FormFieldValue | null>;
+required: ComputedRef<boolean | null>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue | null): void;
+$el: Readonly<Ref<HTMLElement | undefined>>;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {}): any;
+default?(_: {}): any;
+};
+}) | null;
+}, any>;
+
+export declare const AGLink: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;
+
+export declare const AGLoadingModal: DefineComponent<ExtractPropTypes<    {
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-description: {
+message: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-modelValue: {
-type?: PropType<FormFieldValue | null> | undefined;
+progress: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: FormFieldValue | (() => FormFieldValue | null) | null;
+default: number | (() => number | null) | null;
 };
-}>>, {
-name: string | null;
-label: string | null;
-description: string | null;
-modelValue: FormFieldValue | null;
-}, {}>;
-
-export declare const AGLink: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
-
-export declare const AGLoadingModal: DefineComponent<    {
-message: {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
 message: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}>>, {
+progress: {
+type?: PropType<number | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: number | (() => number | null) | null;
+};
+}>> & Readonly<{}>, {
+progress: number | null;
+title: string | null;
 message: string | null;
-}, {}>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare type AGLoadingModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof loadingModalProps>>;
+export declare type AGLoadingModalProps = AcceptRefs<ObjectWithout<ExtractPropTypes<typeof loadingModalProps>, null | undefined>>;
 
-export declare const AGMarkdown: DefineComponent<    {
+export declare const AGMarkdown: DefineComponent<ExtractPropTypes<    {
 as: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -898,9 +2174,13 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+actions: {
+type?: PropType<Record<string, () => unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, () => unknown> | (() => Record<string, () => unknown> | null) | null;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
 as: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -931,102 +2211,102 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-}>>, {
+actions: {
+type?: PropType<Record<string, () => unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, () => unknown> | (() => Record<string, () => unknown> | null) | null;
+};
+}>> & Readonly<{}>, {
+actions: Record<string, () => unknown> | null;
+text: string | null;
 as: string | null;
 inline: boolean;
 langKey: string | null;
 langParams: number | Record<string, unknown> | null;
-text: string | null;
-}, {}>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AGMeasured: DefineComponent<    {
-as: {
-type?: PropType<string> | undefined;
+export declare const AGMeasured: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;
+
+export declare const AGModal: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;
+
+export declare const AGModalContext: DefineComponent<ExtractPropTypes<    {
+modal: {
+type?: PropType<Modal<unknown>> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+required: true;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-as: {
-type?: PropType<string> | undefined;
+childIndex: {
+type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+default: number | (() => number) | null;
 };
-}>>, {
-as: string;
-}, {}>;
-
-export declare const AGModal: DefineComponent<    {
-cancellable: {
-type?: PropType<boolean> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+modal: {
+type?: PropType<Modal<unknown>> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: boolean | (() => boolean) | null;
+required: true;
 };
-title: {
-type?: PropType<string | null> | undefined;
+childIndex: {
+type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: number | (() => number) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-cancellable: {
-type?: PropType<boolean> | undefined;
+}>> & Readonly<{}>, {
+childIndex: number;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare const AGModalTitle: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;
+
+export declare const AGProgressBar: DefineComponent<ExtractPropTypes<    {
+progress: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: boolean | (() => boolean) | null;
+default: number | (() => number | null) | null;
 };
-title: {
-type?: PropType<string | null> | undefined;
+barClass: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | (() => string) | null;
 };
-}>>, {
-cancellable: boolean;
-title: string | null;
-}, {}>;
-
-export declare const AGModalContext: DefineComponent<    {
-modal: {
-type?: PropType<Modal<unknown>> | undefined;
+job: {
+type?: PropType<Job<JobListener, JobStatus, JobStatus> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: Job<JobListener, JobStatus, JobStatus> | (() => Job<JobListener, JobStatus, JobStatus> | null) | null;
 };
-childIndex: {
-type?: PropType<number> | undefined;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+progress: {
+type?: PropType<number | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: number | (() => number | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
-modal: {
-type?: PropType<Modal<unknown>> | undefined;
+barClass: {
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: string | (() => string) | null;
 };
-childIndex: {
-type?: PropType<number> | undefined;
+job: {
+type?: PropType<Job<JobListener, JobStatus, JobStatus> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: Job<JobListener, JobStatus, JobStatus> | (() => Job<JobListener, JobStatus, JobStatus> | null) | null;
 };
-}>>, {}, {}>;
-
-export declare const AGModalTitle: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+}>> & Readonly<{}>, {
+progress: number | null;
+barClass: string;
+job: Job<JobListener, JobStatus, JobStatus> | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 
-export declare const AGPromptModal: DefineComponent<    {
+export declare const AGPromptModal: DefineComponent<ExtractPropTypes<    {
 title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -1064,10 +2344,10 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 acceptColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
 cancelText: {
 type?: PropType<string | null> | undefined;
@@ -1076,14 +2356,12 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 cancelColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
 title: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -1121,10 +2399,10 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 acceptColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
 cancelText: {
 type?: PropType<string | null> | undefined;
@@ -1133,25 +2411,25 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 cancelColor: {
-type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
 };
-}>>, {
-title: string | null;
+}>> & Readonly<{}>, {
 label: string | null;
+title: string | null;
 defaultValue: string | null;
-placeholder: string | null;
 acceptText: string | null;
-acceptColor: "primary" | "secondary" | "danger" | "clear";
+acceptColor: "clear" | "primary" | "secondary" | "danger";
 cancelText: string | null;
-cancelColor: "primary" | "secondary" | "danger" | "clear";
-}, {}>;
+cancelColor: "clear" | "primary" | "secondary" | "danger";
+placeholder: string | null;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare type AGPromptModalProps = SubPartial<ObjectWithoutEmpty<ExtractPropTypes<typeof promptModalProps>>, 'acceptColor' | 'cancelColor'>;
+export declare type AGPromptModalProps = Pretty<AcceptRefs<SubPartial<ObjectWithout<ExtractPropTypes<typeof promptModalProps>, null | undefined>, 'acceptColor' | 'cancelColor'>>>;
 
-export declare const AGSelect: DefineComponent<    {
+export declare const AGSelect: DefineComponent<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -1182,9 +2460,9 @@ validator?(value: unknown): boolean;
 } & {
 default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ["update:modelValue"], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly<ExtractPropTypes<    {
 name: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -1215,16 +2493,190 @@ validator?(value: unknown): boolean;
 } & {
 default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
 };
-}>> & {
+}>> & Readonly<{
 "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
 name: string | null;
 label: string | null;
 noSelectionText: string | null;
 optionsText: string | ((option: FormFieldValue) => string) | null;
-}, {}>;
-
-export declare const AGSnackbar: DefineComponent<    {
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+$select: ({
+$: ComponentInternalInstance;
+$data: {};
+$props: Partial<{
+name: string | null;
+label: string | null;
+modelValue: FormFieldValue | null;
+noSelectionText: string | null;
+optionsText: string | ((option: FormFieldValue) => string) | null;
+}> & Omit<{
+readonly name: string | null;
+readonly label: string | null;
+readonly modelValue: FormFieldValue | null;
+readonly options: FormFieldValue[];
+readonly noSelectionText: string | null;
+readonly optionsText: string | ((option: FormFieldValue) => string) | null;
+readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "name" | "label" | "modelValue" | "noSelectionText" | "optionsText">;
+$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", ...args: any[]) => void;
+$el: any;
+$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+label: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+options: {
+type?: PropType<FormFieldValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+noSelectionText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+optionsText: {
+type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+id: string;
+label: ComputedRef<string | null>;
+noSelectionText: ComputedRef<string>;
+buttonText: ComputedRef<string>;
+renderText: ComputedRef<(value: FormFieldValue) => string>;
+selectedOption: ComputedRef<FormFieldValue | null>;
+options: ComputedRef<FormFieldValue[]>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (...args: any[]) => void;
+}, string, {
+name: string | null;
+label: string | null;
+modelValue: FormFieldValue | null;
+noSelectionText: string | null;
+optionsText: string | ((option: FormFieldValue) => string) | null;
+}, {}, 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: 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<{
+name: string | null;
+label: string | null;
+modelValue: FormFieldValue | null;
+noSelectionText: string | null;
+optionsText: string | ((option: FormFieldValue) => string) | null;
+}> & Omit<Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+label: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+options: {
+type?: PropType<FormFieldValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+noSelectionText: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+optionsText: {
+type?: PropType<string | ((option: FormFieldValue) => string) | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | ((option: FormFieldValue) => string) | (() => string | ((option: FormFieldValue) => string) | null) | null;
+};
+modelValue: {
+type?: PropType<FormFieldValue | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: FormFieldValue | (() => FormFieldValue | null) | null;
+};
+}>> & Readonly<{
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, "id" | "errors" | "update" | "options" | "selectedOption" | "buttonText" | "renderText" | ("name" | "label" | "modelValue" | "noSelectionText" | "optionsText")> & ShallowUnwrapRef<    {
+id: string;
+label: ComputedRef<string | null>;
+noSelectionText: ComputedRef<string>;
+buttonText: ComputedRef<string>;
+renderText: ComputedRef<(value: FormFieldValue) => string>;
+selectedOption: ComputedRef<FormFieldValue | null>;
+options: ComputedRef<FormFieldValue[]>;
+errors: DeepReadonly<Ref<string[] | null>>;
+update(value: FormFieldValue): void;
+}> & {} & ComponentCustomProperties & {} & {
+$slots: {
+default?(_: {
+value: unknown;
+open: unknown;
+disabled: unknown;
+}): any;
+};
+}) | null;
+}, any>;
+
+export declare const AGSnackbar: DefineComponent<ExtractPropTypes<    {
 id: {
 type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
@@ -1249,9 +2701,7 @@ validator?(value: unknown): boolean;
 } & {
 default: "secondary" | "danger" | (() => "secondary" | "danger") | null;
 };
-}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
 id: {
 type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
@@ -1276,16 +2726,14 @@ validator?(value: unknown): boolean;
 } & {
 default: "secondary" | "danger" | (() => "secondary" | "danger") | null;
 };
-}>>, {
+}>> & Readonly<{}>, {
 actions: SnackbarAction[];
 color: "secondary" | "danger";
-}, {}>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 
 export declare type AGSnackbarProps = ObjectWithoutEmpty<ExtractPropTypes<typeof snackbarProps>>;
 
-export declare const AGStartupCrash: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+export declare const AGStartupCrash: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 
 export declare const alertModalProps: {
     title: {
@@ -1302,7 +2750,7 @@ export declare const alertModalProps: {
     };
 };
 
-export declare const App: Facade<AppService, AppService>;
+export declare const App: Facade<AppService>;
 
 export declare class AppService extends _default_3 {
     readonly name: string;
@@ -1313,6 +2761,7 @@ export declare class AppService extends _default_3 {
     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>;
 }
 
@@ -1323,7 +2772,9 @@ declare type BaseProp<T> = {
     validator?(value: unknown): boolean;
 };
 
-export declare function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean>;
+export declare function booleanInput(defaultValue?: boolean, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Boolean>;
 
 export declare function booleanProp(defaultValue?: boolean): OptionalProp<boolean>;
 
@@ -1333,7 +2784,7 @@ export declare function bootstrap(rootComponent: Component, options?: AerogelOpt
 
 export declare function bootstrapApplication(app: App_2, options?: AerogelOptions): Promise<void>;
 
-declare const Cache_2: Facade<CacheService, CacheService>;
+declare const Cache_2: Facade<CacheService>;
 export { Cache_2 as Cache }
 
 export declare class CacheService extends Service {
@@ -1360,11 +2811,17 @@ export declare function componentRef<T>(): Ref<UnwrapNestedRefs<T> | undefined>;
 export declare function computedAsync<T>(getter: () => Promise<T>): Ref<T | undefined>;
 
 export declare type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
-    [K in keyof TComputedState]: (state: UnrefServiceState<TState>) => TComputedState[K];
+    [K in keyof TComputedState]: (state: Unref<TState>) => TComputedState[K];
 } & ThisType<{
     readonly [K in keyof TComputedState]: TComputedState[K];
 }>;
 
+export declare type ConfirmCheckboxes = Record<string, {
+    label: string;
+    default?: boolean;
+    required?: boolean;
+}>;
+
 export declare const confirmModalProps: {
     title: {
         type?: PropType<string | null> | undefined;
@@ -1385,10 +2842,10 @@ export declare const confirmModalProps: {
         default: string | (() => string | null) | null;
     };
     acceptColor: {
-        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
         validator?(value: unknown): boolean;
     } & {
-        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+        default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
     };
     cancelText: {
         type?: PropType<string | null> | undefined;
@@ -1397,122 +2854,128 @@ export declare const confirmModalProps: {
         default: string | (() => string | null) | null;
     };
     cancelColor: {
-        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
+    };
+    checkboxes: {
+        type?: PropType<ConfirmCheckboxes | null> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: ConfirmCheckboxes | (() => ConfirmCheckboxes | null) | null;
+    };
+    actions: {
+        type?: PropType<Record<string, () => unknown> | null> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: Record<string, () => unknown> | (() => Record<string, () => unknown> | null) | null;
+    };
+    required: {
+        type?: PropType<boolean> | undefined;
         validator?(value: unknown): boolean;
     } & {
-        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+        default: boolean | (() => boolean) | null;
     };
 };
 
-export declare interface ConfirmOptions {
+export declare type ConfirmOptions = AcceptRefs<{
     acceptText?: string;
     acceptColor?: Color;
     cancelText?: string;
     cancelColor?: Color;
+    actions?: Record<string, () => unknown>;
+    required?: boolean;
+}>;
+
+export declare interface ConfirmOptionsWithCheckboxes<T extends ConfirmCheckboxes = ConfirmCheckboxes> extends ConfirmOptions {
+    checkboxes?: T;
 }
 
-export declare function dateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date>;
+export declare function dateInput(defaultValue?: Date, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Date>;
 
-declare const _default: Constructor<UnrefServiceState<    {
-logs: ErrorReportLog[];
-startupErrors: ErrorReport[];
-}>> & Constructor<    {
-hasErrors: boolean;
-hasNewErrors: boolean;
-hasStartupErrors: boolean;
-}> & Constructor<Service<UnrefServiceState<    {
+declare const _default: ServiceWithState<    {
 logs: ErrorReportLog[];
 startupErrors: ErrorReport[];
-}>, {
+}, {
 hasErrors: boolean;
 hasNewErrors: boolean;
 hasStartupErrors: boolean;
-}, Partial<UnrefServiceState<    {
+}, Partial<{
 logs: ErrorReportLog[];
 startupErrors: ErrorReport[];
-}>>>>;
+}>>;
 
-declare const _default_2: Constructor<UnrefServiceState<    {
-locale: string | null;
-locales: string[];
-fallbackLocale: string;
-}>> & Constructor<    {}> & Constructor<Service<UnrefServiceState<    {
+declare const _default_2: ServiceWithState<    {
 locale: string | null;
 locales: string[];
 fallbackLocale: string;
-}>, {}, Partial<UnrefServiceState<    {
+}, {}, Partial<{
 locale: string | null;
 locales: string[];
 fallbackLocale: string;
-}>>>>;
+}>>;
 
-declare const _default_3: Constructor<UnrefServiceState<    {
+declare const _default_3: ServiceWithState<    {
 plugins: Record<string, Plugin_2>;
+instance: App_2 | null;
 environment: string;
 version: string;
 sourceUrl: string | undefined;
-}>> & Constructor<    {
-development: boolean;
-testing: boolean;
-versionName: string;
-versionUrl: string;
-}> & Constructor<Service<UnrefServiceState<    {
-plugins: Record<string, Plugin_2>;
-environment: string;
-version: string;
-sourceUrl: string | undefined;
-}>, {
+}, {
 development: boolean;
+staging: boolean;
 testing: boolean;
 versionName: string;
 versionUrl: string;
-}, Partial<UnrefServiceState<    {
+}, Partial<{
 plugins: Record<string, Plugin_2>;
+instance: App_2 | null;
 environment: string;
 version: string;
 sourceUrl: string | undefined;
-}>>>>;
+}>>;
 
-declare const _default_4: Constructor<UnrefServiceState<    {
-modals: Modal<unknown>[];
-snackbars: Snackbar[];
-layout: Layout;
-}>> & Constructor<    {
-mobile: boolean;
-desktop: boolean;
-}> & Constructor<Service<UnrefServiceState<    {
-modals: Modal<unknown>[];
+declare const _default_4: ServiceWithState<    {
+modals: Modal[];
 snackbars: Snackbar[];
 layout: Layout;
-}>, {
+}, {
 mobile: boolean;
 desktop: boolean;
-}, Partial<UnrefServiceState<    {
-modals: Modal<unknown>[];
+}, Partial<{
+modals: Modal[];
 snackbars: Snackbar[];
 layout: Layout;
-}>>>>;
+}>>;
 
 export declare type DefaultServices = typeof defaultServices;
 
 declare const defaultServices: {
-    $app: Facade<AppService, AppService>;
-    $events: Facade<EventsService, EventsService>;
+    $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 = {}>(options: {
+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>) => Partial<State>;
-}): Constructor<UnrefServiceState<State>> & Constructor<ComputedState> & Constructor<Service<UnrefServiceState<State>, ComputedState, Partial<UnrefServiceState<State>>>>;
+    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>;
 
@@ -1529,6 +2992,8 @@ export declare function enumProp<Enum extends Record<string, unknown>>(enumerati
 
 export declare type ErrorHandler = (error: ErrorSource) => boolean;
 
+declare type ErrorHandler_2 = (error: ErrorSource) => string | undefined;
+
 export declare interface ErrorReport {
     title: string;
     description?: string;
@@ -1551,7 +3016,7 @@ export declare const errorReportModalProps: {
     };
 };
 
-export declare const Errors: Facade<ErrorsService, ErrorsService>;
+export declare const Errors: Facade<ErrorsService>;
 
 export declare type ErrorSource = string | Error | JSError | unknown;
 
@@ -1576,7 +3041,7 @@ declare type EventListener_2<T = unknown> = (payload: T) => unknown;
 export { EventListener_2 as EventListener }
 
 declare interface EventListenerOptions_2 {
-    priority: number;
+    priority: EventListenerPriority;
 }
 export { EventListenerOptions_2 as EventListenerOptions }
 
@@ -1586,7 +3051,9 @@ export declare const EventListenerPriorities: {
     readonly High: 256;
 };
 
-export declare const Events: Facade<EventsService, EventsService>;
+export declare type EventListenerPriority = (typeof EventListenerPriorities)[keyof typeof EventListenerPriorities];
+
+export declare const Events: Facade<EventsService>;
 
 export declare interface EventsPayload {
 }
@@ -1598,10 +3065,13 @@ export declare class EventsService extends Service {
     emit<Event extends EventWithPayload>(event: Event, payload: EventsPayload[Event]): Promise<void>;
     emit<Event extends string>(event: UnknownEvent<Event>, payload?: unknown): 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;
     on<Event extends string>(event: UnknownEvent<Event>, listener: EventListener_2): () => void;
+    on<Event extends string>(event: UnknownEvent<Event>, priority: EventListenerPriority, listener: EventListener_2): () => void;
     on<Event extends string>(event: UnknownEvent<Event>, options: Partial<EventListenerOptions_2>, listener: EventListener_2): () => void;
     once<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): () => void;
     once<Event extends EventWithoutPayload>(event: Event, options: Partial<EventListenerOptions_2>, listener: () => unknown): () => void;
@@ -1691,6 +3161,8 @@ export declare const FormFieldTypes: {
     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;
@@ -1756,6 +3228,7 @@ export declare type IAGHeadlessSelectOptionSlotProps = {
 };
 
 export declare interface IAGModal {
+    inline: Ref<boolean>;
     cancellable: Ref<boolean>;
     close(result?: unknown): Promise<void>;
 }
@@ -1775,6 +3248,8 @@ export declare function injectReactive<T extends object>(key: InjectionKey<T> |
 
 export declare function injectReactiveOrFail<T extends object>(key: InjectionKey<T> | string, errorMessage?: string): UnwrapNestedRefs<T>;
 
+export declare const inputEmits: readonly ["update:modelValue"];
+
 export declare const inputProps: {
     name: {
         type?: PropType<string | null> | undefined;
@@ -1804,11 +3279,44 @@ export declare const inputProps: {
 
 export declare function installPlugins(plugins: Plugin_2[], ...args: GetClosureArgs<Plugin_2['install']>): Promise<void>;
 
-export declare abstract class Job {
-    abstract run(): 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 const Lang: Facade<LangService, LangService>;
+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;
@@ -1839,15 +3347,35 @@ export declare const Layouts: {
     readonly Desktop: "desktop";
 };
 
+export declare function listenerProp<T extends Function = Function>(): OptionalProp<T | null>;
+
 export declare const loadingModalProps: {
+    title: {
+        type?: PropType<string | null> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: string | (() => string | null) | null;
+    };
     message: {
         type?: PropType<string | null> | undefined;
         validator?(value: unknown): boolean;
     } & {
         default: string | (() => string | null) | null;
     };
+    progress: {
+        type?: PropType<number | null> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: number | (() => number | null) | null;
+    };
 };
 
+export declare type LoadingOptions = AcceptRefs<{
+    title?: string;
+    message?: string;
+    progress?: number;
+}>;
+
 export declare type MeasureDirectiveListener = (size: ElementSize) => unknown;
 
 export declare function mixedProp<T>(type?: PropType<T>): OptionalProp<T | null>;
@@ -1876,6 +3404,12 @@ export declare const modalProps: {
     } & {
         default: boolean | (() => boolean) | null;
     };
+    inline: {
+        type?: PropType<boolean> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: boolean | (() => boolean) | null;
+    };
     title: {
         type?: PropType<string | null> | undefined;
         validator?(value: unknown): boolean;
@@ -1886,7 +3420,9 @@ export declare const modalProps: {
 
 declare type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string, unknown>, infer TResult> ? TResult : never;
 
-export declare function numberInput(defaultValue?: number): FormFieldDefinition<typeof FormFieldTypes.Number>;
+export declare function numberInput(defaultValue?: number, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Number>;
 
 export declare function numberProp(): OptionalProp<number | null>;
 
@@ -1906,6 +3442,8 @@ declare type OptionalProp<T> = BaseProp<T> & {
     default: T | (() => T) | null;
 };
 
+export declare function persistent<T extends object>(name: string, defaults: T): UnwrapNestedRefs<T>;
+
 declare interface Plugin_2 {
     name?: string;
     install(app: App_2, options: AerogelOptions): void | Promise<void>;
@@ -1950,10 +3488,10 @@ export declare const promptModalProps: {
         default: string | (() => string | null) | null;
     };
     acceptColor: {
-        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
         validator?(value: unknown): boolean;
     } & {
-        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+        default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
     };
     cancelText: {
         type?: PropType<string | null> | undefined;
@@ -1962,14 +3500,14 @@ export declare const promptModalProps: {
         default: string | (() => string | null) | null;
     };
     cancelColor: {
-        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        type?: PropType<"clear" | "primary" | "secondary" | "danger"> | undefined;
         validator?(value: unknown): boolean;
     } & {
-        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+        default: "clear" | "primary" | "secondary" | "danger" | (() => "clear" | "primary" | "secondary" | "danger") | null;
     };
 };
 
-export declare interface PromptOptions {
+export declare type PromptOptions = AcceptRefs<{
     label?: string;
     defaultValue?: string;
     placeholder?: string;
@@ -1978,10 +3516,22 @@ export declare interface PromptOptions {
     cancelText?: string;
     cancelColor?: Color;
     trim?: boolean;
-}
+}>;
+
+export declare type RefUnion<T> = T extends infer R ? Ref<R> : never;
+
+export declare function registerErrorHandler(handler: ErrorHandler_2): void;
 
 export declare function removeInteractiveClasses(classes: string): string;
 
+export declare function renderMarkdown(markdown: 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 requiredArrayProp<T>(): RequiredProp<T[]>;
 
 export declare function requiredBooleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'>;
@@ -2008,6 +3558,8 @@ export declare function requiredStringProp(): RequiredProp<string>;
 
 export declare function resetPiniaStore(): Pinia;
 
+export declare function safeHtml(html: string): string;
+
 export declare const selectEmits: readonly ["update:modelValue"];
 
 export declare const selectProps: {
@@ -2043,14 +3595,17 @@ export declare const selectProps: {
     };
 };
 
-export declare class Service<State extends ServiceState = DefaultServiceState, ComputedState extends ServiceState = {}, ServiceStorage extends Partial<State> = Partial<State>> extends MagicObject {
+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;
@@ -2058,39 +3613,50 @@ export declare class Service<State extends ServiceState = DefaultServiceState, C
     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(state: Partial<State>): 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 serializePersistedState(state: Partial<State>): Partial<State>;
+    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 initializePersistedState(): 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, ErrorsService>;
+    $errors: Facade<ErrorsService>;
 };
 
 declare const services_2: {
-    $lang: Facade<LangService, LangService>;
+    $lang: Facade<LangService>;
 };
 
 declare const services_3: {
-    $ui: Facade<UIService, UIService>;
+    $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 interface ShowSnackbarOptions {
     component?: Component;
     color?: SnackbarColor;
@@ -2145,7 +3711,20 @@ export declare const snackbarProps: {
     };
 };
 
-export declare function stringInput(defaultValue?: string): FormFieldDefinition<typeof FormFieldTypes.String>;
+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 function stringProp(): OptionalProp<string | null>;
 
@@ -2153,11 +3732,11 @@ export declare function stringProp(defaultValue: string): OptionalProp<string>;
 
 export declare type SubmitFormListener = () => unknown;
 
-export declare const translate: (key: string, parameters?: number | Record<string, unknown> | undefined) => string;
+export declare const translate: (key: string, parameters?: Record<string, unknown> | number) => string;
 
-export declare const translateWithDefault: (key: string, defaultMessage: string, parameters?: number | Record<string, unknown>) => string;
+export declare const translateWithDefault: (key: string, defaultMessage: string, parameters?: Record<string, unknown> | number) => string;
 
-export declare const UI: Facade<UIService, UIService>;
+export declare const UI: Facade<UIService>;
 
 export declare type UIComponent = ObjectValues<typeof UIComponents>;
 
@@ -2179,27 +3758,32 @@ export declare class UIService extends _default_4 {
     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 ConfirmCheckboxes>(message: string, options?: ConfirmOptionsWithCheckboxes<T>): Promise<[boolean, Record<keyof T, boolean>]>;
+    confirm<T extends ConfirmCheckboxes>(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>;
     showSnackbar(message: string, options?: ShowSnackbarOptions): void;
     hideSnackbar(id: string): void;
     registerComponent(name: UIComponent, component: Component): void;
     openModal<TModalComponent extends ModalComponent>(component: TModalComponent, properties?: ModalProperties<TModalComponent>): Promise<Modal<ModalResult<TModalComponent>>>;
     closeModal(id: string, result?: unknown): Promise<void>;
+    closeAllModals(): Promise<void>;
     protected boot(): Promise<void>;
+    private removeModal;
     private watchModalEvents;
     private watchMountedEvent;
-    private watchWindowMedia;
+    private watchViewportBreakpoints;
 }
 
 export declare type UIServices = typeof services_3;
 
 export declare type UnknownEvent<T> = T extends keyof EventsPayload ? never : T;
 
-export declare type UnrefServiceState<State extends ServiceState> = {
-    [K in keyof State]: State[K] extends MaybeRef<infer T> ? T : State[K];
+export declare type Unref<T> = {
+    [K in keyof T]: T[K] extends MaybeRef<infer Value> ? Value : T[K];
 };
 
 export declare function useAlertModalProps(): typeof alertModalProps;
@@ -2212,7 +3796,7 @@ export declare function useConfirmModal(props: ExtractPropTypes<typeof confirmMo
 export declare function useConfirmModalProps(): typeof confirmModalProps;
 
 export declare function useErrorReportModal(props: ExtractPropTypes<typeof errorReportModalProps>): {
-    activeReportIndex: Ref<number>;
+    activeReportIndex: Ref<number, number>;
     details: ComputedRef<string>;
     nextReportText: string;
     previousReportText: string;
@@ -2233,10 +3817,13 @@ export declare function useForm<const T extends FormFieldDefinitions>(fields: T)
 
 export declare function useInputAttrs(): [ComputedRef<{}>, ComputedRef<unknown>];
 
+export declare function useInputEmits(): Writable<typeof inputEmits>;
+
 export declare function useInputProps(): typeof inputProps;
 
 export declare function useLoadingModal(props: ExtractPropTypes<typeof loadingModalProps>): {
     renderedMessage: ComputedRef<string>;
+    showProgress: ComputedRef<boolean>;
 };
 
 export declare function useLoadingModalProps(): typeof loadingModalProps;
@@ -2262,28 +3849,46 @@ export declare function useSnackbar(props: ExtractPropTypes<typeof snackbarProps
 
 export declare function useSnackbarProps(): typeof snackbarProps;
 
+export declare function validate(value: unknown, rule: string): string[];
+
+export declare const validators: Record<string, FormFieldValidator>;
+
 export { }
 
-    export interface EventsPayload {
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
         'application-ready': void;
         'application-mounted': void;
     }
+}
 
-    export interface AerogelOptions {
+
+declare module '@aerogel/core' {
+    interface AerogelOptions {
         directives?: Record<string, Directive>;
     }
+}
 
-    export interface EventsPayload {
-        error: { error: ErrorSource; message?: string };
-    }
 
-    export interface AerogelOptions {
+declare module '@aerogel/core' {
+    interface AerogelOptions {
         handleError?(error: ErrorSource): boolean;
     }
+}
+
+
+declare module '@aerogel/core' {
+    interface Services extends ErrorsServices {
+    }
+}
 
-    export interface Services extends ErrorsServices {}
 
-    export interface Services extends LangServices {}
+declare module '@aerogel/core' {
+    interface Services extends LangServices {
+    }
+}
+
 
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties {
@@ -2291,36 +3896,81 @@ declare module '@vue/runtime-core' {
     }
 }
 
-declare global {
-    // eslint-disable-next-line no-var
-    var __aerogelEvents__: AerogelGlobalEvents | undefined;
-}
 
-    export interface AerogelOptions {
+declare module '@aerogel/core' {
+    interface AerogelOptions {
         services?: Record<string, Service>;
     }
+}
+
 
 declare module '@vue/runtime-core' {
-    interface ComponentCustomProperties extends Services {}
+    interface ComponentCustomProperties extends Services {
+    }
 }
 
+
 declare global {
-    // eslint-disable-next-line no-var
     var testingRuntime: AerogelTestingRuntime | undefined;
 }
 
-    export interface EventsPayload {
-        'close-modal': { id: string; result?: unknown };
-        'hide-modal': { id: string };
-        'hide-overlays-backdrop': void;
-        'modal-closed': { modal: Modal; result?: unknown };
-        'modal-will-close': { modal: Modal; result?: unknown };
-        'show-modal': { id: string };
-        'show-overlays-backdrop': void;
-    }
 
-    export interface AerogelOptions {
+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;
+    }
+}
+
 
-    export interface Services extends UIServices {}
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'close-modal': {
+            id: string;
+            result?: unknown;
+        };
+        'hide-modal': {
+            id: string;
+        };
+        'hide-overlays-backdrop': void;
+        'modal-closed': {
+            modal: Modal;
+            result?: unknown;
+        };
+        'modal-will-close': {
+            modal: Modal;
+            result?: unknown;
+        };
+        'show-modal': {
+            id: string;
+        };
+        'show-overlays-backdrop': void;
+    }
+}