@omnitend/dashboard-for-laravel 0.42.2 → 0.44.0

package/dist/components/base/DFormSelect.vue.d.ts

@@ -1,4 +1,4 @@
-export type OptionItem = string | number | boolean | Record<string, unknown>;
+export type OptionItem = string | number | boolean | object;
 export interface Props<TValue = unknown> {
     modelValue?: TValue | TValue[] | null;
     options?: readonly OptionItem[];

package/dist/components/extended/DXChoiceField.vue.d.ts

@@ -13,10 +13,10 @@ interface Props {
     /** Escape-hatch control props, already guard-merged by DXField. */
     controlProps?: Record<string, any>;
     /**
-     * Whether async options have resolved (a searchable select must not render
-     * before its options load, or it shows the raw id instead of the label).
+     * The field's first async options load is still in flight. A searchable
+     * select then shows "Loading…" instead of its value's raw id.
      */
-    optionsReady?: boolean;
+    optionsPending?: boolean;
 }
 declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (value: any) => any;

package/dist/components/extended/DXCurrencyInput.vue.d.ts

@@ -17,9 +17,9 @@ interface Props {
      *  slot overrides it when the affix needs to be more than a string. */
     append?: string;
 }
-declare var __VLS_14: {};
+declare var __VLS_13: {};
 type __VLS_Slots = {} & {
-    append?: (props: typeof __VLS_14) => any;
+    append?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: number | null) => any;

package/dist/components/extended/DXDashboard.vue.d.ts

@@ -1,4 +1,4 @@
-import type { Navigation, NavbarActionsOnMobile, NavbarSearchAlign } from '../../types/navigation';
+import type { Navigation, NavbarActionsOnMobile, NavbarSearchAlign, SidebarVariant } from '../../types/navigation';
 interface Props {
     /** Navigation structure for sidebar */
     navigation: Navigation;
@@ -50,6 +50,13 @@ interface Props {
      * (single-open accordion). `false`: all groups start open, toggled independently.
      */
     autoCollapseInactiveGroups?: boolean;
+    /**
+     * Sidebar colour scheme, forwarded to DXDashboardSidebar as `variant`:
+     * `'light'` (default: white pane, tinted group headers, green active item,
+     * Poppins) or `'dark'` (the navy rail). Colours come from the
+     * `--dx-sidebar-*` custom properties, so either can be rebranded in CSS.
+     */
+    sidebarVariant?: SidebarVariant;
     /** LocalStorage key for sidebar state persistence */
     storageKey?: string;
     /**
@@ -59,15 +66,15 @@ interface Props {
      */
     dashboardId?: string;
 }
-declare var __VLS_9: string, __VLS_10: any, __VLS_20: string, __VLS_21: any, __VLS_26: {}, __VLS_37: {};
+declare var __VLS_13: string, __VLS_14: any, __VLS_24: string, __VLS_25: any, __VLS_30: {}, __VLS_41: {};
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
+    [K in NonNullable<typeof __VLS_13>]?: (props: typeof __VLS_14) => any;
 } & {
-    [K in NonNullable<typeof __VLS_20>]?: (props: typeof __VLS_21) => any;
+    [K in NonNullable<typeof __VLS_24>]?: (props: typeof __VLS_25) => any;
 } & {
-    default?: (props: typeof __VLS_26) => any;
+    default?: (props: typeof __VLS_30) => any;
 } & {
-    default?: (props: typeof __VLS_37) => any;
+    default?: (props: typeof __VLS_41) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<Props, {
     /**
@@ -93,6 +100,7 @@ declare const __VLS_component: import("vue").DefineComponent<Props, {
     actionsOnMobile: NavbarActionsOnMobile;
     userMenuLabel: string;
     contentMaxWidth: string;
+    sidebarVariant: SidebarVariant;
     storageKey: string;
     dashboardId: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/extended/DXDashboardNavbar.vue.d.ts

@@ -10,9 +10,8 @@ type __VLS_Props = {
     pageTitle?: string;
     /**
      * Horizontal alignment of the search slot content within its region
-     * (`"start"` = flush left, `"center"` = centred). Applies at every size:
-     * the region sits inline after the title from `md` up, and is its own
-     * full-width row below.
+     * (`"start"` = flush left, `"center"` = centred). The region sits inline
+     * between the toggle/title and the user menu at every width.
      */
     searchAlign?: NavbarSearchAlign;
     /**
@@ -26,6 +25,14 @@ type __VLS_Props = {
      * announces the trigger as the avatar's initial ("J") rather than as a menu.
      */
     userMenuLabel?: string;
+    /**
+     * Whether the sidebar the toggle controls is showing, exposed as the
+     * toggle's `aria-expanded`. Left unset, the toggle carries none.
+     * DXDashboard sets it.
+     */
+    sidebarExpanded?: boolean;
+    /** `id` of the sidebar the toggle controls (its `aria-controls`). */
+    sidebarId?: string;
 };
 declare var __VLS_11: {}, __VLS_13: {}, __VLS_15: {
     pageTitle: string;
@@ -76,6 +83,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     searchAlign: NavbarSearchAlign;
     actionsOnMobile: NavbarActionsOnMobile;
     userMenuLabel: string;
+    sidebarExpanded: boolean;
+    sidebarId: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/extended/DXDashboardSidebar.vue.d.ts

@@ -1,4 +1,4 @@
-import type { Navigation } from '../../types/navigation';
+import type { Navigation, SidebarVariant } from '../../types/navigation';
 type __VLS_Props = {
     /** Grouped navigation to render: an array of groups, each with a label and items. */
     navigation: Navigation;
@@ -22,6 +22,20 @@ type __VLS_Props = {
      * `false`: all groups start open and toggle independently.
      */
     autoCollapseInactiveGroups?: boolean;
+    /**
+     * Colour scheme: `'light'` (default) or `'dark'`. Colours come from the
+     * `--dx-sidebar-*` custom properties (see the theming guide), so either
+     * scheme can be rebranded in CSS.
+     */
+    variant?: SidebarVariant;
+    /**
+     * Below `sm`, show the open sidebar as a full-screen menu over the page,
+     * with a close button (which emits `close`), instead of a rail beside it;
+     * hidden there until opened. The owner must answer `close`, Escape and
+     * `navigate`: DXDashboard sets this and does. Off by default, so a
+     * standalone sidebar keeps its rail on phones.
+     */
+    phoneMenu?: boolean;
 };
 declare var __VLS_1: {
     collapsed: boolean;
@@ -42,15 +56,21 @@ type __VLS_Slots = {} & {
     footer?: (props: typeof __VLS_9) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
     toggle: () => any;
+    navigate: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
     onToggle?: (() => any) | undefined;
+    onNavigate?: (() => any) | undefined;
 }>, {
     hidden: boolean;
     title: string;
     collapsed: boolean;
     collapsibleGroups: boolean;
     autoCollapseInactiveGroups: boolean;
+    variant: SidebarVariant;
+    phoneMenu: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/extended/DXForm.vue.d.ts

@@ -1,3 +1,5 @@
+import { type ErrorSummarySelection } from "./DXFormErrorSummary.vue";
+import { type ErrorTarget } from "../../utils/formErrorTargets";
 import type { UseFormReturn } from "../../composables/useForm";
 import type { DefineFormReturn } from "../../composables/defineForm";
 import type { FieldDefinition, FormTab, LabelCols } from "../../types";
@@ -91,16 +93,77 @@ interface Props {
      * `sm` up and stacks above the input below `sm`.
      */
     labelCols?: LabelCols;
+    /**
+     * Where to list what the last failed submit returned (`form.submitFailure`:
+     * the server's message and every validation message, with readable
+     * labels):
+     *
+     * - `"footer"` (default) — directly above the submit button, below any
+     *   tabs, next to the control the user just pressed.
+     * - `"top"` — above the fields, where the form-level alert sits.
+     * - `"external"` — the host renders a `DXFormErrorSummary` of its own
+     *   elsewhere (beside a submit button outside the form, as DXTable's
+     *   modal does). DXForm renders neither a summary nor, while a failure
+     *   is listed, the form-level alert.
+     * - `false` — no summary; the form-level alert behaves as before.
+     *
+     * While a summary shows a failure the form-level alert does not render,
+     * so a failure shows exactly one alert. Each row naming a visible field is
+     * a button that selects the field's tab and focuses it.
+     */
+    errorSummary?: "footer" | "top" | "external" | false;
+    /**
+     * The summary's heading when the failure has field errors (default
+     * "Couldn't save. Please check:"). A failure with none (a message-only
+     * 422, a 500) is headed by the server's message instead.
+     */
+    errorSummaryTitle?: string;
+    /**
+     * The summary's sub-heading over the rows no visible field owns (default
+     * "Other problems"), shown only when some rows ARE owned.
+     */
+    errorSummaryOtherTitle?: string;
+    /**
+     * After a failed submit, scroll the first field with an error into view
+     * (once its tab is selected and rendered). Never moves focus. On by
+     * default.
+     */
+    scrollToError?: boolean;
 }
 type __VLS_Props = Props;
 type __VLS_Slots = Record<string, (props: any) => any>;
+/** Select the first visible tab owning a visible errored field, if any. */
 declare function goToErrorTab(): void;
+/**
+ * Take the user to an error a summary lists: select its tab, wait for the
+ * pane to render, look the field up in the form (its marker, anywhere
+ * inside the form's element, a teleport target inside the form included),
+ * scroll it into view and focus its control: an editable control that can
+ * take focus, waiting (about a second) while none can, e.g. an async editor
+ * still loading or a widget rendered disabled until its data arrives;
+ * anything else focusable only as a fallback. A focus counts only once
+ * `document.activeElement` is the control. The field is looked up again by
+ * its key whenever its element leaves the DOM (a re-render replacing it),
+ * and a moment with none at all is waited out. When no marker renders
+ * within the field's render frames, or nothing in it takes focus, focus
+ * moves to the selected tab's button. Exposed so a summary rendered OUTSIDE
+ * the form (DXTable's modal footer) can drive it.
+ */
+declare function focusErrorTarget(target: ErrorSummarySelection): Promise<void>;
 type __VLS_PublicProps = __VLS_Props & {
-    /** v-model for the active tab index. */
+    /**
+     * v-model for the active tab, as an index into the VISIBLE tabs. It is a
+     * view of `activeTabKey` (below), which is what DXForm actually tracks.
+     */
     "activeTab"?: number;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {
+    /** Select the first visible tab owning a visible errored field, if any. */
     goToErrorTab: typeof goToErrorTab;
+    /** Select an error's tab, then scroll to and focus its field. */
+    focusErrorTarget: typeof focusErrorTarget;
+    /** What the last failed submit returned, resolved by this form's rules. */
+    errorTargets: import("vue").ComputedRef<ErrorTarget[]>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     submit: () => any;
     "update:activeTab": (value: number) => any;
@@ -118,6 +181,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps,
     autoErrorTab: boolean;
     cardTabs: boolean;
     layoutThreshold: number;
+    errorSummary: "footer" | "top" | "external" | false;
+    scrollToError: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/extended/DXFormErrorSummary.vue.d.ts

@@ -0,0 +1,70 @@
+import type { UseFormReturn } from "../../composables/useForm";
+import type { DefineFormReturn } from "../../composables/defineForm";
+import type { FieldDefinition, FormTab } from "../../types";
+import { type ErrorTarget } from "../../utils/formErrorTargets";
+/** What a summary row points at (emitted by `select-target`). */
+export interface ErrorSummarySelection {
+    /** The owning field's key. */
+    fieldKey: string;
+    /** The tab holding that field, or `null` in a flat form. */
+    tabKey: string | null;
+    /** The error key as the server sent it. */
+    errorKey: string;
+}
+interface Props {
+    /** The form: a `useForm` return or a `defineForm` return. */
+    form: UseFormReturn<any> | DefineFormReturn<any>;
+    /** Field definitions (optional when `form` is a defineForm return). */
+    fields?: FieldDefinition[];
+    /** The form's tabs, so rows follow tab order and know their tab. */
+    tabs?: FormTab[];
+    /**
+     * Extra context merged under the form data when evaluating `when` and
+     * function labels, as on DXForm.
+     */
+    context?: Record<string, any>;
+    /**
+     * Field visibility, replacing the default (`when`/`show` against form
+     * data + `context`). A host form passes its own predicate so the summary
+     * agrees with what it renders.
+     */
+    isFieldVisible?: (field: FieldDefinition) => boolean;
+    /** Tab visibility, replacing the default (the tab's `when`). */
+    isTabVisible?: (tab: FormTab) => boolean;
+    /**
+     * A field's label, replacing the default (its `label`, resolved against
+     * `labelModel`: the form model, or the row for a repeater sub-field).
+     */
+    resolveLabel?: (field: FieldDefinition, labelModel: Record<string, any>) => string | null | undefined;
+    /**
+     * Rows already resolved by the host (from `resolveErrorTargets` over
+     * `form.submitFailure.errors`). When given, the summary lists these and
+     * resolves nothing itself; the message still comes from
+     * `form.submitFailure`, and nothing renders while that is null.
+     */
+    targets?: ErrorTarget[] | null;
+    /**
+     * The heading when the failure has at least one field error. The
+     * server's own message is not used then: Laravel's default 422 message
+     * is the first error plus "(and N more errors)", which repeats the first
+     * row. A failure with no field errors (a message-only 422, a 500, a
+     * network failure) keeps the server's message as the heading, as it is
+     * the only information.
+     */
+    title?: string;
+    /**
+     * The sub-heading over the rows no visible field owns, listed after the
+     * owned rows. Shown only when there are both kinds; when no row is owned
+     * they are listed under the heading alone.
+     */
+    otherTitle?: string;
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "select-target": (selection: ErrorSummarySelection) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onSelect-target"?: ((selection: ErrorSummarySelection) => any) | undefined;
+}>, {
+    title: string;
+    otherTitle: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/extended/DXFormField.vue.d.ts

@@ -15,6 +15,9 @@ interface Props {
 declare var __VLS_2: `field(${string})`, __VLS_3: {
     field: FieldDefinition;
     model: Record<string, any>;
+    targetAttrs: {
+        "data-dx-field-key": string;
+    };
 }, __VLS_6: `field-before(${string})`, __VLS_7: {
     field: FieldDefinition;
     model: Record<string, any>;

package/dist/components/extended/DXStackingTable.vue.d.ts

@@ -0,0 +1,25 @@
+interface Props {
+    /**
+     * Stack when the wrapper's content width is below this many px. 576 is
+     * Bootstrap's `sm` breakpoint, but measured on the container.
+     */
+    stackBelow?: number;
+}
+declare var __VLS_1: {
+    stacked: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {
+    isStacked: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    stackBelow: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/extended/DXTable.vue.d.ts

@@ -317,6 +317,17 @@ export interface Props<TItem = any> {
     createText?: string;
     /** Override the modal's Delete button label (default: "Delete {item}"). */
     deleteText?: string;
+    /**
+     * Heading of the modal's failed-save summary when the failure has field
+     * errors (default "Couldn't save. Please check:"). A failure with none
+     * is headed by the server's message instead.
+     */
+    errorSummaryTitle?: string;
+    /**
+     * Sub-heading over the summary rows no edit field owns (default "Other
+     * problems"), shown only when some rows ARE owned.
+     */
+    errorSummaryOtherTitle?: string;
     /** API endpoint pattern for updates (e.g., "/api/products/:id") */
     editUrl?: string;
     /**
@@ -416,6 +427,15 @@ export interface Props<TItem = any> {
      * doesn't *look* clickable, and a click on it can't quietly do something.
      */
     rowClickable?: (item: TItem, index: number) => boolean;
+    /**
+     * Whether clicking a row opens the edit modal (when `editFields` are set).
+     * Defaults to `true`. Set `false` when `editFields` exist only for the
+     * create modal (`openCreate()` / the create button) and a row click does
+     * something else, such as opening the record's own page from `row-clicked`:
+     * the row then emits `row-clicked` without also opening the edit modal, and
+     * only a `row-clicked` listener makes rows look clickable (#200).
+     */
+    editOnRowClick?: boolean;
     /** Enable client-side filtering, sorting, and pagination on items array */
     clientSide?: boolean;
     /**

package/dist/components/extended/DXTableEditorModal.vue.d.ts

@@ -46,37 +46,41 @@ interface Props {
     createText?: string;
     /** Override the Delete button label. */
     deleteText?: string;
+    /** The footer summary's heading for a failure with field errors. */
+    errorSummaryTitle?: string;
+    /** The footer summary's sub-heading over rows no field owns. */
+    errorSummaryOtherTitle?: string;
 }
-declare var __VLS_21: `edit-value(${string})`, __VLS_22: {
+declare var __VLS_23: `edit-value(${string})`, __VLS_24: {
     item: any;
     value: any;
     update: any;
     field: any;
-}, __VLS_25: `edit-span(${string})`, __VLS_26: {
+}, __VLS_27: `edit-span(${string})`, __VLS_28: {
     item: any;
     value: any;
     update: any;
     close: () => void;
-}, __VLS_29: `tab-content(${string})`, __VLS_30: {
+}, __VLS_31: `tab-content(${string})`, __VLS_32: {
     item: any;
     tab: any;
-}, __VLS_33: `tab-before(${string})`, __VLS_34: {
+}, __VLS_35: `tab-before(${string})`, __VLS_36: {
     item: any;
     tab: any;
-}, __VLS_37: `tab-after(${string})`, __VLS_38: {
+}, __VLS_39: `tab-after(${string})`, __VLS_40: {
     item: any;
     tab: any;
 };
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_21>]?: (props: typeof __VLS_22) => any;
+    [K in NonNullable<typeof __VLS_23>]?: (props: typeof __VLS_24) => any;
 } & {
-    [K in NonNullable<typeof __VLS_25>]?: (props: typeof __VLS_26) => any;
+    [K in NonNullable<typeof __VLS_27>]?: (props: typeof __VLS_28) => any;
 } & {
-    [K in NonNullable<typeof __VLS_29>]?: (props: typeof __VLS_30) => any;
+    [K in NonNullable<typeof __VLS_31>]?: (props: typeof __VLS_32) => any;
 } & {
-    [K in NonNullable<typeof __VLS_33>]?: (props: typeof __VLS_34) => any;
+    [K in NonNullable<typeof __VLS_35>]?: (props: typeof __VLS_36) => any;
 } & {
-    [K in NonNullable<typeof __VLS_37>]?: (props: typeof __VLS_38) => any;
+    [K in NonNullable<typeof __VLS_39>]?: (props: typeof __VLS_40) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     cancel: () => any;

package/dist/composables/useAsyncOptions.d.ts

@@ -7,13 +7,26 @@ import type { FieldDefinition, FieldOption } from "../types";
  * out-of-order responses clobbering newer ones; loader failures are swallowed
  * so the last good options (or the static `field.options` fallback) stay put.
  *
- * Extracted verbatim from DXField's inline logic (#135) — behaviour unchanged.
+ * Known limit: replacing a field's `optionsLoader` at runtime does NOT restart
+ * the "first load" state (loaded options and `firstLoadSettled` carry over).
+ * Loader identity is not a stable signal: an inline loader in a computed
+ * `fields` array is a new function on every recompute, so treating each new
+ * function as a new source would blank the field and refetch on every
+ * unrelated edit.
+ *
+ * Extracted from DXField's inline logic (#135).
  * `getField` is an accessor (props aren't destructurable without losing
  * reactivity); `effectiveModel` is the model passed to the loader.
  */
 export interface UseAsyncOptionsReturn {
     /** Options returned by the most recent successful load, or null if none yet. */
     loadedOptions: Ref<FieldOption[] | null>;
+    /**
+     * False until the first load has SETTLED (succeeded or failed). Only that
+     * first load leaves a field with nothing to show; a later reload keeps the
+     * options it has, or the static fallback after a failure.
+     */
+    firstLoadSettled: Ref<boolean>;
     /** Trigger a load (no-op when the field has no `optionsLoader`). */
     loadOptions: () => Promise<void>;
 }

package/dist/composables/useForm.d.ts

@@ -4,6 +4,18 @@ export interface ValidationErrors {
     [key: string]: string[];
 }
 export type FormError = ApiError;
+/**
+ * What the most recent failed submit returned (#194): the server's message and
+ * a COPY of its validation errors, frozen at the moment the submit failed.
+ * The live `form.errors` empties as the user fixes fields; this does not, so a
+ * summary built from it keeps listing every message until the next submit.
+ */
+export interface SubmitFailure {
+    /** A message fit to show a user (never empty, never a raw exception). */
+    message: string;
+    /** The validation errors the submit returned (`{}` when none). */
+    errors: ValidationErrors;
+}
 export interface FormSubmitOptions<TPayload = unknown, TResponse = unknown> {
     onSuccess?: (data: TResponse) => void;
     onError?: (error: FormError) => void;
@@ -29,6 +41,19 @@ export interface FormState<TData extends Record<string, any>> {
      */
     wasSuccessful: boolean;
     shouldShowMessage: boolean;
+    /**
+     * What the most recent submit failed with, or `null`. Set when a submit
+     * fails (validation or otherwise; an aborted submit does not count),
+     * cleared when a submit starts and when one succeeds. Untouched by
+     * `clearError`, `clearErrors`, `setErrors` and field edits.
+     */
+    submitFailure: SubmitFailure | null;
+    /**
+     * How many submits have failed, counting every failure (including a
+     * `preserveErrors` resubmit that returned the same errors), so a watcher
+     * can react to "a submit just failed" even when nothing else changed.
+     */
+    failedSubmitCount: number;
 }
 export interface UseFormReturn<TData extends Record<string, any>> extends FormState<TData> {
     hasErrors: ComputedRef<boolean>;
@@ -50,4 +75,5 @@ export interface UseFormReturn<TData extends Record<string, any>> extends FormSt
     patch: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
     delete: <TResponse = unknown>(url: string, options?: FormSubmitOptions<TData, TResponse>) => Promise<TResponse>;
 }
+export declare function isAbortError(error: unknown): boolean;
 export declare function useForm<TData extends Record<string, any>>(initialData?: TData): UseFormReturn<TData>;