@aerogel/core 0.0.0-next.8e6b2bcc764fa682decbb41aa6848c77a744dec3 → 0.0.0-next.906ec80f260b7e5cb54a0c97bd4905bdaf4bf916

package/dist/aerogel-core.d.ts

@@ -3,7 +3,7 @@ import type { App as App_2 } from 'vue';
 import type { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComputedRef } from 'vue';
-import { Constructor } from '@noeldemartin/utils';
+import type { Constructor } from '@noeldemartin/utils';
 import type { DeepReadonly } from 'vue';
 import { DefineComponent } from 'vue';
 import type { DefineStoreOptions } from 'pinia';
@@ -13,12 +13,16 @@ 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 { JSError } from '@noeldemartin/utils';
+import type { 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 { ObjectWithout } from '@noeldemartin/utils';
 import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
 import type { Pinia } from 'pinia';
+import type { Pretty } from '@noeldemartin/utils';
 import { PromisedValue } from '@noeldemartin/utils';
 import { PropType } from 'vue';
 import { PublicProps } from 'vue';
@@ -27,10 +31,19 @@ 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 { VNode } from 'vue';
 import type { Writable } from '@noeldemartin/utils';
 
+export declare interface __SetsElement {
+    __setElement(element?: HTMLElement): void;
+}
+
+export declare type AcceptRefs<T> = {
+    [K in keyof T]: T[K] | RefUnion<T[K]>;
+};
+
 export declare type AerogelGlobalEvents = Partial<{
     [Event in EventWithoutPayload]: () => unknown;
 }> & Partial<{
@@ -78,7 +91,7 @@ required: true;
 title: string | null;
 }, {}>;
 
-export declare type AGAlertModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof alertModalProps>>;
+export declare type AGAlertModalProps = Pretty<AcceptRefs<ObjectWithout<ExtractPropTypes<typeof alertModalProps>, null | undefined>>>;
 
 export declare const AGAppLayout: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
@@ -149,12 +162,42 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+acceptColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 cancelText: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+cancelColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | 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;
+};
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
@@ -176,19 +219,54 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+acceptColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 cancelText: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+cancelColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | 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;
+};
 }>>, {
 title: string | null;
 acceptText: string | null;
+acceptColor: "primary" | "secondary" | "danger" | "clear";
 cancelText: string | null;
+cancelColor: "primary" | "secondary" | "danger" | "clear";
+checkboxes: ConfirmCheckboxes | null;
+actions: Record<string, () => unknown> | null;
+required: boolean;
 }, {}>;
 
-export declare type AGConfirmModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof confirmModalProps>>;
+export declare type AGConfirmModalProps = Pretty<AcceptRefs<SubPartial<ObjectWithout<ExtractPropTypes<typeof confirmModalProps>, null | undefined>, 'acceptColor' | 'cancelColor'>>>;
 
 export declare const AGErrorMessage: DefineComponent<    {
 error: {
@@ -226,7 +304,7 @@ required: true;
 };
 }>>, {}, {}>;
 
-export declare type AGErrorReportModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof errorReportModalProps>>;
+export declare type AGErrorReportModalProps = Pretty<AcceptRefs<ObjectWithout<ExtractPropTypes<typeof errorReportModalProps>, null | undefined>>>;
 
 export declare const AGErrorReportModalTitle: DefineComponent<    {
 report: {
@@ -296,6 +374,12 @@ form: Form<FormFieldDefinitions> | null;
 }, {}>;
 
 export declare const AGHeadlessButton: DefineComponent<    {
+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;
@@ -335,6 +419,12 @@ 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;
+validator?(value: unknown): boolean;
+} & {
+default: Object | (() => Object | null) | null;
+};
 href: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
@@ -372,6 +462,7 @@ validator?(value: unknown): boolean;
 default: boolean | (() => boolean) | null;
 };
 }>>, {
+as: Object | null;
 href: string | null;
 url: string | null;
 route: string | null;
@@ -393,17 +484,23 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-as: {
-type?: PropType<string> | undefined;
+description: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+default: string | (() => string | null) | null;
 };
 modelValue: {
-type?: PropType<string | number | boolean | null> | undefined;
+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 | number | boolean | (() => string | number | boolean | null) | null;
+default: string | (() => string) | null;
 };
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
@@ -420,27 +517,38 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
-as: {
-type?: PropType<string> | undefined;
+description: {
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string) | null;
+default: string | (() => string | null) | null;
 };
 modelValue: {
-type?: PropType<string | number | boolean | null> | undefined;
+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 | number | boolean | (() => string | number | boolean | null) | null;
+default: string | (() => string) | null;
 };
 }>> & {
 "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }, {
 as: string;
-modelValue: string | number | boolean | null;
 name: string | null;
 label: string | null;
+description: string | null;
+modelValue: FormFieldValue | null;
 }, {}>;
 
+export declare const AGHeadlessInputDescription: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
 export declare const AGHeadlessInputError: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
@@ -469,6 +577,10 @@ export declare const AGHeadlessInputLabel: DefineComponent<    {}, (_ctx: any, _
 [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;
@@ -476,6 +588,12 @@ 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;
@@ -491,6 +609,12 @@ 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;
@@ -499,6 +623,7 @@ default: string | (() => string | null) | null;
 };
 }>>, {
 cancellable: boolean;
+inline: boolean;
 title: string | null;
 }, {}>;
 
@@ -730,6 +855,18 @@ 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;
+};
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
@@ -745,9 +882,23 @@ 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;
+};
 }>>, {
 name: string | null;
 label: string | null;
+description: string | null;
+modelValue: FormFieldValue | null;
 }, {}>;
 
 export declare const AGLink: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
@@ -755,26 +906,52 @@ export declare const AGLink: DefineComponent<    {}, (_ctx: any, _cache: any) =>
 }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
 
 export declare const AGLoadingModal: DefineComponent<    {
+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;
+};
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, 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 | 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;
+};
 }>>, {
+title: string | null;
 message: string | null;
+progress: number | null;
 }, {}>;
 
-export declare type AGLoadingModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof loadingModalProps>>;
+export declare type AGLoadingModalProps = AcceptRefs<ObjectWithout<ExtractPropTypes<typeof loadingModalProps>, null | undefined>>;
 
 export declare const AGMarkdown: DefineComponent<    {
 as: {
@@ -796,10 +973,10 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 langParams: {
-type?: PropType<Record<string, unknown> | null> | undefined;
+type?: PropType<number | Record<string, unknown> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Record<string, unknown> | (() => Record<string, unknown> | null) | null;
+default: number | Record<string, unknown> | (() => number | Record<string, unknown> | null) | null;
 };
 text: {
 type?: PropType<string | null> | undefined;
@@ -807,6 +984,12 @@ 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;
+};
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
@@ -829,10 +1012,10 @@ validator?(value: unknown): boolean;
 default: string | (() => string | null) | null;
 };
 langParams: {
-type?: PropType<Record<string, unknown> | null> | undefined;
+type?: PropType<number | Record<string, unknown> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: Record<string, unknown> | (() => Record<string, unknown> | null) | null;
+default: number | Record<string, unknown> | (() => number | Record<string, unknown> | null) | null;
 };
 text: {
 type?: PropType<string | null> | undefined;
@@ -840,12 +1023,19 @@ 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;
+};
 }>>, {
 as: string | null;
 inline: boolean;
 langKey: string | null;
-langParams: Record<string, unknown> | null;
+langParams: number | Record<string, unknown> | null;
 text: string | null;
+actions: Record<string, () => unknown> | null;
 }, {}>;
 
 export declare const AGMeasured: DefineComponent<    {
@@ -875,6 +1065,12 @@ 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;
@@ -890,6 +1086,12 @@ 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;
@@ -898,6 +1100,7 @@ default: string | (() => string | null) | null;
 };
 }>>, {
 cancellable: boolean;
+inline: boolean;
 title: string | null;
 }, {}>;
 
@@ -912,7 +1115,7 @@ childIndex: {
 type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: number | (() => number) | null;
 };
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
@@ -927,14 +1130,62 @@ childIndex: {
 type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
-required: true;
+default: number | (() => number) | null;
 };
-}>>, {}, {}>;
+}>>, {
+childIndex: number;
+}, {}>;
 
 export declare const AGModalTitle: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
 
+export declare const AGProgressBar: DefineComponent<    {
+progress: {
+type?: PropType<number | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: number | (() => number | null) | null;
+};
+barClass: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string) | null;
+};
+job: {
+type?: PropType<Job<JobListener, JobStatus, JobStatus> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Job<JobListener, JobStatus, JobStatus> | (() => Job<JobListener, JobStatus, JobStatus> | null) | null;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+progress: {
+type?: PropType<number | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: number | (() => number | null) | null;
+};
+barClass: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string) | null;
+};
+job: {
+type?: PropType<Job<JobListener, JobStatus, JobStatus> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Job<JobListener, JobStatus, JobStatus> | (() => Job<JobListener, JobStatus, JobStatus> | null) | null;
+};
+}>>, {
+progress: number | null;
+barClass: string;
+job: Job<JobListener, JobStatus, JobStatus> | null;
+}, {}>;
+
 export declare const AGPromptModal: DefineComponent<    {
 title: {
 type?: PropType<string | null> | undefined;
@@ -972,12 +1223,24 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+acceptColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 cancelText: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+cancelColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
@@ -1017,22 +1280,36 @@ validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+acceptColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 cancelText: {
 type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+cancelColor: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
 }>>, {
 title: string | null;
 label: string | null;
 defaultValue: string | null;
 placeholder: string | null;
 acceptText: string | null;
+acceptColor: "primary" | "secondary" | "danger" | "clear";
 cancelText: string | null;
+cancelColor: "primary" | "secondary" | "danger" | "clear";
 }, {}>;
 
-export declare type AGPromptModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof promptModalProps>>;
+export declare type AGPromptModalProps = Pretty<AcceptRefs<SubPartial<ObjectWithout<ExtractPropTypes<typeof promptModalProps>, null | undefined>, 'acceptColor' | 'cancelColor'>>>;
 
 export declare const AGSelect: DefineComponent<    {
 name: {
@@ -1187,7 +1464,8 @@ export declare const alertModalProps: {
 
 export declare const App: Facade<AppService, AppService>;
 
-export declare class AppService extends _default_2 {
+export declare class AppService extends _default_3 {
+    readonly name: string;
     readonly ready: PromisedValue<void>;
     readonly mounted: PromisedValue<void>;
     isReady(): boolean;
@@ -1195,6 +1473,7 @@ export declare class AppService extends _default_2 {
     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>;
 }
 
@@ -1205,7 +1484,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>;
 
@@ -1215,6 +1496,17 @@ 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>;
+export { Cache_2 as Cache }
+
+export declare class CacheService extends Service {
+    private cache?;
+    get(url: string): Promise<Response | null>;
+    store(url: string, response: Response): Promise<void>;
+    replace(url: string, response: Response): Promise<void>;
+    protected open(): Promise<Cache>;
+}
+
 export declare type Color = (typeof Colors)[keyof typeof Colors];
 
 export declare const Colors: {
@@ -1231,11 +1523,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;
@@ -1255,94 +1553,148 @@ export declare const confirmModalProps: {
     } & {
         default: string | (() => string | null) | null;
     };
+    acceptColor: {
+        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+    };
     cancelText: {
         type?: PropType<string | null> | undefined;
         validator?(value: unknown): boolean;
     } & {
         default: string | (() => string | null) | null;
     };
+    cancelColor: {
+        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | 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;
+    };
 };
 
-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;
 }
 
-declare const _default: Constructor<UnrefServiceState<    {
-logs: ErrorReportLog[];
-startupErrors: ErrorReport[];
-}>> & Constructor<    {
-hasErrors: boolean;
-hasNewErrors: boolean;
-hasStartupErrors: boolean;
-}> & Constructor<Service<UnrefServiceState<    {
+export declare function dateInput(defaultValue?: Date, options?: {
+    rules?: string;
+}): FormFieldDefinition<typeof FormFieldTypes.Date>;
+
+declare const _default: ServiceWithState<    {
 logs: ErrorReportLog[];
 startupErrors: ErrorReport[];
-}>, {
+}, {
 hasErrors: boolean;
 hasNewErrors: boolean;
 hasStartupErrors: boolean;
-}, Partial<UnrefServiceState<    {
+}, Partial<{
 logs: ErrorReportLog[];
 startupErrors: ErrorReport[];
-}>>>>;
-
-declare const _default_2: Constructor<UnrefServiceState<    {
-plugins: Record<string, Plugin_2>;
-environment: string;
-sourceUrl: string | undefined;
-}>> & Constructor<    {
-development: boolean;
-testing: boolean;
-}> & Constructor<Service<UnrefServiceState<    {
+}>>;
+
+declare const _default_2: ServiceWithState<    {
+locale: string | null;
+locales: string[];
+fallbackLocale: string;
+}, {}, Partial<{
+locale: string | null;
+locales: string[];
+fallbackLocale: string;
+}>>;
+
+declare const _default_3: ServiceWithState<    {
 plugins: Record<string, Plugin_2>;
+instance: App_2<any> | null;
 environment: string;
+version: string;
 sourceUrl: string | undefined;
-}>, {
+}, {
 development: boolean;
+staging: boolean;
 testing: boolean;
-}, Partial<UnrefServiceState<    {
+versionName: string;
+versionUrl: string;
+}, Partial<{
 plugins: Record<string, Plugin_2>;
+instance: App_2<any> | null;
 environment: string;
+version: string;
 sourceUrl: string | undefined;
-}>>>>;
+}>>;
 
-declare const _default_3: Constructor<UnrefServiceState<    {
-modals: Modal<unknown>[];
-snackbars: Snackbar[];
-}>> & Constructor<    {}> & Constructor<Service<UnrefServiceState<    {
+declare const _default_4: ServiceWithState<    {
 modals: Modal<unknown>[];
 snackbars: Snackbar[];
-}>, {}, Partial<UnrefServiceState<    {
+layout: Layout;
+}, {
+mobile: boolean;
+desktop: boolean;
+}, Partial<{
 modals: Modal<unknown>[];
 snackbars: Snackbar[];
-}>>>>;
+layout: Layout;
+}>>;
 
 export declare type DefaultServices = typeof defaultServices;
 
 declare const defaultServices: {
     $app: Facade<AppService, AppService>;
     $events: Facade<EventsService, EventsService>;
+    $storage: Facade<StorageService, 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>;
 
 export declare function dispatch(job: Job): Promise<void>;
 
+export declare function elementRef(): Ref<HTMLElement | undefined>;
+
 export declare interface ElementSize {
     width: number;
     height: number;
@@ -1352,6 +1704,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;
@@ -1399,7 +1753,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 }
 
@@ -1409,6 +1763,8 @@ export declare const EventListenerPriorities: {
     readonly High: 256;
 };
 
+export declare type EventListenerPriority = (typeof EventListenerPriorities)[keyof typeof EventListenerPriorities];
+
 export declare const Events: Facade<EventsService, EventsService>;
 
 export declare interface EventsPayload {
@@ -1421,10 +1777,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;
@@ -1450,23 +1809,33 @@ export declare function extractModalProps<T extends ExtractPropTypes<typeof moda
 
 export declare function extractSelectProps<T extends ExtractPropTypes<typeof selectProps>>(props: T): Pick<T, keyof typeof selectProps>;
 
-declare class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
+export declare type FocusFormListener = (input: string) => unknown;
+
+export declare class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
     errors: DeepReadonly<UnwrapNestedRefs<FormErrors<Fields>>>;
     private _fields;
     private _data;
     private _submitted;
     private _errors;
+    private _listeners;
     constructor(fields: Fields);
     get valid(): boolean;
     get submitted(): boolean;
     setFieldValue<T extends keyof Fields>(field: T, value: FormData_2<Fields>[T]): void;
     getFieldValue<T extends keyof Fields>(field: T): GetFormFieldValue<Fields[T]['type']>;
+    getFieldRules<T extends keyof Fields>(field: T): string[];
+    data(): FormData_2<Fields>;
     validate(): boolean;
     reset(options?: {
         keepData?: boolean;
         keepErrors?: boolean;
     }): void;
     submit(): boolean;
+    on(event: 'focus', listener: FocusFormListener): () => void;
+    on(event: 'submit', listener: SubmitFormListener): () => void;
+    off(event: 'focus', listener: FocusFormListener): void;
+    off(event: 'submit', listener: SubmitFormListener): void;
+    focus(input: string): Promise<void>;
     protected __get(property: string): unknown;
     protected __set(property: string, value: unknown): void;
     private getFieldErrors;
@@ -1487,6 +1856,7 @@ export declare type FormErrors<T> = {
 
 export declare interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
     type: TType;
+    trim?: boolean;
     default?: GetFormFieldValue<TType>;
     rules?: TRules;
 }
@@ -1500,16 +1870,29 @@ export declare const FormFieldTypes: {
     readonly Number: "number";
     readonly Boolean: "boolean";
     readonly Object: "object";
+    readonly Date: "date";
 };
 
+export declare type FormFieldValidator<T = unknown> = (value: T) => string | string[] | undefined;
+
 export declare type FormFieldValue = GetFormFieldValue<FormFieldType>;
 
+export declare function getCurrentLayout(): Layout;
+
+export declare function getElement(value: unknown): HTMLElement | undefined;
+
 export declare function getErrorMessage(error: ErrorSource): string;
 
-export declare type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.String ? string : TType extends typeof FormFieldTypes.Number ? number : TType extends typeof FormFieldTypes.Boolean ? boolean : TType extends typeof FormFieldTypes.Object ? object : never;
+export declare type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.String ? string : TType extends typeof FormFieldTypes.Number ? number : TType extends typeof FormFieldTypes.Boolean ? boolean : TType extends typeof FormFieldTypes.Object ? object : TType extends typeof FormFieldTypes.Date ? Date : never;
 
 export declare function getPiniaStore(): Pinia;
 
+export declare interface HasElement {
+    $el: Readonly<Ref<HTMLElement | undefined>>;
+}
+
+export declare function hasElement(value: unknown): value is UnwrapNestedRefs<HasElement>;
+
 export declare interface IAGErrorReportModalButtonsDefaultSlotProps {
     id: string;
     description: string;
@@ -1518,13 +1901,18 @@ export declare interface IAGErrorReportModalButtonsDefaultSlotProps {
     handler?(): void;
 }
 
-export declare interface IAGHeadlessInput {
+export declare interface IAGHeadlessButton extends HasElement {
+}
+
+export declare interface IAGHeadlessInput extends HasElement {
     id: string;
     name: ComputedRef<string | null>;
     label: ComputedRef<string | null>;
-    value: ComputedRef<string | number | boolean | null>;
+    description: ComputedRef<string | boolean | null>;
+    value: ComputedRef<FormFieldValue | null>;
+    required: ComputedRef<boolean | null>;
     errors: DeepReadonly<Ref<string[] | null>>;
-    update(value: string | number | boolean | null): void;
+    update(value: FormFieldValue | null): void;
 }
 
 export declare interface IAGHeadlessModal extends IAGModal {
@@ -1552,6 +1940,7 @@ export declare type IAGHeadlessSelectOptionSlotProps = {
 };
 
 export declare interface IAGModal {
+    inline: Ref<boolean>;
     cancellable: Ref<boolean>;
     close(result?: unknown): Promise<void>;
 }
@@ -1584,44 +1973,127 @@ export declare const inputProps: {
     } & {
         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;
+    };
 };
 
 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 interface JobListener {
+    onUpdated?(progress: number): unknown;
+}
+
+export declare interface JobStatus {
+    completed: boolean;
+    children?: JobStatus[];
 }
 
 export declare const Lang: Facade<LangService, LangService>;
 
 export declare interface LangProvider {
-    translate(key: string, parameters?: Record<string, unknown>): string;
-    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown>): string;
+    getLocale(): string;
+    setLocale(locale: string): Promise<void>;
+    getFallbackLocale(): string;
+    setFallbackLocale(fallbackLocale: string): Promise<void>;
+    getLocales(): string[];
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
 }
 
-declare class LangService extends Service {
+declare class LangService extends _default_2 {
     private provider;
     constructor();
-    setProvider(provider: LangProvider): void;
-    translate(key: string, parameters?: Record<string, unknown>): string;
-    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown>): string;
+    setProvider(provider: LangProvider): Promise<void>;
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
+    getBrowserLocale(): string;
+    protected boot(): Promise<void>;
 }
 
 export declare type LangServices = typeof services_2;
 
+export declare type Layout = (typeof Layouts)[keyof typeof Layouts];
+
+export declare const Layouts: {
+    readonly Mobile: "mobile";
+    readonly Desktop: "desktop";
+};
+
+export declare 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>;
 
+export declare function mixedProp<T>(type: PropType<T>, defaultValue: T): OptionalProp<T>;
+
+export declare const MOBILE_BREAKPOINT = 768;
+
 declare interface Modal<T = unknown> {
     id: string;
     properties: Record<string, unknown>;
@@ -1642,6 +2114,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;
@@ -1652,7 +2130,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>;
 
@@ -1664,10 +2144,16 @@ export declare function objectProp<T>(defaultValue: () => T): OptionalProp<T>;
 
 export declare function onCleanMounted(operation: () => Function): void;
 
+export declare function onFormFocus(input: {
+    name: string | null;
+}, listener: () => unknown): void;
+
 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>;
@@ -1711,28 +2197,57 @@ export declare const promptModalProps: {
     } & {
         default: string | (() => string | null) | null;
     };
+    acceptColor: {
+        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+    };
     cancelText: {
         type?: PropType<string | null> | undefined;
         validator?(value: unknown): boolean;
     } & {
         default: string | (() => string | null) | null;
     };
+    cancelColor: {
+        type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+    };
 };
 
-export declare interface PromptOptions {
+export declare type PromptOptions = AcceptRefs<{
     label?: string;
     defaultValue?: string;
     placeholder?: string;
     acceptText?: string;
+    acceptColor?: Color;
     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'>;
 
+export declare function requiredDateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date>;
+
 export declare function requiredEnumProp<Enum extends Record<string, unknown>>(enumeration: Enum): RequiredProp<Enum[keyof Enum]>;
 
 export declare function requiredMixedProp<T>(type?: PropType<T>): RequiredProp<T>;
@@ -1753,6 +2268,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: {
@@ -1788,14 +2305,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;
@@ -1803,17 +2323,27 @@ 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;
@@ -1835,6 +2365,8 @@ declare const services_3: {
 
 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;
@@ -1889,15 +2421,30 @@ 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, 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>;
 
 export declare function stringProp(defaultValue: string): OptionalProp<string>;
 
-export declare const translate: (key: string, parameters?: Record<string, unknown> | undefined) => string;
+export declare type SubmitFormListener = () => unknown;
+
+export declare const translate: (key: string, parameters?: number | Record<string, unknown> | undefined) => string;
 
-export declare const translateWithDefault: (key: string, defaultMessage: string, parameters?: Record<string, unknown>) => string;
+export declare const translateWithDefault: (key: string, defaultMessage: string, parameters?: number | Record<string, unknown>) => string;
 
 export declare const UI: Facade<UIService, UIService>;
 
@@ -1913,7 +2460,7 @@ export declare const UIComponents: {
     readonly StartupCrash: "startup-crash";
 };
 
-export declare class UIService extends _default_3 {
+export declare class UIService extends _default_4 {
     private modalCallbacks;
     private components;
     requireComponent(name: UIComponent): Component;
@@ -1921,26 +2468,32 @@ export declare class UIService extends _default_3 {
     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>): Promise<T>;
-    loading<T>(message: string, operation: Promise<T>): Promise<T>;
+    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 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;
@@ -1978,6 +2531,7 @@ 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;
@@ -2003,6 +2557,10 @@ 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 {
@@ -2037,6 +2595,10 @@ declare global {
     var __aerogelEvents__: AerogelGlobalEvents | undefined;
 }
 
+    export interface EventsPayload {
+        'purge-storage': void;
+    }
+
     export interface AerogelOptions {
         services?: Record<string, Service>;
     }