@vizejs/ui 0.387.0 → 0.388.0

package/dist/drag-and-drop-CagE25Kt.d.mts

@@ -0,0 +1,47 @@
+import { h as DragPayload, n as DragAndDropOptions, t as DragAndDropController, u as DragAnnouncements } from "./drag-and-drop-controller-types-DoTSR_aM.mjs";
+
+//#region src/families/interaction/drag-and-drop/drag-and-drop-announce.d.ts
+/** Built-in English announcement builders; consumers override to localize. */
+declare const defaultDragAnnouncements: Required<DragAnnouncements>;
+//#endregion
+//#region src/families/interaction/drag-and-drop/drag-and-drop-transfer.d.ts
+/** Structured data-transfer format written next to the plain-text projection. */
+declare const DRAG_TRANSFER_TYPE = "application/vnd.vize-ui.drag+json";
+/**
+ * Serialize one typed payload onto a `DataTransfer`.
+ *
+ * The structured payload is written under {@link DRAG_TRANSFER_TYPE}; the
+ * optional `plainText` projection is mirrored to `text/plain` so external
+ * applications receive a meaningful representation.
+ */
+declare function writeDragTransfer(dataTransfer: DataTransfer, payload: DragPayload): void;
+/**
+ * Deserialize a typed payload from a `DataTransfer`.
+ *
+ * @returns The structured payload, or `null` when the transfer does not carry
+ * a well-formed {@link DRAG_TRANSFER_TYPE} entry.
+ */
+declare function readDragTransfer<Data = unknown>(dataTransfer: DataTransfer): DragPayload<Data> | null;
+/**
+ * Serialize one typed payload onto a clipboard event during `copy` or `cut`.
+ *
+ * The event's default action is prevented so the written data wins.
+ *
+ * @returns `true` when the event exposed writable clipboard data.
+ */
+declare function writeClipboardTransfer(event: ClipboardEvent, payload: DragPayload): boolean;
+/**
+ * Deserialize a typed payload from a clipboard event during `paste`.
+ *
+ * @returns The structured payload, or `null` when the clipboard does not carry
+ * a well-formed {@link DRAG_TRANSFER_TYPE} entry.
+ */
+declare function readClipboardTransfer<Data = unknown>(event: ClipboardEvent): DragPayload<Data> | null;
+//#endregion
+//#region src/families/interaction/drag-and-drop/drag-and-drop.d.ts
+/** Create an SSR-safe pointer, touch, and keyboard drag-and-drop coordinator. */
+declare function createDragAndDrop<Data = unknown>(options?: DragAndDropOptions<Data>): DragAndDropController<Data>;
+/** Create a drag-and-drop coordinator disposed with the current effect scope. */
+declare function useDragAndDrop<Data = unknown>(options?: DragAndDropOptions<Data>): DragAndDropController<Data>;
+//#endregion
+export { readDragTransfer as a, defaultDragAnnouncements as c, readClipboardTransfer as i, useDragAndDrop as n, writeClipboardTransfer as o, DRAG_TRANSFER_TYPE as r, writeDragTransfer as s, createDragAndDrop as t };

package/dist/drag-and-drop-controller-types-DoTSR_aM.d.mts

@@ -0,0 +1,304 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/interaction/drag-and-drop/drag-and-drop-types.d.ts
+/** Input families that can own a drag session. */
+type DragPointerType = "keyboard" | "mouse" | "pen" | "pointer" | "touch";
+/** Drop position relative to a target, used for indicators and placeholders. */
+type DropEdge = "bottom" | "inside" | "left" | "right" | "top";
+/** Lifecycle phases emitted by a drag-and-drop controller. */
+type DragEventType = "dragend" | "dragmove" | "dragstart";
+/** Target-scoped phases delivered to drop-target callbacks. */
+type DropTargetEventType = "drop" | "dropenter" | "dropleave" | "dropmove";
+/** Serializable, axis-aligned CSS pixel rectangle. */
+interface DropTargetRect {
+  readonly bottom: number;
+  readonly left: number;
+  readonly right: number;
+  readonly top: number;
+}
+/** Typed payload transferred from a drag source to a drop target. */
+interface DragPayload<Data = unknown> {
+  /** Consumer-defined discriminant such as a MIME type or model name. */
+  readonly kind: string;
+  /** Structured payload delivered verbatim to accepting drop targets. */
+  readonly data: Data;
+  /** Optional plain-text projection for clipboard and data-transfer adapters. */
+  readonly plainText?: string;
+}
+/** Immutable snapshot shared by every drag lifecycle phase. */
+interface DragLifecycleEvent<Data = unknown, Type extends DragEventType = DragEventType> {
+  /** Lifecycle phase represented by this immutable snapshot. */
+  readonly type: Type;
+  /** Input family that owns this session. */
+  readonly pointerType: DragPointerType;
+  /** Key of the source that owns this session. */
+  readonly sourceKey: string;
+  /** Payload resolved when the session started, or `null` when none was declared. */
+  readonly payload: DragPayload<Data> | null;
+  /** Key of the drop target currently under the drag, or `null`. */
+  readonly targetKey: string | null;
+  /** Drop edge resolved for the current target, or `null`. */
+  readonly edge: DropEdge | null;
+  /** Client coordinates when supplied by pointing hardware. */
+  readonly x: number | null;
+  readonly y: number | null;
+  /** Native event responsible for this phase, or `null` for manual settlement. */
+  readonly originalEvent: Event | null;
+  /** Whether the session settled without a drop. Always `false` before `dragend`. */
+  readonly isCanceled: boolean;
+}
+/** Snapshot emitted once when a session starts. */
+type DragStartEvent<Data = unknown> = DragLifecycleEvent<Data, "dragstart">;
+/** Snapshot emitted for movement and target changes inside a session. */
+type DragMoveEvent<Data = unknown> = DragLifecycleEvent<Data, "dragmove">;
+/** Snapshot emitted after a session drops or cancels. */
+type DragEndEvent<Data = unknown> = DragLifecycleEvent<Data, "dragend">;
+/** Immutable snapshot delivered to one drop target's callbacks. */
+interface DropTargetEvent<Data = unknown> {
+  /** Target-scoped phase represented by this immutable snapshot. */
+  readonly type: DropTargetEventType;
+  /** Key of the target receiving this phase. */
+  readonly targetKey: string;
+  /** Key of the source that owns the session. */
+  readonly sourceKey: string;
+  /** Input family that owns the session. */
+  readonly pointerType: DragPointerType;
+  /** Payload resolved when the session started, or `null` when none was declared. */
+  readonly payload: DragPayload<Data> | null;
+  /** Drop edge resolved against this target, or `null` after leaving. */
+  readonly edge: DropEdge | null;
+  /** Client coordinates when supplied by pointing hardware. */
+  readonly x: number | null;
+  readonly y: number | null;
+  /** Native event responsible for this phase, or `null` for manual settlement. */
+  readonly originalEvent: Event | null;
+}
+/** Reactive indicator state for the target currently under the drag. */
+interface DropIndicatorState {
+  /** Key of the target the indicator belongs to. */
+  readonly targetKey: string;
+  /** Drop edge the indicator represents. */
+  readonly edge: DropEdge;
+  /** Full target rectangle for placeholder geometry, or `null` when unmeasurable. */
+  readonly rect: DropTargetRect | null;
+  /** Zero-thickness line rectangle along the edge; `null` for `"inside"` drops. */
+  readonly line: DropTargetRect | null;
+}
+/** Context handed to announcement builders before speaking to assistive tech. */
+interface DragAnnouncementContext<Data = unknown> {
+  readonly pointerType: DragPointerType;
+  readonly sourceKey: string;
+  readonly sourceLabel: string;
+  readonly payload: DragPayload<Data> | null;
+  readonly targetKey: string | null;
+  readonly targetLabel: string | null;
+  /** One-based position of the current target among valid targets, or `null`. */
+  readonly targetIndex: number | null;
+  readonly targetCount: number | null;
+  readonly edge: DropEdge | null;
+}
+/** Localizable builders for grab, move, drop, and cancel announcements. */
+interface DragAnnouncements<Data = unknown> {
+  /** Spoken when a session starts. Return `null` to stay silent. */
+  readonly grab?: (context: DragAnnouncementContext<Data>) => string | null;
+  /** Spoken when the drag enters a target or its edge changes. */
+  readonly move?: (context: DragAnnouncementContext<Data>) => string | null;
+  /** Spoken after a completed drop. */
+  readonly drop?: (context: DragAnnouncementContext<Data>) => string | null;
+  /** Spoken after a canceled session. */
+  readonly cancel?: (context: DragAnnouncementContext<Data>) => string | null;
+}
+//#endregion
+//#region src/families/interaction/drag-and-drop/drag-and-drop-controller-types.d.ts
+/** Edge-proximity auto-scroll configuration for pointer sessions. */
+interface DragAutoScrollOptions {
+  /** Scrollable element driven while a pointer drag approaches its edges. */
+  readonly container: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Viewport rectangle of the container used for edge proximity.
+   *
+   * @default the container's `getBoundingClientRect()`
+   */
+  readonly getRect?: () => DropTargetRect | DOMRectReadOnly | null | undefined;
+  /**
+   * Distance in CSS pixels from a container edge that engages scrolling.
+   * The resolved value must be finite and greater than zero.
+   *
+   * @default 48
+   */
+  readonly threshold?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Maximum scroll distance in CSS pixels applied per scroll step.
+   * The resolved value must be finite and greater than zero.
+   *
+   * @default 16
+   */
+  readonly speed?: MaybeRefOrGetter<number | undefined>;
+}
+/** Options shared by `createDragAndDrop` and `useDragAndDrop`. */
+interface DragAndDropOptions<Data = unknown> {
+  /**
+   * Suppress new sessions and cancel the active session on its next event.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Chebyshev distance in CSS pixels a pointer must travel before a session
+   * starts. The resolved value must be finite and greater than or equal to zero.
+   *
+   * @default 4
+   */
+  readonly startDistance?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Edge-proximity auto-scroll for pointer sessions.
+   *
+   * @default undefined
+   */
+  readonly autoScroll?: DragAutoScrollOptions;
+  /**
+   * Overrides merged over the built-in English announcement builders.
+   *
+   * @default built-in English announcements
+   */
+  readonly announcements?: DragAnnouncements<Data>;
+  /** Called exactly once when a session starts. */
+  readonly onDragStart?: (event: DragStartEvent<Data>) => void;
+  /** Called for pointer movement and keyboard target changes inside a session. */
+  readonly onDragMove?: (event: DragMoveEvent<Data>) => void;
+  /** Called exactly once after a session drops or cancels. */
+  readonly onDragEnd?: (event: DragEndEvent<Data>) => void;
+}
+/** Declaration of one draggable source owned by a controller. */
+interface DragSourceOptions<Data = unknown> {
+  /** Stable key unique among this controller's sources. */
+  readonly key: string;
+  /** Dragged item element used for geometry; the handle receives `sourceProps`. */
+  readonly element?: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Typed payload resolved when a session starts.
+   *
+   * @default undefined
+   */
+  readonly payload?: MaybeRefOrGetter<DragPayload<Data> | undefined>;
+  /**
+   * Human-readable name used by announcements.
+   *
+   * @default the source key
+   */
+  readonly label?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * Suppress new sessions from this source.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Whether Enter or Space on the handle starts a keyboard session.
+   *
+   * @default true
+   */
+  readonly keyboard?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** Native handlers to spread onto exactly one drag handle per source. */
+interface DragSourceProps {
+  readonly onDragstart: (event: DragEvent) => void;
+  readonly onFocusout: (event: FocusEvent) => void;
+  readonly onKeydown: (event: KeyboardEvent) => void;
+  readonly onMousedown: (event: MouseEvent) => void;
+  readonly onPointerdown: (event: PointerEvent) => void;
+  readonly onTouchstart: (event: TouchEvent) => void;
+}
+/** Live registration owned by one drag source. */
+interface DragSourceRegistration {
+  /** Key this registration was created with. */
+  readonly key: string;
+  /** Whether this source owns the active session. */
+  readonly isDragging: Readonly<ShallowRef<boolean>>;
+  /** Stable native handlers to spread or merge onto one drag handle. */
+  readonly sourceProps: Readonly<DragSourceProps>;
+  /** Remove the source; its active session is canceled first. */
+  readonly dispose: () => void;
+}
+/** Declaration of one drop target owned by a controller. */
+interface DropTargetOptions<Data = unknown> {
+  /** Stable key unique among this controller's targets. */
+  readonly key: string;
+  /** Element that owns this target's geometry and keyboard order. */
+  readonly element: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Drop edges this target resolves, in preference order for keyboard sessions.
+   *
+   * @default ["inside"]
+   */
+  readonly edges?: MaybeRefOrGetter<readonly DropEdge[] | undefined>;
+  /**
+   * Viewport rectangle used for hit testing and indicator geometry.
+   *
+   * @default the element's `getBoundingClientRect()`
+   */
+  readonly getRect?: () => DropTargetRect | DOMRectReadOnly | null | undefined;
+  /**
+   * Whether this target accepts the session payload.
+   *
+   * @default every payload is accepted
+   */
+  readonly accepts?: (payload: DragPayload<Data> | null) => boolean;
+  /**
+   * Remove this target from hit testing and keyboard navigation.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Human-readable name used by announcements.
+   *
+   * @default the target key
+   */
+  readonly label?: MaybeRefOrGetter<string | undefined>;
+  /** Called when the drag enters this target. */
+  readonly onEnter?: (event: DropTargetEvent<Data>) => void;
+  /** Called when the drag moves inside this target or its edge changes. */
+  readonly onMove?: (event: DropTargetEvent<Data>) => void;
+  /** Called when the drag leaves this target without dropping. */
+  readonly onLeave?: (event: DropTargetEvent<Data>) => void;
+  /** Called when the session drops on this target. */
+  readonly onDrop?: (event: DropTargetEvent<Data>) => void;
+}
+/** Live registration owned by one drop target. */
+interface DropTargetRegistration {
+  /** Key this registration was created with. */
+  readonly key: string;
+  /** Whether the active session is currently over this target. */
+  readonly isOver: Readonly<ShallowRef<boolean>>;
+  /** Remove the target from hit testing and keyboard navigation. */
+  readonly dispose: () => void;
+}
+/** Stateful drag-and-drop coordinator with explicit ownership and disposal. */
+interface DragAndDropController<Data = unknown> {
+  /** Whether a pointer or keyboard session is active. */
+  readonly isDragging: Readonly<ShallowRef<boolean>>;
+  /** Key of the source that owns the active session, or `null`. */
+  readonly sourceKey: Readonly<ShallowRef<string | null>>;
+  /** Key of the target currently under the active session, or `null`. */
+  readonly targetKey: Readonly<ShallowRef<string | null>>;
+  /** Indicator state for the target currently under the active session. */
+  readonly indicator: Readonly<ShallowRef<DropIndicatorState | null>>;
+  /** Register one draggable source. Duplicate keys are rejected. */
+  readonly registerSource: (options: DragSourceOptions<Data>) => DragSourceRegistration;
+  /** Register one drop target. Duplicate keys are rejected. */
+  readonly registerTarget: (options: DropTargetOptions<Data>) => DropTargetRegistration;
+  /** Speak one message through the controller's assertive live region. */
+  readonly announce: (message: string) => void;
+  /**
+   * Cancel the active session, including one that has not started yet.
+   *
+   * @returns `true` when an owned session or armed pointer was settled.
+   * @throws An error carrying `VIZE_UI_DRAG_AND_DROP_DISPOSED` after disposal.
+   */
+  readonly cancel: () => boolean;
+  /** Release listeners, the live region, and reactive state without callbacks. */
+  readonly dispose: () => void;
+}
+//#endregion
+export { DropTargetRect as S, DragStartEvent as _, DragSourceProps as a, DropTargetEvent as b, DropTargetRegistration as c, DragEndEvent as d, DragEventType as f, DragPointerType as g, DragPayload as h, DragSourceOptions as i, DragAnnouncementContext as l, DragMoveEvent as m, DragAndDropOptions as n, DragSourceRegistration as o, DragLifecycleEvent as p, DragAutoScrollOptions as r, DropTargetOptions as s, DragAndDropController as t, DragAnnouncements as u, DropEdge as v, DropTargetEventType as x, DropIndicatorState as y };

package/dist/drag-and-drop.d.mts

@@ -0,0 +1,3 @@
+import { S as DropTargetRect, _ as DragStartEvent, a as DragSourceProps, b as DropTargetEvent, c as DropTargetRegistration, d as DragEndEvent, f as DragEventType, g as DragPointerType, h as DragPayload, i as DragSourceOptions, l as DragAnnouncementContext, m as DragMoveEvent, n as DragAndDropOptions, o as DragSourceRegistration, p as DragLifecycleEvent, r as DragAutoScrollOptions, s as DropTargetOptions, t as DragAndDropController, u as DragAnnouncements, v as DropEdge, x as DropTargetEventType, y as DropIndicatorState } from "./drag-and-drop-controller-types-DoTSR_aM.mjs";
+import { a as readDragTransfer, c as defaultDragAnnouncements, i as readClipboardTransfer, n as useDragAndDrop, o as writeClipboardTransfer, r as DRAG_TRANSFER_TYPE, s as writeDragTransfer, t as createDragAndDrop } from "./drag-and-drop-CagE25Kt.mjs";
+export { DRAG_TRANSFER_TYPE, type DragAndDropController, type DragAndDropOptions, type DragAnnouncementContext, type DragAnnouncements, type DragAutoScrollOptions, type DragEndEvent, type DragEventType, type DragLifecycleEvent, type DragMoveEvent, type DragPayload, type DragPointerType, type DragSourceOptions, type DragSourceProps, type DragSourceRegistration, type DragStartEvent, type DropEdge, type DropIndicatorState, type DropTargetEvent, type DropTargetEventType, type DropTargetOptions, type DropTargetRect, type DropTargetRegistration, createDragAndDrop, defaultDragAnnouncements, readClipboardTransfer, readDragTransfer, useDragAndDrop, writeClipboardTransfer, writeDragTransfer };

package/dist/drag-and-drop.mjs

@@ -0,0 +1,2 @@
+import { a as readDragTransfer, h as defaultDragAnnouncements, i as readClipboardTransfer, n as useDragAndDrop, o as writeClipboardTransfer, r as DRAG_TRANSFER_TYPE, s as writeDragTransfer, t as createDragAndDrop } from "./drag-and-drop-BjYgWGcG.mjs";
+export { DRAG_TRANSFER_TYPE, createDragAndDrop, defaultDragAnnouncements, readClipboardTransfer, readDragTransfer, useDragAndDrop, writeClipboardTransfer, writeDragTransfer };

package/dist/empty-state-DtyOxCA4.mjs

@@ -0,0 +1,73 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { createBlock, defineComponent, openBlock, renderSlot, resolveDynamicComponent, useTemplateRef, withCtx } from "vue";
+//#region src/families/feedback/empty-state/empty-state.vue?vue&type=script&setup=true&lang.ts
+const state = "empty";
+//#endregion
+//#region src/families/feedback/empty-state/empty-state.vue
+var empty_state_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "empty-state",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "section"
+		},
+		tone: {
+			type: String,
+			required: false,
+			default: "neutral"
+		},
+		density: {
+			type: String,
+			required: false,
+			default: "comfortable"
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: "block"
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		__expose({
+			element,
+			get density() {
+				return __props.density;
+			},
+			get orientation() {
+				return __props.orientation;
+			},
+			state,
+			get tone() {
+				return __props.tone;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), {
+				ref_key: "element",
+				ref: element,
+				part: "root",
+				"data-vize-ui": "empty-state",
+				"data-state": "empty",
+				"data-tone": __props.tone,
+				"data-density": __props.density,
+				"data-orientation": __props.orientation
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					density: __props.density,
+					orientation: __props.orientation,
+					state,
+					tone: __props.tone
+				}, void 0, true)]),
+				_: 3
+			}, 8, [
+				"data-tone",
+				"data-density",
+				"data-orientation"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-2b0f370c"]]);
+//#endregion
+export { empty_state_default as t };

package/dist/empty-state.d.mts

@@ -0,0 +1,2 @@
+import { Cs as EmptyStateTone, Ss as EmptyStateState, _s as EmptyStateDensity, bs as EmptyStateOrientation, gs as _default, vs as EmptyStateElement, xs as EmptyStateSlotState, ys as EmptyStateExpose } from "./announcer-DGr2Iz0i.mjs";
+export { _default as EmptyState, type EmptyStateDensity, type EmptyStateElement, type EmptyStateExpose, type EmptyStateOrientation, type EmptyStateSlotState, type EmptyStateState, type EmptyStateTone };

package/dist/empty-state.mjs

@@ -0,0 +1,2 @@
+import { t as empty_state_default } from "./empty-state-DtyOxCA4.mjs";
+export { empty_state_default as EmptyState };

package/dist/error-summary-6Xis_769.d.mts

@@ -0,0 +1,65 @@
+import { n as ErrorSummaryField, r as ErrorSummaryOptions, t as ErrorSummaryController } from "./error-summary-types-5ePaC9O3.mjs";
+
+//#region src/families/form/error-summary/error-summary-runtime.d.ts
+/**
+ * Create the focus contract behind an error summary.
+ *
+ * When invalid fields appear the previously focused element is captured and
+ * focus moves to the summary; when every field is repaired that element gets
+ * focus back, provided focus has not been moved elsewhere in the meantime.
+ */
+declare function createErrorSummary(options?: ErrorSummaryOptions): ErrorSummaryController;
+/** Create an error summary controller disposed with the current Vue effect scope. */
+declare function useErrorSummary(options?: ErrorSummaryOptions): ErrorSummaryController;
+//#endregion
+//#region src/families/form/error-summary/error-summary.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Invalid fields in document order. Field ids must be unique.
+   *
+   * @default []
+   */
+  readonly fields?: readonly ErrorSummaryField[];
+  /**
+   * Text for the heading that labels the summary region.
+   *
+   * @default ""
+   */
+  readonly heading?: string;
+  /**
+   * Move focus into the summary when invalid fields appear.
+   *
+   * @default true
+   */
+  readonly autoFocus?: boolean;
+};
+type __VLS_Slots = {
+  /** Replaces the heading prop text inside the labelling element. */heading?(props: {
+    readonly fields: readonly ErrorSummaryField[];
+  }): unknown; /** Replaces one link's content; the default is label-prefixed message text. */
+  field?(props: {
+    readonly field: ErrorSummaryField;
+  }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+  hasErrors: import("vue").ComputedRef<boolean>;
+  focusSummary: () => boolean;
+  focusField: (id: string) => HTMLElement | null;
+  restoreFocus: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  fieldFocus: (field: ErrorSummaryField) => any;
+  restore: (target: HTMLElement | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onFieldFocus?: (field: ErrorSummaryField) => any;
+  onRestore?: (target: HTMLElement | null) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { createErrorSummary as n, useErrorSummary as r, _default as t };