@aerogel/core 0.0.0-next.7f6ed5a1f91688a86bf5ede2adc465e4fd6cfdea → 0.0.0-next.88c59e62f64db70aedfbc4c31b5bbc287be44483

package/dist/aerogel-core.d.ts

@@ -1,16 +1,22 @@
+import { ListboxButton as AGHeadlessSelectButton } from '@headlessui/vue';
+import { ListboxLabel as AGHeadlessSelectLabel } from '@headlessui/vue';
+import { ListboxOption as AGHeadlessSelectOption } from '@headlessui/vue';
+import { ListboxOptions as AGHeadlessSelectOptions } from '@headlessui/vue';
 import { AllowedComponentProps } from 'vue';
-import type { App } from 'vue';
+import type { App as App_2 } from 'vue';
 import type { Component } from 'vue';
 import { ComponentCustomProps } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
+import type { ComputedRef } from 'vue';
 import { Constructor } from '@noeldemartin/utils';
 import type { DeepReadonly } from 'vue';
 import { DefineComponent } from 'vue';
 import type { Directive } from 'vue';
 import { ExtractPropTypes } from 'vue';
 import { Facade } from '@noeldemartin/utils';
+import type { GetClosureArgs } from '@noeldemartin/utils';
 import type { InjectionKey } from 'vue';
-import type { LocationQuery } from 'vue-router';
+import type { JSError } from '@noeldemartin/utils';
 import { MagicObject } from '@noeldemartin/utils';
 import type { ObjectValues } from '@noeldemartin/utils';
 import { PromisedValue } from '@noeldemartin/utils';
@@ -18,22 +24,210 @@ import { PropType } from 'vue';
 import type { Ref } from 'vue';
 import { RendererElement } from 'vue';
 import { RendererNode } from 'vue';
-import type { RouteParams } from 'vue-router';
 import type { UnwrapNestedRefs } from 'vue';
 import { VNode } from 'vue';
 import { VNodeProps } from 'vue';
 
+declare interface AerogelOptions {
+    plugins?: Plugin_2[];
+}
+
+export declare const AGAlertModal: DefineComponent<    {
+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;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, 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;
+};
+}>>, {
+title: string | null;
+}, {}>;
+
 export declare const AGAppLayout: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
 
-export declare const AGButton: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+export declare const AGAppOverlays: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
 
+export declare const AGButton: DefineComponent<    {
+color: {
+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, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+color: {
+type?: PropType<"primary" | "secondary" | "danger" | "clear"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "primary" | "secondary" | "danger" | "clear" | (() => "primary" | "secondary" | "danger" | "clear") | null;
+};
+}>>, {
+color: "primary" | "secondary" | "danger" | "clear";
+}, {}>;
+
+export declare const AGCheckbox: DefineComponent<    {
+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, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+}>>, {
+name: string | null;
+}, {}>;
+
+export declare const AGConfirmModal: DefineComponent<    {
+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;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, 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;
+};
+}>>, {
+title: string | null;
+}, {}>;
+
+export declare const AGErrorMessage: DefineComponent<    {
+error: {
+type?: PropType<unknown> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+error: {
+type?: PropType<unknown> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>>, {}, {}>;
+
+export declare const AGErrorReportModalButtons: DefineComponent<    {
+report: {
+type?: PropType<ErrorReport> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+report: {
+type?: PropType<ErrorReport> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>>, {}, {}>;
+
+export declare const AGErrorReportModalTitle: DefineComponent<    {
+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, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<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;
+};
+}>>, {
+currentReport: number | null;
+totalReports: number | null;
+}, {}>;
+
 export declare const AGForm: DefineComponent<    {
 form: {
-type: PropType<Form<FormFieldDefinitions> | null>;
+type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
@@ -42,7 +236,7 @@ default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null)
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "submit"[], "submit", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 form: {
-type: PropType<Form<FormFieldDefinitions> | null>;
+type?: PropType<Form<FormFieldDefinitions> | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: Form<FormFieldDefinitions> | (() => Form<FormFieldDefinitions> | null) | null;
@@ -54,32 +248,38 @@ form: Form<FormFieldDefinitions> | null;
 }, {}>;
 
 export declare const AGHeadlessButton: DefineComponent<    {
+href: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
 url: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 route: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 routeParams: {
-type: PropType<RouteParams>;
+type?: PropType<    {}> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: RouteParams | (() => RouteParams) | null;
+default: {} | (() => {}) | null;
 };
 routeQuery: {
-type: PropType<LocationQuery>;
+type?: PropType<    {}> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: LocationQuery | (() => LocationQuery) | null;
+default: {} | (() => {}) | null;
 };
 submit: {
-type: PropType<boolean>;
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
@@ -87,95 +287,130 @@ default: boolean | (() => boolean) | null;
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+href: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
 url: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 route: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 routeParams: {
-type: PropType<RouteParams>;
+type?: PropType<    {}> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: RouteParams | (() => RouteParams) | null;
+default: {} | (() => {}) | null;
 };
 routeQuery: {
-type: PropType<LocationQuery>;
+type?: PropType<    {}> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: LocationQuery | (() => LocationQuery) | null;
+default: {} | (() => {}) | null;
 };
 submit: {
-type: PropType<boolean>;
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
 };
 }>>, {
+href: string | null;
 url: string | null;
 route: string | null;
-routeParams: RouteParams;
-routeQuery: LocationQuery;
+routeParams: {};
+routeQuery: {};
 submit: boolean;
 }, {}>;
 
 export declare const AGHeadlessInput: DefineComponent<    {
 as: {
-type: PropType<string | null>;
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | (() => string) | null;
 };
 name: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 modelValue: {
-type: PropType<string | null>;
+type?: PropType<string | number | boolean | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | number | boolean | (() => string | number | boolean | null) | null;
 };
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 as: {
-type: PropType<string | null>;
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | (() => string) | null;
 };
 name: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 modelValue: {
-type: PropType<string | null>;
+type?: PropType<string | number | boolean | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
-default: string | (() => string | null) | null;
+default: string | number | boolean | (() => string | number | boolean | null) | null;
 };
 }>> & {
 "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }, {
-as: string | null;
+as: string;
 name: string | null;
-modelValue: string | null;
+modelValue: string | number | boolean | null;
 }, {}>;
 
+export declare const AGHeadlessInputError: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
+export declare const AGHeadlessInputInput: DefineComponent<    {
+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, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+type: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string) | null;
+};
+}>>, {
+type: string;
+}, {}>;
+
+export declare const AGHeadlessInputLabel: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
 export declare const AGHeadlessModal: DefineComponent<    {
 cancellable: {
-type: PropType<boolean>;
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
@@ -184,7 +419,7 @@ default: boolean | (() => boolean) | null;
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 cancellable: {
-type: PropType<boolean>;
+type?: PropType<boolean> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: boolean | (() => boolean) | null;
@@ -199,7 +434,7 @@ export declare const AGHeadlessModalPanel: DefineComponent<    {}, (_ctx: any, _
 
 export declare const AGHeadlessModalTitle: DefineComponent<    {
 as: {
-type: PropType<string>;
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
@@ -208,7 +443,7 @@ default: string | (() => string) | null;
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 as: {
-type: PropType<string>;
+type?: PropType<string> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string) | null;
@@ -217,9 +452,68 @@ default: string | (() => string) | null;
 as: string;
 }, {}>;
 
+export declare const AGHeadlessSelect: DefineComponent<    {
+options: {
+type?: PropType<SelectOptionValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+modelValue: {
+type?: PropType<SelectOptionValue> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: SelectOptionValue | (() => SelectOptionValue);
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+options: {
+type?: PropType<SelectOptionValue[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+name: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+modelValue: {
+type?: PropType<SelectOptionValue> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: SelectOptionValue | (() => SelectOptionValue);
+};
+}>> & {
+"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+name: string | null;
+modelValue: SelectOptionValue;
+}, {}>;
+
+export { AGHeadlessSelectButton }
+
+export { AGHeadlessSelectLabel }
+
+export { AGHeadlessSelectOption }
+
+export { AGHeadlessSelectOptions }
+
+export declare const AGHeadlessSnackbar: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
 export declare const AGInput: DefineComponent<    {
 name: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
@@ -228,7 +522,7 @@ default: string | (() => string | null) | null;
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 name: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
@@ -237,15 +531,57 @@ default: string | (() => string | null) | null;
 name: string | null;
 }, {}>;
 
+export declare const AGLink: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
+export declare const AGLoadingModal: DefineComponent<    {
+message: {
+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, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+message: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+}>>, {
+message: string | null;
+}, {}>;
+
 export declare const AGMarkdown: DefineComponent<    {
+as: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+inline: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
 langKey: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+langParams: {
+type?: PropType<Record<string, unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, unknown> | (() => Record<string, unknown> | null) | null;
+};
 text: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
@@ -253,36 +589,73 @@ default: string | (() => string | null) | null;
 }, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+as: {
+type?: PropType<string | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: string | (() => string | null) | null;
+};
+inline: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
 langKey: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
+langParams: {
+type?: PropType<Record<string, unknown> | null> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: Record<string, unknown> | (() => Record<string, unknown> | null) | null;
+};
 text: {
-type: PropType<string | null>;
+type?: PropType<string | null> | undefined;
 validator?(value: unknown): boolean;
 } & {
 default: string | (() => string | null) | null;
 };
 }>>, {
+as: string | null;
+inline: boolean;
 langKey: string | null;
+langParams: Record<string, unknown> | null;
 text: string | null;
 }, {}>;
 
-export declare const AGModal: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+export declare const AGModal: DefineComponent<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
 [key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+cancellable: {
+type?: PropType<boolean> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: boolean | (() => boolean) | null;
+};
+}>>, {
+cancellable: boolean;
+}, {}>;
 
 export declare const AGModalContext: DefineComponent<    {
 modal: {
-type: PropType<Modal<unknown>>;
+type?: PropType<Modal<unknown>> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
 childIndex: {
-type: PropType<number>;
+type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
@@ -291,59 +664,247 @@ required: true;
 [key: string]: any;
 }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
 modal: {
-type: PropType<Modal<unknown>>;
+type?: PropType<Modal<unknown>> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
 childIndex: {
-type: PropType<number>;
+type?: PropType<number> | undefined;
 validator?(value: unknown): boolean;
 } & {
 required: true;
 };
 }>>, {}, {}>;
 
+export declare const AGModalTitle: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+
+export declare const AGSnackbar: DefineComponent<    {
+id: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+actions: {
+type?: PropType<SnackbarAction[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: SnackbarAction[] | (() => SnackbarAction[]) | null;
+};
+color: {
+type?: PropType<"secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "secondary" | "danger" | (() => "secondary" | "danger") | null;
+};
+}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
+[key: string]: any;
+}>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {
+id: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+message: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+actions: {
+type?: PropType<SnackbarAction[]> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: SnackbarAction[] | (() => SnackbarAction[]) | null;
+};
+color: {
+type?: PropType<"secondary" | "danger"> | undefined;
+validator?(value: unknown): boolean;
+} & {
+default: "secondary" | "danger" | (() => "secondary" | "danger") | null;
+};
+}>>, {
+actions: SnackbarAction[];
+color: "secondary" | "danger";
+}, {}>;
+
+export declare const App: Facade<AppService, Constructor<AppService>>;
+
+export declare class AppService extends _default_2 {
+    plugin<T extends Plugin_2 = Plugin_2>(name: string): T | null;
+    protected boot(): Promise<void>;
+}
+
 export declare function arrayProp<T>(defaultValue?: () => T[]): OptionalProp<T[]>;
 
 declare type BaseProp<T> = {
-    type: PropType<T>;
+    type?: PropType<T>;
     validator?(value: unknown): boolean;
 };
 
+export declare function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean>;
+
 export declare function booleanProp(defaultValue?: boolean): OptionalProp<boolean>;
 
-export declare function bootServices(app: App, services: Record<string, Service>): Promise<void>;
+export declare function bootServices(app: App_2, services: Record<string, Service>): Promise<void>;
 
-export declare function bootstrapApplication(rootComponent: Component, options?: BootstrapOptions): Promise<void>;
+export declare function bootstrapApplication(rootComponent: Component, options?: AerogelOptions): Promise<void>;
 
-declare interface BootstrapOptions {
-}
+export declare type Color = (typeof Colors)[keyof typeof Colors];
+
+export declare const Colors: {
+    readonly Primary: "primary";
+    readonly Secondary: "secondary";
+    readonly Danger: "danger";
+    readonly Clear: "clear";
+};
+
+export declare type ComponentProps = Record<string, unknown>;
 
 export declare function componentRef<T>(): Ref<UnwrapNestedRefs<T> | undefined>;
 
-declare const _default: Constructor<State> & Constructor<Service<DefaultServiceState>> & Service;
+export declare type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
+    [K in keyof TComputedState]: (state: TState) => TComputedState[K];
+} & ThisType<{
+    readonly [K in keyof TComputedState]: TComputedState[K];
+}>;
+
+declare const _default: Constructor<    {
+logs: ErrorReportLog[];
+startupErrors: ErrorReport[];
+}> & Constructor<    {
+hasErrors: boolean;
+hasNewErrors: boolean;
+hasStartupErrors: boolean;
+}> & Constructor<Service<    {
+logs: ErrorReportLog[];
+startupErrors: ErrorReport[];
+}, {
+hasErrors: boolean;
+hasNewErrors: boolean;
+hasStartupErrors: boolean;
+}, Partial<{
+logs: ErrorReportLog[];
+startupErrors: ErrorReport[];
+}>>>;
+
+declare const _default_2: Constructor<    {
+plugins: Record<string, Plugin_2>;
+environment: "production" | "development" | "testing";
+sourceUrl: string | undefined;
+isMounted: boolean;
+}> & Constructor<    {
+development: boolean;
+testing: boolean;
+}> & Constructor<Service<    {
+plugins: Record<string, Plugin_2>;
+environment: "production" | "development" | "testing";
+sourceUrl: string | undefined;
+isMounted: boolean;
+}, {
+development: boolean;
+testing: boolean;
+}, Partial<{
+plugins: Record<string, Plugin_2>;
+environment: "production" | "development" | "testing";
+sourceUrl: string | undefined;
+isMounted: boolean;
+}>>>;
+
+declare const _default_3: Constructor<    {
+modals: Modal<unknown>[];
+snackbars: Snackbar[];
+}> & Constructor<    {}> & Constructor<Service<    {
+modals: Modal<unknown>[];
+snackbars: Snackbar[];
+}, {}, Partial<{
+modals: Modal<unknown>[];
+snackbars: Snackbar[];
+}>>>;
 
 export declare type DefaultServices = typeof defaultServices;
 
 declare const defaultServices: {
-    $events: Facade<EventsService>;
+    $app: Facade<AppService, Constructor<AppService>>;
+    $events: Facade<EventsService, Constructor<EventsService>>;
 };
 
-export declare type DefaultServiceState = {};
+export declare type DefaultServiceState = any;
 
 export declare function defineDirective(directive: Directive): Directive;
 
-export declare function defineServiceState<State extends ServiceState>(options: {
+export declare function definePlugin<T extends Plugin_2>(plugin: T): T;
+
+export declare function defineServiceState<State extends ServiceState = ServiceState, ComputedState extends ServiceState = {}>(options: {
+    name: string;
     initialState: State;
-}): Constructor<State> & ServiceConstructor;
+    persist?: (keyof State)[];
+    computed?: ComputedStateDefinition<State, ComputedState>;
+    serialize?: (state: Partial<State>) => Partial<State>;
+}): Constructor<State> & Constructor<ComputedState> & Constructor<Service<State, ComputedState, Partial<State>>>;
 
 export declare function enumProp<Enum extends Record<string, unknown>>(enumeration: Enum, defaultValue?: Enum[keyof Enum]): OptionalProp<Enum[keyof Enum]>;
 
+export declare type ErrorHandler = (error: ErrorSource) => boolean;
+
+export declare interface ErrorReport {
+    title: string;
+    description?: string;
+    details?: string;
+    error?: Error | JSError | unknown;
+}
+
+export declare interface ErrorReportLog {
+    report: ErrorReport;
+    seen: boolean;
+    date: Date;
+}
+
+export declare const errorReportModalProps: {
+    reports: {
+        type?: PropType<ErrorReport[]> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        required: true;
+    };
+};
+
+export declare const Errors: Facade<ErrorsService, Constructor<ErrorsService>>;
+
+export declare type ErrorSource = string | Error | JSError | unknown;
+
+declare class ErrorsService extends _default {
+    forceReporting: boolean;
+    private enabled;
+    enable(): void;
+    disable(): void;
+    inspect(error: ErrorSource | ErrorReport[]): Promise<void>;
+    report(error: ErrorSource, message?: string): Promise<void>;
+    see(report: ErrorReport): void;
+    seeAll(): void;
+    getErrorMessage(error: ErrorSource): string;
+    private logError;
+    private createErrorReport;
+    private createStartupErrorReport;
+    private createErrorReportFromError;
+}
+
+export declare type ErrorsServices = typeof services;
+
 declare type EventListener_2<T = unknown> = (payload: T) => unknown;
 export { EventListener_2 as EventListener }
 
-export declare const Events: Facade<EventsService>;
+export declare const Events: Facade<EventsService, Constructor<EventsService>>;
 
 export declare interface EventsPayload {
 }
@@ -370,6 +931,8 @@ export declare type EventWithPayload = {
     [K in keyof EventsPayload]: EventsPayload[K] extends void ? never : K;
 }[keyof EventsPayload];
 
+export declare function extractSelectProps<T extends Record<keyof typeof selectProps, unknown>>(componentProps: T): Pick<T, keyof typeof selectProps>;
+
 declare class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
     errors: DeepReadonly<UnwrapNestedRefs<FormErrors<Fields>>>;
     private _fields;
@@ -383,16 +946,22 @@ declare class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> e
     setFieldValue<T extends keyof Fields>(field: T, value: FormData_2<Fields>[T]): void;
     getFieldValue<T extends keyof Fields>(field: T): GetFormFieldValue<Fields[T]['type']>;
     validate(): boolean;
+    reset(options?: {
+        keepData?: boolean;
+        keepErrors?: boolean;
+    }): void;
     submit(): boolean;
     protected __get(property: string): unknown;
     protected __set(property: string, value: unknown): void;
     private getFieldErrors;
     private getInitialData;
     private getInitialErrors;
+    private resetData;
+    private resetErrors;
 }
 
 declare type FormData_2<T> = {
-    [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules> ? TRules extends 'required' ? GetFormFieldValue<TType> : GetFormFieldValue<TType> | null : never;
+    -readonly [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules> ? TRules extends 'required' ? GetFormFieldValue<TType> : GetFormFieldValue<TType> | null : never;
 };
 export { FormData_2 as FormData }
 
@@ -413,45 +982,81 @@ export declare type FormFieldType = ObjectValues<typeof FormFieldTypes>;
 export declare const FormFieldTypes: {
     readonly String: "string";
     readonly Number: "number";
+    readonly Boolean: "boolean";
+    readonly Object: "object";
 };
 
-export declare type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.String ? string : TType extends typeof FormFieldTypes.Number ? number : 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 : never;
+
+export declare interface IAGErrorReportModalButtonsDefaultSlotProps {
+    id: string;
+    description: string;
+    iconComponent: Component;
+    url?: string;
+    handler?(): void;
+}
+
+export declare interface IAGHeadlessInput {
+    id: string;
+    value: ComputedRef<string | number | boolean | null>;
+    errors: DeepReadonly<Ref<string[] | null>>;
+    update(value: string | number | boolean | null): void;
+}
 
 export declare interface IAGHeadlessModal extends IAGModal {
 }
 
+export declare interface IAGHeadlessSelect {
+    value: ComputedRef<SelectOptionValue | undefined>;
+    options: SelectOptionValue[];
+    update(value: string | number | boolean | null): void;
+}
+
+export declare type IAGHeadlessSelectOptionSlotProps = {
+    active: boolean;
+    selected: boolean;
+};
+
 export declare interface IAGModal {
     cancellable: Ref<boolean>;
     close(): Promise<void>;
 }
 
+export declare interface IAGModalContext {
+    modal: Ref<Modal>;
+    childIndex: Ref<number>;
+}
+
+export declare interface IAGModalSlotProps {
+    close(result?: unknown): Promise<void>;
+}
+
 export declare function injectOrFail<T>(key: InjectionKey<T> | string, errorMessage?: string): T;
 
 export declare function injectReactive<T extends object>(key: InjectionKey<T> | string): UnwrapNestedRefs<T> | undefined;
 
 export declare function injectReactiveOrFail<T extends object>(key: InjectionKey<T> | string, errorMessage?: string): UnwrapNestedRefs<T>;
 
-export declare const Lang: Facade<LangService>;
+export declare function installPlugins(plugins: Plugin_2[], ...args: GetClosureArgs<Plugin_2['install']>): Promise<void>;
 
-export declare function lang(key: string, parameters?: Record<string, unknown>): string;
+export declare const Lang: Facade<LangService, Constructor<LangService>>;
 
-export declare interface LangOptions {
-    messages: Record<string, unknown>;
-    defaultLocale?: string;
-    fallbackLocale?: string;
+export declare interface LangProvider {
+    translate(key: string, parameters?: Record<string, unknown>): string;
 }
 
 declare class LangService extends Service {
-    private i18n?;
-    setup(): void;
+    private provider;
+    constructor();
+    setProvider(provider: LangProvider): void;
     translate(key: string, parameters?: Record<string, unknown>): string;
+    translateWithDefault(key: string, defaultMessage: string): string;
+    translateWithDefault(key: string, parameters: Record<string, unknown>, defaultMessage: string): string;
 }
 
-export declare type LangServices = typeof services;
-
-export declare type LazyMessages = () => Promise<Record<string, unknown>>;
+export declare type LangServices = typeof services_2;
 
-export declare function mixedProp<T>(type: PropType<T>): OptionalProp<T | null>;
+export declare function mixedProp<T>(type?: PropType<T>): OptionalProp<T | null>;
 
 declare interface Modal<T = unknown> {
     id: string;
@@ -478,12 +1083,22 @@ export declare function objectProp<T = Object>(): OptionalProp<T | null>;
 
 export declare function objectProp<T>(defaultValue: () => T): OptionalProp<T>;
 
+export declare function onCleanMounted(operation: () => Function): void;
+
 declare type OptionalProp<T> = BaseProp<T> & {
     default: T | (() => T) | null;
 };
 
+declare interface Plugin_2 {
+    name?: string;
+    install(app: App_2, options: AerogelOptions): void | Promise<void>;
+}
+export { Plugin_2 as Plugin }
+
 export declare function requiredArrayProp<T>(): RequiredProp<T[]>;
 
+export declare function requiredBooleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'>;
+
 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>;
@@ -502,21 +1117,42 @@ export declare function requiredStringInput(defaultValue?: string): FormFieldDef
 
 export declare function requiredStringProp(): RequiredProp<string>;
 
-export declare class Service<State extends ServiceState = DefaultServiceState> extends MagicObject {
-    protected _namespace: string;
+export declare type SelectOptionValue = string | number | boolean | object | null;
+
+export declare const selectProps: {
+    options: {
+        type?: PropType<SelectOptionValue[]> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        required: true;
+    };
+};
+
+export declare class Service<State extends ServiceState = DefaultServiceState, ComputedState extends ServiceState = {}, ServiceStorage extends Partial<State> = Partial<State>> extends MagicObject {
+    static persist: string[];
+    protected _name: string;
     private _booted;
-    private _state;
+    private _computedStateKeys;
+    private _store?;
     constructor();
     get booted(): PromisedValue<void>;
-    launch(namespace?: string): Promise<void>;
+    launch(): Promise<void>;
+    hasState<P extends keyof State>(property: P): boolean;
+    getState(): State;
+    getState<P extends keyof State>(property: P): State[P];
+    setState<P extends keyof State>(property: P, value: State[P]): void;
+    setState(state: Partial<State>): void;
     protected __get(property: string): unknown;
     protected __set(property: string, value: unknown): void;
-    protected hasState<P extends keyof State>(property: P): boolean;
-    protected getState(): State;
-    protected getState<P extends keyof State>(property: P): State[P];
-    protected setState(state: Partial<State>): void;
+    protected onStateUpdated(state: 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 frameworkBoot(): Promise<void>;
     protected boot(): Promise<void>;
+    protected restorePersistedState(): void;
 }
 
 export declare type ServiceConstructor<T extends Service = Service> = Constructor<T> & typeof Service;
@@ -525,70 +1161,160 @@ export declare interface Services extends DefaultServices {
 }
 
 declare const services: {
-    $lang: Facade<LangService>;
+    $errors: Facade<ErrorsService, Constructor<ErrorsService>>;
 };
 
 declare const services_2: {
-    $ui: Facade<UIService>;
+    $lang: Facade<LangService, Constructor<LangService>>;
+};
+
+declare const services_3: {
+    $ui: Facade<UIService, Constructor<UIService>>;
 };
 
 export declare type ServiceState = Record<string, any>;
 
-declare interface State {
-    modals: Modal[];
+declare interface ShowSnackbarOptions {
+    component?: Component;
+    color?: SnackbarColor;
+    actions?: SnackbarAction[];
+}
+
+declare interface Snackbar {
+    id: string;
+    component: Component;
+    properties: Record<string, unknown>;
 }
 
+export declare interface SnackbarAction {
+    text: string;
+    dismiss?: boolean;
+    handler?(): unknown;
+}
+
+export declare type SnackbarColor = (typeof SnackbarColors)[keyof typeof SnackbarColors];
+
+export declare const SnackbarColors: Omit<{
+    readonly Primary: "primary";
+    readonly Secondary: "secondary";
+    readonly Danger: "danger";
+    readonly Clear: "clear";
+}, "Primary" | "Clear">;
+
+export declare const snackbarProps: {
+    id: {
+        type?: PropType<string> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        required: true;
+    };
+    message: {
+        type?: PropType<string> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        required: true;
+    };
+    actions: {
+        type?: PropType<SnackbarAction[]> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: SnackbarAction[] | (() => SnackbarAction[]) | null;
+    };
+    color: {
+        type?: PropType<"secondary" | "danger"> | undefined;
+        validator?(value: unknown): boolean;
+    } & {
+        default: "secondary" | "danger" | (() => "secondary" | "danger") | null;
+    };
+};
+
 export declare function stringInput(defaultValue?: string): FormFieldDefinition<typeof FormFieldTypes.String>;
 
 export declare function stringProp(): OptionalProp<string | null>;
 
 export declare function stringProp(defaultValue: string): OptionalProp<string>;
 
-export declare const UI: Facade<UIService>;
+export declare const translate: (key: string, parameters?: Record<string, unknown> | undefined) => string;
+
+export declare const translateWithDefault: {
+    (key: string, defaultMessage: string): string;
+    (key: string, parameters: Record<string, unknown>, defaultMessage: string): string;
+};
+
+export declare const UI: Facade<UIService, Constructor<UIService>>;
 
 export declare type UIComponent = ObjectValues<typeof UIComponents>;
 
 export declare const UIComponents: {
     readonly AlertModal: "alert-modal";
+    readonly ConfirmModal: "confirm-modal";
+    readonly ErrorReportModal: "error-report-modal";
+    readonly LoadingModal: "loading-modal";
+    readonly Snackbar: "snackbar";
 };
 
-declare class UIService extends _default {
+declare class UIService extends _default_3 {
     private modalCallbacks;
     private components;
+    requireComponent(name: UIComponent): Component;
     alert(message: string): void;
+    alert(title: string, message: string): void;
+    confirm(message: string): Promise<boolean>;
+    confirm(title: string, message: string): Promise<boolean>;
+    loading<T>(operation: Promise<T>): Promise<T>;
+    loading<T>(message: string, operation: Promise<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>;
     protected boot(): Promise<void>;
-    private requireComponent;
     private watchModalEvents;
 }
 
-export declare type UIServices = typeof services_2;
+export declare type UIServices = typeof services_3;
 
 export declare type UnknownEvent<T> = T extends keyof EventsPayload ? never : T;
 
+export declare function useErrorReportModalProps(): typeof errorReportModalProps;
+
+export declare function useEvent<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): void;
+
+export declare function useEvent<Event extends EventWithPayload>(event: Event, listener: EventListener_2<EventsPayload[Event]>): void;
+
+export declare function useEvent<Event extends string>(event: UnknownEvent<Event>, listener: EventListener_2): void;
+
 export declare function useForm<const T extends FormFieldDefinitions>(fields: T): Form<T> & FormData_2<T>;
 
+export declare function useInputAttrs(): [ComputedRef<{}>, ComputedRef<unknown>];
+
+export declare function useSelectProps(): typeof selectProps;
+
+export declare function useSnackbarProps(): typeof snackbarProps;
+
 export { }
 
-    interface BootstrapOptions {
-        lang?: LangOptions;
-        langMessages?: Record<string, unknown>;
+    interface AerogelOptions {
+        directives?: Record<string, Directive>;
     }
 
-    interface Services extends LangServices {}
-
-    interface BootstrapOptions {
-        models?: Record<string, Record<string, unknown>>;
+    interface AerogelOptions {
+        handleError?(error: ErrorSource): boolean;
     }
 
-    interface BootstrapOptions {
-        routes?: RouteRecordRaw[];
-        basePath?: string;
+    export interface Services extends ErrorsServices {}
+
+    export interface Services extends LangServices {}
+
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        $td: typeof translateWithDefault;
     }
+}
 
-import type { RouteRecordRaw } from 'vue-router';
+    interface AerogelOptions {
+        services?: Record<string, Service>;
+    }
 
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties extends Services {}
@@ -602,8 +1328,8 @@ declare module '@vue/runtime-core' {
         'show-modal': { id: string };
     }
 
-    interface BootstrapOptions {
+    interface AerogelOptions {
         components?: Partial<Record<UIComponent, Component>>;
     }
 
-    interface Services extends UIServices {}
+    export interface Services extends UIServices {}