@omnitend/dashboard-for-laravel 0.40.0 → 0.41.1

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

@@ -0,0 +1,47 @@
+interface Props {
+    /** Whether the switch is on. */
+    modelValue?: boolean;
+    /** Static text beside the toggle; the fallback when no contextual text applies. */
+    label?: string;
+    /** Text shown when on — overrides `label` in the on state (e.g. "Product is current"). */
+    textWhenTrue?: string;
+    /** Text shown when off — overrides `label` in the off state (e.g. "Product is not current"). */
+    textWhenFalse?: string;
+    /**
+     * On-state colour. `"success"` (default) reads the house green-on / red-off
+     * style — an active/enabled/good switch ("Product is current", "Stock is
+     * tracked", "Visible"). `"neutral"` is for semantically-mixed switches
+     * ("contains alcohol", an allergen toggle, "hidden on web shop") that
+     * shouldn't imply good/bad — it uses the brand primary on / grey off (#158).
+     */
+    onVariant?: "success" | "neutral";
+    /**
+     * `"sm"` renders a compact box (a few px shorter than the default, which
+     * matches the input height) for dense rows that repeat the switch per item (a
+     * per-line visibility toggle in a modal). Omit for the standard size, which
+     * lines the switch up with the `.form-control`
+     * height so a switch lines up with inputs beside it.
+     */
+    size?: "sm";
+}
+declare var __VLS_4: {
+    on: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_4) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    onVariant: "success" | "neutral";
+}, {}, {}, {}, 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

@@ -0,0 +1,495 @@
+import type { FieldDefinition, LabelCols } from "../../types";
+export type FilterType = 'text' | 'select' | 'select-native' | 'number' | 'date' | false;
+export interface FilterOption {
+    value: string;
+    text: string;
+}
+/**
+ * Adapts the built-in `apiUrl` provider's request/response to a backend whose
+ * convention differs from dfl's (spatie query-builder params, an envelope
+ * without the `{data, pagination}` shape). The sanctioned replacement for the
+ * axios-interceptor bridges #132 removed the route for: `request` maps the
+ * outgoing params (its return is what goes on the wire); `response` maps the
+ * body back, receiving the ORIGINAL dfl-shape params (`page`, `perPage`, …)
+ * so it can synthesize paginator metadata a foreign envelope lacks.
+ */
+export interface DXTableApiAdapter {
+    request?: (params: Record<string, any>) => Record<string, any>;
+    response?: (body: any, context: {
+        params: Record<string, any>;
+    }) => {
+        data: any[];
+        pagination?: PaginationData;
+        filterValues?: Record<string, string[]>;
+    };
+}
+export interface TableField {
+    key: string;
+    label?: string;
+    /**
+     * The key this column's filter is sent under, when it differs from the
+     * column's own key (default: `key`). Lets a *display* column filter on a
+     * different server param — e.g. a "Customer" column rendering a name but
+     * filtering on `customer_id` — instead of forcing the column to be named
+     * after the server's filter param and the human-facing value into a
+     * `#cell` slot.
+     */
+    filterKey?: string;
+    /**
+     * For a `select` filter: allow SEVERAL values at once (#51). The filter
+     * renders as a multi-select typeahead, the filters map holds an ARRAY of
+     * the chosen option values, and the query string carries Laravel bracket
+     * notation (`filters[status][]=active&filters[status][]=pending`).
+     * Client-side, a row matches when its value equals ANY chosen value. An
+     * empty selection means "no filter". The "All …" reset row is omitted in
+     * this mode (removing the chips/✕ is the way back); `filterNullText`
+     * stays available as a choosable value.
+     */
+    filterMultiple?: boolean;
+    /**
+     * For a `select` filter: adds an option meaning "has no value", e.g.
+     * `filterNullText: "Unassigned"` on an assignee column. Selecting it sends
+     * `filterNullValue` (default `"null"`) as the filter value; client-side, it
+     * matches rows whose value is null, undefined or empty.
+     */
+    filterNullText?: string;
+    /** The value sent when the `filterNullText` option is chosen. Default `"null"`. */
+    filterNullValue?: string;
+    /**
+     * Text of the "clear this filter" option at the top of a `select` filter's
+     * list (default: the filter's placeholder, e.g. "All statuses"). The list
+     * otherwise offers no way back to *unfiltered* once a value is picked —
+     * only the ✕, which isn't discoverable from inside the open dropdown.
+     */
+    filterAllText?: string;
+    sortable?: boolean;
+    hint?: string;
+    /**
+     * The inline filter control for this column, or `false`/omit for none. See
+     * `FilterType`. `'select'` (typeahead) and `'select-native'` (plain
+     * `<select>`) share the same options and value semantics — pick the native
+     * one when OS-native menu behaviour matters more than type-to-narrow.
+     */
+    filter?: FilterType;
+    filterOptions?: FilterOption[];
+    filterPlaceholder?: string;
+    /**
+     * For a `select` filter on a **client-side** table: derive the dropdown's
+     * options from the distinct values present in the loaded rows. Defaults to
+     * `true` — with no `filterOptions` and no server `filterValues` the
+     * alternative is an empty dropdown, which can only ever be a bug.
+     *
+     * Set `false` to opt out (e.g. a column whose raw values are opaque ids you
+     * would rather label yourself via `filterOptions`).
+     *
+     * Explicit `filterOptions` and server-supplied `filterValues` still WIN, in
+     * that order. Provider/API and Inertia modes ignore this flag: they only
+     * ever hold one page of rows, so there is no complete value set to derive
+     * from (see `getFieldFilterOptions`).
+     */
+    deriveFilterOptions?: boolean;
+    /**
+     * Fixed width for this column, applied via a `<colgroup>` `<col>`. A number
+     * is treated as pixels (`200` → `200px`); a string is used verbatim
+     * (`"20%"`, `"12rem"`). Pair with the table-level `fixedLayout` prop so the
+     * width is authoritative and the column stops resizing to fit its content —
+     * without `fixedLayout` a wider cell can still stretch the column (#156).
+     */
+    width?: string | number;
+    /**
+     * Minimum width for this column, applied via the same `<col>` as `width`.
+     * A number is pixels; a string is used verbatim.
+     */
+    minWidth?: string | number;
+    [key: string]: any;
+}
+export interface PaginationData {
+    current_page: number;
+    per_page: number;
+    total: number;
+    from: number;
+    to: number;
+    last_page?: number;
+    total_unfiltered?: number;
+}
+export interface BTableSortBy {
+    key: string;
+    order?: 'asc' | 'desc';
+}
+export interface BTableProviderContext {
+    sortBy?: BTableSortBy[];
+    filter?: string;
+    currentPage: number;
+    perPage: number;
+}
+export type BTableProvider<T = any> = (context: Readonly<BTableProviderContext>) => Promise<T[] | undefined> | T[] | undefined;
+export interface EditTab {
+    /** Unique key for this tab */
+    key: string;
+    /**
+     * Display label (optional, auto-derived from key if omitted). May be a
+     * function of the model (the edited row merged with the live form data),
+     * e.g. `label: (item) => \`Products (${item.products_count ?? 0})\``.
+     */
+    label?: string | ((item: any) => string);
+    /** Field keys to display in this tab (from editFields) */
+    fieldKeys: string[];
+    /** Conditional display (optional) */
+    when?: boolean | ((item: any) => boolean);
+    /** Lazy load tab content (optional, default false) */
+    lazy?: boolean;
+}
+/**
+ * Discriminated data-source descriptor (#130). The additive, type-safe
+ * replacement for the legacy `items` / `provider` / `apiUrl` / `inertiaUrl` /
+ * `clientSide` prop matrix, in which every prop was independently optional and
+ * the mode was inferred by precedence — so invalid combinations compiled and
+ * some were silently ignored.
+ *
+ * Pass ONE `source`: the mode is explicit and its required companion prop is
+ * enforced by the compiler (`{ mode: 'provider' }` without a `provider` won't
+ * type-check). The legacy props still work and take over when `source` is
+ * omitted; a future major removes them with a codemod (#130 Phase 3).
+ *
+ * `apiAdapter` (transport translation) and `pagination` (server-supplied page
+ * metadata) stay sibling props — they're orthogonal to which mode is active.
+ */
+export type DXTableSource<TItem = any> = {
+    mode: 'client';
+    items: TItem[];
+} | {
+    mode: 'provider';
+    provider: BTableProvider<TItem>;
+} | {
+    mode: 'api';
+    url: string;
+} | {
+    mode: 'inertia';
+    items: TItem[];
+    url?: string;
+};
+export interface Props<TItem = any> {
+    /** Table title */
+    title?: string;
+    /** Name for item (singular) - automatically pluralized (e.g., "product" → "products") */
+    itemName?: string;
+    /** Table data items (Inertia mode) */
+    items?: TItem[];
+    /** Provider function for API mode (alternative to items/apiUrl) */
+    provider?: BTableProvider<TItem>;
+    /** API endpoint URL for auto-provider mode (alternative to provider function) */
+    apiUrl?: string;
+    /** Adapts the built-in provider's request params / response body to a
+     *  backend convention that differs from dfl's (see DXTableApiAdapter). */
+    apiAdapter?: DXTableApiAdapter;
+    /**
+     * Discriminated data-source (#130) — the type-safe alternative to the
+     * legacy `items` / `provider` / `apiUrl` / `inertiaUrl` / `clientSide`
+     * props. When set it WINS over those props; when omitted, the legacy props
+     * apply unchanged. See `DXTableSource`.
+     */
+    source?: DXTableSource<TItem>;
+    /** Table field definitions */
+    fields: TableField[];
+    /** Sort configuration (v-model support) */
+    sortBy?: BTableSortBy[];
+    /** Filter values (v-model support) - key is field key, value is the filter
+     *  string, or an ARRAY of values for a `filterMultiple` column (#51). */
+    filters?: Record<string, string | string[]>;
+    /** Dynamic filter options from server - key is field key, value is array of values */
+    filterValues?: Record<string, string[]>;
+    /** Inertia route URL (if provided, handles navigation automatically) */
+    inertiaUrl?: string;
+    /** Loading/busy state (v-model support) */
+    busy?: boolean;
+    /** Loading state (deprecated, use busy instead) */
+    loading?: boolean;
+    /** Loading text */
+    loadingText?: string;
+    /** Error message */
+    error?: string | null;
+    /** Pagination data (Inertia mode) */
+    pagination?: PaginationData;
+    /** Show pagination controls */
+    showPagination?: boolean;
+    /** Show per-page selector */
+    showPerPageSelector?: boolean;
+    /**
+     * Show the footer's item-count caption ("N items." / "X to Y out of Z
+     * items."). Defaults to `true`. Set `false` to suppress just the caption,
+     * independent of the pager — a page ported from a plain `<b-table>` that
+     * hides the pager with `:show-pagination="false"` would otherwise gain a
+     * caption it never had (#127).
+     */
+    showCount?: boolean;
+    /** Per-page options for selector */
+    perPageOptions?: number[];
+    /** Current page (for provider mode) */
+    currentPage?: number;
+    /**
+     * Items per page. With a `v-model:per-page` it is controlled state; a bare
+     * `:per-page="20"` is the INITIAL page size (see the initial-value vs
+     * controlled note above). When passed explicitly it takes PRECEDENCE over any
+     * per-page preference persisted in localStorage — `:per-page="20"` always
+     * starts at 20, never a size the user once picked on another table (#124).
+     * Omit it to let a stored preference (URL-keyed tables only) or the default
+     * apply.
+     */
+    perPage?: number;
+    /** Striped (banded) rows. Off by default — banding adds little on short
+     *  tables and can read as noise; opt in with `:striped="true"`. */
+    striped?: boolean;
+    /** Hover effect on rows */
+    hover?: boolean;
+    /** Responsive table */
+    responsive?: boolean;
+    /** Fluid container */
+    fluid?: boolean;
+    /** Container CSS class */
+    containerClass?: string;
+    /** Column size (Bootstrap grid) */
+    columnSize?: string | number;
+    /**
+     * Wrap the table in a `DCard`. Defaults to `true`. Set `false` for a plain,
+     * borderless variant — the same header, filter row, table and pagination
+     * rendered directly on the page background (no card border/shadow), for
+     * data-heavy admin index pages that read as busy inside a card.
+     *
+     * The table renders FLUSH to the card border (rows and stripes reach the
+     * edge) while the header and pagination stay padded. Only the table region
+     * is rounded to follow the card's corners — the card itself does not clip
+     * (#166), so a `position: absolute` popover you render into `#header` or
+     * any other slot is free to overhang the card.
+     *
+     * The one place content is still clipped is INSIDE the table: Bootstrap's
+     * `.table-responsive` is a horizontal scroll container, so an overlay in a
+     * `cell(<key>)` slot is bounded by it. Teleport it (bvn's own menus already
+     * do — `DDropdown` teleports to `<body>`, the column-filter menus are
+     * `fixed`), or pass `:responsive="false"`.
+     */
+    card?: boolean;
+    /**
+     * Form field definitions for edit modal (if provided, enables edit on row
+     * click). `import type` is erased at compile time, so this creates no
+     * runtime import cycle (#131).
+     */
+    editFields?: FieldDefinition[];
+    /** Tab definitions for organizing edit modal content */
+    editTabs?: EditTab[];
+    /** Edit modal title (can be function for dynamic titles) */
+    editModalTitle?: string | ((item: any) => string);
+    /** Edit modal size */
+    editModalSize?: 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Field layout for the edit/create modal's form, forwarded to its `DXForm`
+     * ("vertical" = label above input, "horizontal" = label left). Defaults to
+     * **"horizontal"** to match the Omni Tend form convention (a raw modal form
+     * previously fell back to DXForm's vertical default, which looked out of
+     * place next to horizontal page forms). Pass `"vertical"` to opt out.
+     *
+     * `"auto"` hands the decision to `DXForm`'s container-width observer, which
+     * measures the FORM rather than the window — so a modal narrowed by its own
+     * breakpoint stacks to vertical even on a wide viewport, where a media query
+     * would still report "plenty of room". See `useContainerWidth`.
+     */
+    editLayout?: 'vertical' | 'horizontal' | 'auto';
+    /**
+     * Label column width for the edit modal's horizontal layout, forwarded to
+     * `DXForm`'s `labelCols` (a single width or a per-breakpoint object). Only
+     * meaningful when `editLayout` is "horizontal".
+     */
+    editLabelCols?: LabelCols;
+    /**
+     * Wrap the edit/create modal's form in a bordered card. Off by default (the
+     * modal body already provides a boundary); opt in for a more contained,
+     * panelled look around a tabbed edit form.
+     */
+    editCard?: boolean;
+    /** Override the modal's Save button label (default: "Save {item}"). */
+    saveText?: string;
+    /** Override the modal's Create button label (default: "Create {item}"). */
+    createText?: string;
+    /** Override the modal's Delete button label (default: "Delete {item}"). */
+    deleteText?: string;
+    /** API endpoint pattern for updates (e.g., "/api/products/:id") */
+    editUrl?: string;
+    /**
+     * API endpoint pattern to fetch the FULL record for the edit modal
+     * (e.g., "/api/products/:id"). When set, opening a row seeds the form from
+     * this fetch (shown with a loading state) instead of the thin list row —
+     * use when the list payload omits fields the edit form needs (notes, nested
+     * relations, repeater rows, …). The response is unwrapped from `data.data`
+     * (Laravel API Resource) or used as-is.
+     */
+    showUrl?: string;
+    /** API endpoint pattern for deletions (e.g., "/api/products/:id") */
+    deleteUrl?: string;
+    /**
+     * Guard run when Delete is clicked, before the confirm dialog and request.
+     * Return a message for a non-deletable item to show it immediately (as a
+     * toast) and skip both the confirm and the delete request; return
+     * `null`/`undefined` to proceed with the normal confirm + delete. Lets you
+     * short-circuit a doomed delete (e.g. a record with dependents that the
+     * server would reject) with an immediate, specific reason.
+     *
+     * AWAITED, so it may return a promise — the same shape as `saveGuard`, so
+     * an `async` guard behaves the way its author expects. A guard that throws
+     * also aborts, surfacing its message.
+     */
+    deleteGuard?: (item: TItem) => string | null | undefined | Promise<string | null | undefined>;
+    /**
+     * Guard run when the modal's Save/Create is clicked, before the request.
+     * Return a message to abort the save — it is shown immediately (as a toast)
+     * and no request is made; return `null`/`undefined` to proceed. Covers both
+     * the `editUrl` and `createUrl` paths.
+     *
+     * AWAITED (as `deleteGuard` is), so it may return a promise: the case it
+     * exists for is an async control in an `edit-value` slot — an image
+     * upload — that has not finished when Save is clicked. Without the guard the
+     * form submits the previous media map, the save SUCCEEDS, the toast says
+     * saved and the modal closes: the image is lost with no error anywhere,
+     * because every individual step worked. Await the upload here and the save
+     * simply waits for it.
+     *
+     * `item` is the row being edited, `null` in create mode (as in the
+     * `edit-value` slot's binding); `data` is the live form data. Aborting
+     * leaves the modal open with the user's edits intact. A guard that throws
+     * also aborts, surfacing its message.
+     *
+     * Dismissing the modal while the guard is still pending — by any route —
+     * abandons the save; nothing is written for a record the user has closed.
+     */
+    saveGuard?: (item: TItem | null, data: Record<string, any>) => string | null | undefined | Promise<string | null | undefined>;
+    /** API endpoint for creating new items (e.g., "/api/products") — enables "New" button */
+    createUrl?: string;
+    /**
+     * Render the built-in "New {item}" button in the card header (default
+     * `true` whenever `createUrl` is set). Set `false` to drive the create
+     * modal from your own trigger elsewhere — e.g. a button in the dashboard
+     * navbar's actions slot calling the exposed `openCreate()`. With no
+     * `title` and no `header` slot, the header is then dropped entirely
+     * rather than left empty.
+     */
+    showCreateButton?: boolean;
+    /**
+     * Render a `<tfoot>` mirroring the header row, so `#foot(<key>)` slots can
+     * hold per-column totals that line up under their data (#99). Without it
+     * there is no footer to put them in. For a fully custom footer, use the
+     * `custom-foot` slot instead.
+     */
+    footClone?: boolean;
+    /**
+     * Show a message row when there are no rows (default `true`). An empty
+     * table body is indistinguishable from a broken one, so the message is on
+     * by default. Override the wording with `emptyText`, or the whole row with
+     * the `empty` slot.
+     */
+    showEmpty?: boolean;
+    /**
+     * Message shown when there are no rows. Defaults to "No {items} found", or
+     * "No {items} match your filters" when a column filter is active.
+     */
+    emptyText?: string;
+    /**
+     * Rows currently expanded, as a `v-model`. Pair with the `row-expansion`
+     * slot to render detail content under a row (#112) instead of forcing every
+     * per-row detail into a modal.
+     */
+    expandedItems?: TItem[];
+    /**
+     * Class(es) applied to each row's `<tr>` — a string, or a function of the
+     * row. Use for conditional row styling (a variant, a muted/disabled look)
+     * without reaching into the table's internal DOM from global CSS.
+     */
+    rowClass?: string | ((item: TItem, index: number) => string | string[] | Record<string, boolean>);
+    /**
+     * Whether a given row is actionable. Only relevant when rows are clickable
+     * (an `editFields` modal or a `row-clicked` listener). A row this returns
+     * `false` for gets no pointer cursor, no hover highlight, and does not fire
+     * `row-clicked` or open the edit modal — so a row that isn't clickable
+     * doesn't *look* clickable, and a click on it can't quietly do something.
+     */
+    rowClickable?: (item: TItem, index: number) => boolean;
+    /** Enable client-side filtering, sorting, and pagination on items array */
+    clientSide?: boolean;
+    /**
+     * Apply `table-layout: fixed` to the underlying table. Off by default, so
+     * existing tables keep their content-sized columns. When on, column widths
+     * stop depending on cell content, so they no longer reshuffle when a filter
+     * narrows the rows — the table stays put as you filter (#156). Combine with
+     * per-field `width`/`minWidth` to control the proportions; columns with no
+     * declared width share the remaining space equally.
+     */
+    fixedLayout?: boolean;
+    /**
+     * Field on each row whose value uniquely identifies it, forwarded to the
+     * inner bvn table's `primaryKey` (all three data modes). Without it bvn keys
+     * client-side rows by their INDEX, which mis-associates per-row STATEFUL cell
+     * components when a row is inserted/removed mid-interaction — a debounced
+     * edit in one row can end up saved against the wrong record after a
+     * concurrent delete of a row above. Set it (e.g. `primary-key="id"`) so bvn
+     * keys rows by that field's value and each row keeps its identity across
+     * data mutations. Non-breaking: omit it and rows key by index exactly as
+     * before.
+     */
+    primaryKey?: string;
+}
+declare const _default: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onRowCreated?: ((item: any, response: any) => any) | undefined;
+        readonly onCreateError?: ((error: any) => any) | undefined;
+        readonly onRowUpdated?: ((item: T, response: any) => any) | undefined;
+        readonly onEditError?: ((item: T, error: any) => any) | undefined;
+        readonly onRowDeleted?: ((item: T, response: any) => any) | undefined;
+        readonly onDeleteError?: ((item: T, error: any) => any) | undefined;
+        readonly "onUpdate:sortBy"?: ((sortBy: BTableSortBy[]) => any) | undefined;
+        readonly "onUpdate:busy"?: ((busy: boolean) => any) | undefined;
+        readonly onRowClicked?: ((item: T, index: number, event: MouseEvent) => any) | undefined;
+        readonly "onUpdate:expandedItems"?: ((items: T[]) => any) | undefined;
+        readonly onPageChange?: ((page: number) => any) | undefined;
+        readonly onSortChange?: ((sort: {
+            key: string;
+            order: "asc" | "desc";
+        }) => any) | undefined;
+        readonly onFilterChange?: ((filters: Record<string, string | string[]>) => any) | undefined;
+        readonly onPerPageChange?: ((perPage: number) => any) | undefined;
+        readonly "onUpdate:filters"?: ((filters: Record<string, string | string[]>) => any) | undefined;
+        readonly "onUpdate:perPage"?: ((perPage: number) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:sortBy" | "onUpdate:busy" | "onRowClicked" | "onUpdate:expandedItems" | "onRowCreated" | "onCreateError" | "onRowUpdated" | "onEditError" | "onRowDeleted" | "onDeleteError" | "onPageChange" | "onSortChange" | "onFilterChange" | "onPerPageChange" | "onUpdate:filters" | "onUpdate:perPage"> & Props<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        refresh: () => void;
+        /**
+         * Open the built-in create modal (same as clicking the default "New {item}"
+         * button). Lets the create action live outside the table card — e.g. in a
+         * page header or the dashboard navbar. No-op unless `editFields` are set.
+         */
+        openCreate: () => void;
+    }>): void;
+    attrs: any;
+    slots: {
+        [x: `head-end(${string})`]: ((props: {
+            field: TableField;
+            label: string;
+        }) => any) | undefined;
+    } & {
+        [x: string]: ((props: any) => any) | undefined;
+    } & {
+        [x: string]: ((props: any) => any) | undefined;
+    } & {
+        header?: (props: {}) => any;
+    } & {
+        'thead-top'?: (props: any) => any;
+    } & {
+        'thead-sub'?: (props: any) => any;
+    };
+    emit: ((evt: "rowCreated", item: any, response: any) => void) & ((evt: "createError", error: any) => void) & ((evt: "rowUpdated", item: T, response: any) => void) & ((evt: "editError", item: T, error: any) => void) & ((evt: "rowDeleted", item: T, response: any) => void) & ((evt: "deleteError", item: T, error: any) => void) & ((evt: "update:sortBy", sortBy: BTableSortBy[]) => void) & ((evt: "update:busy", busy: boolean) => void) & ((evt: "rowClicked", item: T, index: number, event: MouseEvent) => void) & ((evt: "update:expandedItems", items: T[]) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "sortChange", sort: {
+        key: string;
+        order: "asc" | "desc";
+    }) => void) & ((evt: "filterChange", filters: Record<string, string | string[]>) => void) & ((evt: "perPageChange", perPage: number) => void) & ((evt: "update:filters", filters: Record<string, string | string[]>) => void) & ((evt: "update:perPage", perPage: number) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,100 @@
+import type { EditTab } from "./DXTable.vue";
+import type { LabelCols } from "../../types";
+interface Props {
+    /** Whether the modal is open (v-model:show). */
+    show: boolean;
+    /** Modal title. */
+    title: string;
+    /** Modal size. */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** True while the full record is loading via showUrl. */
+    loading: boolean;
+    /** The edit/create form (a useForm instance), or null before first open. */
+    form: any;
+    /** Bumped per modal open to remount the DXForm subtree (fresh DXField state). */
+    formInstanceKey: number;
+    /** Active tab index (v-model:active-tab). */
+    activeTab: number;
+    /** Field definitions passed to DXForm. */
+    fields: any[];
+    /** Tab definitions passed to DXForm. */
+    tabs?: EditTab[];
+    /** The row being edited (null in create mode) — the slot/context row. */
+    item: any;
+    /** Whether the modal is in create mode (vs edit). */
+    isCreateMode: boolean;
+    /** Which action is in flight, so Save/Delete show their own loading label. */
+    pendingAction: 'save' | 'delete' | null;
+    /** Delete endpoint — gates the Delete button. */
+    deleteUrl?: string;
+    /**
+     * Field layout forwarded to the modal's DXForm (defaults handled upstream).
+     * Includes `"auto"`, which lets the form stack to vertical when the MODAL is
+     * narrow even though the viewport is wide — the container-query case a
+     * viewport media query cannot see.
+     */
+    layout?: 'vertical' | 'horizontal' | 'auto';
+    /** Label column width forwarded to DXForm (horizontal layout). */
+    labelCols?: LabelCols;
+    /** Wrap the modal form in a card (opt-in — off by default). */
+    card?: boolean;
+    /** Singular item noun for the default button labels (e.g. "customer"). */
+    itemName?: string;
+    /** Override the Save button label (edit mode). */
+    saveText?: string;
+    /** Override the Create button label (create mode). */
+    createText?: string;
+    /** Override the Delete button label. */
+    deleteText?: string;
+}
+declare var __VLS_21: `edit-value(${string})`, __VLS_22: {
+    item: any;
+    value: any;
+    update: any;
+    field: any;
+}, __VLS_25: `edit-span(${string})`, __VLS_26: {
+    item: any;
+    value: any;
+    update: any;
+    close: () => void;
+}, __VLS_29: `tab-content(${string})`, __VLS_30: {
+    item: any;
+    tab: any;
+}, __VLS_33: `tab-before(${string})`, __VLS_34: {
+    item: any;
+    tab: any;
+}, __VLS_37: `tab-after(${string})`, __VLS_38: {
+    item: any;
+    tab: any;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_21>]?: (props: typeof __VLS_22) => any;
+} & {
+    [K in NonNullable<typeof __VLS_25>]?: (props: typeof __VLS_26) => any;
+} & {
+    [K in NonNullable<typeof __VLS_29>]?: (props: typeof __VLS_30) => any;
+} & {
+    [K in NonNullable<typeof __VLS_33>]?: (props: typeof __VLS_34) => any;
+} & {
+    [K in NonNullable<typeof __VLS_37>]?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    delete: () => any;
+    "update:activeTab": (value: number) => any;
+    save: () => any;
+    "update:show": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onDelete?: (() => any) | undefined;
+    "onUpdate:activeTab"?: ((value: number) => any) | undefined;
+    onSave?: (() => any) | undefined;
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+    };
+};