nuxt-ui-tools 0.1.0

package/dist/runtime/table/composables/use-table-state.d.ts

@@ -0,0 +1,52 @@
+import { type ComputedRef } from 'vue';
+import type { TableResolvedFilterGroup, TableSchemaView } from '../types/index.js';
+import type { useTableLayout } from './use-table-layout.js';
+export interface UseTableStateParams {
+    schema: ComputedRef<TableSchemaView>;
+    layout: ReturnType<typeof useTableLayout>;
+}
+export declare function useTableState(params: UseTableStateParams): {
+    queryState: {
+        pagination: ComputedRef<{
+            readonly mode: "none";
+            readonly cursor?: undefined;
+            readonly pageSize?: undefined;
+            readonly count?: undefined;
+            readonly pageIndex?: undefined;
+        } | {
+            readonly mode: "cursor";
+            readonly cursor: null;
+            readonly pageSize: number;
+            readonly count: "exact" | "none";
+            readonly pageIndex?: undefined;
+        } | {
+            readonly mode: "offset";
+            readonly pageIndex: number;
+            readonly pageSize: number;
+            readonly count: "exact";
+            readonly cursor?: undefined;
+        }>;
+        paginationMode: "none" | "offset" | "cursor";
+        paginationRevision: import("vue").Ref<number, number>;
+        resetPagination: () => void;
+        setOffsetPagination: (value: {
+            pageIndex: number;
+            pageSize: number;
+        }) => void;
+        sorting: import("vue").WritableComputedRef<{
+            key: string;
+            dir: "desc" | "asc";
+        } | null, {
+            key: string;
+            dir: "asc" | "desc";
+        } | null>;
+        filters: import("vue").WritableComputedRef<{
+            search: string;
+            ui: import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[];
+        }, {
+            search: string;
+            ui: import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[];
+        }>;
+    };
+    resolvedFilterState: ComputedRef<TableResolvedFilterGroup<string>>;
+};

package/dist/runtime/table/composables/use-table-state.js

@@ -0,0 +1,20 @@
+import { computed } from "vue";
+import { createResolvedFilterState } from "../utils/index.js";
+import { useQueryState } from "./use-query-state.js";
+export function useTableState(params) {
+  const queryState = useQueryState({
+    schema: params.schema,
+    activeLayout: params.layout.activeLayout
+  });
+  const resolvedFilterState = computed(
+    () => createResolvedFilterState({
+      definitions: params.schema.value.filters?.ui ?? [],
+      filters: queryState.filters.value,
+      staticFilters: params.schema.value.filters?.static
+    })
+  );
+  return {
+    queryState,
+    resolvedFilterState
+  };
+}

package/dist/runtime/table/composables/use-table.d.ts

@@ -0,0 +1,7 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { TableApi } from '../types/index.js';
+import { type TableInternals } from './use-table-internals.js';
+export declare function useTable<TSchema>(schema: MaybeRefOrGetter<TSchema>): TableApi<TSchema> & {
+    schema: ComputedRef<TSchema>;
+    __internals: TableInternals;
+};

package/dist/runtime/table/composables/use-table.js

@@ -0,0 +1,13 @@
+import { computed, toValue } from "vue";
+import { createTableInternals } from "./use-table-internals.js";
+export function useTable(schema) {
+  const resolvedSchema = computed(() => toValue(schema));
+  const internals = createTableInternals({
+    rawSchema: resolvedSchema
+  });
+  return {
+    ...internals.tableApi,
+    schema: resolvedSchema,
+    __internals: internals
+  };
+}

package/dist/runtime/table/constants/grid.d.ts

@@ -0,0 +1,8 @@
+export declare const GRID_DEFAULTS: {
+    readonly mode: "flow";
+    readonly columns: 1;
+    readonly itemSpan: 1;
+    readonly estimatedRowHeight: 272;
+    readonly skeletonRows: 6;
+    readonly overscan: 3;
+};

package/dist/runtime/table/constants/grid.js

@@ -0,0 +1,8 @@
+export const GRID_DEFAULTS = {
+  mode: "flow",
+  columns: 1,
+  itemSpan: 1,
+  estimatedRowHeight: 272,
+  skeletonRows: 6,
+  overscan: 3
+};

package/dist/runtime/table/constants/query-state.d.ts

@@ -0,0 +1,25 @@
+import type { TableFilterOperator, TableQueryStateFilterKind } from '../types/query-state.js';
+export declare const DEFAULT_FILTER_OPERATOR: Record<TableQueryStateFilterKind, TableFilterOperator>;
+export declare const PAGINATION_DEFAULTS: {
+    defaultSize: {
+        grid: number;
+        table: number;
+    };
+    sizes: {
+        grid: number[];
+        table: number[];
+    };
+};
+/** Default TanStack Query options applied to all table queries. */
+export declare const QUERY_DEFAULTS: {
+    /** How long fetched data is considered fresh (ms). Prevents refetches on remount/focus. */
+    staleTime: {
+        /** Main data query */
+        data: number;
+        /** Context / page-context side queries */
+        context: number;
+        /** Filter option queries (facets, remote options) */
+        filterOptions: number;
+    };
+    refetchOnWindowFocus: boolean;
+};

package/dist/runtime/table/constants/query-state.js

@@ -0,0 +1,26 @@
+export const DEFAULT_FILTER_OPERATOR = {
+  text: "contains",
+  option: "isAnyOf",
+  boolean: "is",
+  number: "is",
+  date: "is"
+};
+export const PAGINATION_DEFAULTS = {
+  defaultSize: { grid: 10, table: 50 },
+  sizes: {
+    grid: [10, 20, 50, 100],
+    table: [10, 20, 50, 100, 200, 500]
+  }
+};
+export const QUERY_DEFAULTS = {
+  /** How long fetched data is considered fresh (ms). Prevents refetches on remount/focus. */
+  staleTime: {
+    /** Main data query */
+    data: 3e4,
+    /** Context / page-context side queries */
+    context: 6e4,
+    /** Filter option queries (facets, remote options) */
+    filterOptions: 3e4
+  },
+  refetchOnWindowFocus: false
+};

package/dist/runtime/table/index.d.ts

@@ -0,0 +1,5 @@
+export * from './builders/index.js';
+export { useTable } from './composables/use-table.js';
+export { defineTableSchema } from './schema/index.js';
+export type * from './types';
+export * from './utils/index.js';

package/dist/runtime/table/index.js

@@ -0,0 +1,4 @@
+export * from "./builders/index.js";
+export { useTable } from "./composables/use-table.js";
+export { defineTableSchema } from "./schema/index.js";
+export * from "./utils/index.js";

package/dist/runtime/table/schema/index.d.ts

@@ -0,0 +1,15 @@
+import type { BuildTableSchema, InferTableSourceRow, ResolvedTableSchema, TableContextDataFromItems, TableContextItem, TableKnownFieldPath, TablePageContextItem, TablePaginationSchema, TableSource } from '../types/index.js';
+type InferredTableSchema<TSource extends TableSource<any, any, any>, TContextItems extends TableContextItem[], TPageContextItems extends TablePageContextItem<InferTableSourceRow<TSource>, TableContextDataFromItems<TContextItems>>[]> = BuildTableSchema<TSource, TContextItems, TPageContextItems, TableKnownFieldPath<InferTableSourceRow<TSource>>, TableKnownFieldPath<InferTableSourceRow<TSource>>>;
+type PaginationSourceConstraint<TPagination> = TPagination extends {
+    mode: 'cursor';
+} ? {
+    source: {
+        mode: 'remote';
+    };
+} : object;
+export declare function defineTableSchema<const TSource extends TableSource<any, any, any> = TableSource<any, any, any>, TContextItems extends TableContextItem[] = TableContextItem[], TPageContextItems extends TablePageContextItem<InferTableSourceRow<TSource>, TableContextDataFromItems<TContextItems>>[] = TablePageContextItem<InferTableSourceRow<TSource>, TableContextDataFromItems<TContextItems>>[], const TPagination extends TablePaginationSchema | undefined = undefined>(schema: InferredTableSchema<TSource, TContextItems, TPageContextItems> & {
+    pagination?: TPagination;
+} & PaginationSourceConstraint<TPagination>): ResolvedTableSchema<InferredTableSchema<TSource, TContextItems, TPageContextItems>> & {
+    pagination: TPagination;
+};
+export {};

package/dist/runtime/table/schema/index.js

@@ -0,0 +1,16 @@
+import { resolveColumns, resolveUiFilters } from "../builders/index.js";
+export function defineTableSchema(schema) {
+  return {
+    ...schema,
+    table: schema.table ? {
+      ...schema.table,
+      columns: resolveColumns(
+        schema.table.columns
+      )
+    } : void 0,
+    filters: schema.filters ? {
+      ...schema.filters,
+      ui: resolveUiFilters(schema.filters.ui)
+    } : void 0
+  };
+}

package/dist/runtime/table/types/actions.d.ts

@@ -0,0 +1,32 @@
+import type { DropdownMenuItem } from '@nuxt/ui';
+import type { TableSourceRequestContext } from './source.js';
+import type { GenericObject, MaybePromise, TableLayout, TableRowRenderParams, TableTextValue } from './utils.js';
+export interface TableActionContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> {
+    selectedRows: TRow[];
+    context: TContext;
+    pageContext: TPageContext;
+    request: TableSourceRequestContext<TRow, TContext>;
+}
+export interface TableToolbarAction<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends Omit<DropdownMenuItem, 'children' | 'disabled' | 'loading' | 'label' | 'onSelect'> {
+    key: string;
+    label?: TableTextValue;
+    condition?: boolean | ((context: TContext) => boolean);
+    disabled?: boolean | ((context: TableActionContext<TRow, TContext, TPageContext>) => boolean);
+    loading?: boolean | ((context: TableActionContext<TRow, TContext, TPageContext>) => boolean);
+    action?: (context: TableActionContext<TRow, TContext, TPageContext>) => MaybePromise<unknown>;
+}
+export interface TableBulkAction<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableToolbarAction<TRow, TContext, TPageContext> {
+    requiresSelection?: boolean;
+}
+export interface TableRowActionContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableRowRenderParams<TRow, TContext, TPageContext> {
+    layout: TableLayout;
+}
+export interface TableRowAction<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends Omit<DropdownMenuItem, 'children' | 'disabled' | 'loading' | 'label' | 'onSelect'> {
+    key: string;
+    label?: TableTextValue;
+    condition?: boolean | ((context: TableRowActionContext<TRow, TContext, TPageContext>) => boolean);
+    disabled?: boolean | ((context: TableRowActionContext<TRow, TContext, TPageContext>) => boolean);
+    loading?: boolean | ((context: TableRowActionContext<TRow, TContext, TPageContext>) => boolean);
+    children?: TableRowAction<TRow, TContext, TPageContext>[];
+    action?: (context: TableRowActionContext<TRow, TContext, TPageContext>) => MaybePromise<unknown>;
+}

package/dist/runtime/table/types/columns.d.ts

@@ -0,0 +1,62 @@
+import type { GenericObject, RenderableType, TableColumnAlign, TableColumnPinned, TableKnownFieldPath, TableFieldValue, TableRowRenderParams, TableSortKey, TableTextValue } from './utils.js';
+export interface TableColumnCellDataAttributes {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+}
+export type TableColumnCellProps = Record<string, unknown> & TableColumnCellDataAttributes;
+interface TableColumnBase<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TParams extends TableRowRenderParams<TRow, TContext, TPageContext> = TableRowRenderParams<TRow, TContext, TPageContext>> {
+    key: TKey;
+    label?: TableTextValue | (() => RenderableType);
+    icon?: string;
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    sortable?: boolean;
+    pinned?: TableColumnPinned;
+    align?: TableColumnAlign;
+    labelAlign?: TableColumnAlign;
+    ellipsis?: boolean | Record<string, unknown>;
+    resizable?: boolean;
+    condition?: () => boolean;
+    enabled?: boolean;
+    required?: boolean;
+    visible?: boolean | ((context: TContext) => boolean);
+    cellProps?: (params: TParams) => TableColumnCellProps;
+    colSpan?: (params: TParams) => number;
+    rowSpan?: (params: TParams) => number;
+    labelRowSpan?: (params: TParams) => number;
+    meta?: {
+        pageContext?: TPageContext;
+    };
+}
+export type TableFieldRenderParams<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> = TableRowRenderParams<TRow, TContext, TPageContext> & {
+    value: TableFieldValue<TRow, TField>;
+};
+interface TableFieldColumnBase<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> extends TableColumnBase<TRow, TContext, TPageContext, Extract<TField, string>, TableFieldRenderParams<TRow, TContext, TPageContext, TField>> {
+    kind: 'field';
+    field: TField;
+    render?: (params: TableFieldRenderParams<TRow, TContext, TPageContext, TField>) => RenderableType;
+}
+export type TableFieldColumn<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> = TableFieldColumnBase<TRow, TContext, TPageContext, TField>;
+type TableAnyFieldColumn<TRow extends GenericObject, TContext extends GenericObject, TPageContext extends GenericObject> = {
+    [TField in TableKnownFieldPath<TRow>]: TableFieldColumn<TRow, TContext, TPageContext, TField>;
+}[TableKnownFieldPath<TRow>];
+export interface TableCompositeColumn<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TSortKey extends string = TableSortKey<TRow>> extends TableColumnBase<TRow, TContext, TPageContext, TKey> {
+    kind: 'composite';
+    sortableKey?: TSortKey;
+    render: (params: TableRowRenderParams<TRow, TContext, TPageContext>) => RenderableType;
+}
+export interface TableDisplayColumn<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string> extends TableColumnBase<TRow, TContext, TPageContext, TKey> {
+    kind: 'display';
+    render: (params: TableRowRenderParams<TRow, TContext, TPageContext>) => RenderableType;
+}
+export type TableColumn<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TSortKey extends string = TableSortKey<TRow>> = TableAnyFieldColumn<TRow, TContext, TPageContext> | TableCompositeColumn<TRow, TContext, TPageContext, TKey, TSortKey> | TableDisplayColumn<TRow, TContext, TPageContext, TKey>;
+export type TableFieldColumnOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> = Omit<TableFieldColumn<TRow, TContext, TPageContext, TField>, 'field' | 'key' | 'kind'>;
+export type TableCompositeColumnOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TSortKey extends string = TableSortKey<TRow>> = Omit<TableCompositeColumn<TRow, TContext, TPageContext, TKey, TSortKey>, 'key' | 'kind'>;
+export type TableDisplayColumnOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string> = Omit<TableDisplayColumn<TRow, TContext, TPageContext, TKey>, 'key' | 'kind'>;
+export interface TableColumnBuilder<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
+    field<TField extends TableKnownFieldPath<TRow>>(field: TField, options?: TableFieldColumnOptions<TRow, TContext, TPageContext, TField>): TableFieldColumn<TRow, TContext, TPageContext, TField>;
+    composite<TKey extends string>(key: TKey, options: TableCompositeColumnOptions<TRow, TContext, TPageContext, TKey, TSortKey>): TableCompositeColumn<TRow, TContext, TPageContext, TKey, TSortKey>;
+    display<TKey extends string>(key: TKey, options: TableDisplayColumnOptions<TRow, TContext, TPageContext, TKey>): TableDisplayColumn<TRow, TContext, TPageContext, TKey>;
+}
+export type TableColumnCollection<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TSortKey extends string = TableSortKey<TRow>> = TableColumn<TRow, TContext, TPageContext, TKey, TSortKey>[] | ((column: TableColumnBuilder<TRow, TContext, TPageContext, TSortKey>) => TableColumn<TRow, TContext, TPageContext, TKey, TSortKey>[]);
+export {};

package/dist/runtime/table/types/context.d.ts

@@ -0,0 +1,26 @@
+import type { TableQueryDefinition } from './source.js';
+import type { GenericObject, Prettify, UnionToIntersection } from './utils.js';
+export interface TableContextItem<TKey extends string = string, TValue = unknown> {
+    key: TKey;
+    query: () => TableQueryDefinition<TValue>;
+    condition?: () => boolean;
+}
+export interface TablePageContextItem<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = string, TValue = unknown> {
+    key: TKey;
+    query: (ctx: {
+        rows: TRow[];
+        context: TContext;
+    }) => TableQueryDefinition<TValue>;
+    condition?: () => boolean;
+}
+type ContextItemRecord<TItem> = TItem extends {
+    key: infer TKey extends string;
+} ? {
+    [K in TKey]: TItem extends {
+        query: (...args: any[]) => infer TQuery;
+    } ? TQuery extends {
+        queryFn?: (...args: never[]) => Promise<infer TValue> | (infer TValue);
+    } ? Awaited<TValue> : TQuery extends TableQueryDefinition<infer TValue> ? Awaited<TValue> : never : never;
+} : {};
+export type TableContextDataFromItems<TItems extends unknown[]> = Prettify<UnionToIntersection<ContextItemRecord<TItems[number]>>>;
+export {};

package/dist/runtime/table/types/data-list.d.ts

@@ -0,0 +1,246 @@
+export type DataListDensity = 'compact' | 'default' | 'comfortable';
+export type DataListControlSize = 'xs' | 'sm' | 'md' | 'lg';
+export type DataListContentFit = 'content' | 'height' | 'fill';
+/** A Tailwind class override for a named DataList UI slot. */
+export type DataListUiClass = string;
+/** UI slots rendered by the built-in DataList recipe. */
+export interface DataListDefaultUi {
+    root?: DataListUiClass;
+    header?: DataListUiClass;
+    heading?: DataListUiClass;
+    title?: DataListUiClass;
+    description?: DataListUiClass;
+    toolbar?: DataListUiClass;
+    primaryActions?: DataListUiClass;
+    secondaryActions?: DataListUiClass;
+}
+/** UI slots forwarded to the underlying Nuxt UI input. */
+export interface DataListSearchUi {
+    [slot: string]: DataListUiClass | undefined;
+    root?: DataListUiClass;
+    base?: DataListUiClass;
+    leading?: DataListUiClass;
+    leadingIcon?: DataListUiClass;
+    leadingAvatar?: DataListUiClass;
+    leadingAvatarSize?: DataListUiClass;
+    trailing?: DataListUiClass;
+    trailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by filter tags and their adjacent actions. */
+export interface DataListFilterTagsUi {
+    root?: DataListUiClass;
+    trigger?: DataListUiClass;
+    label?: DataListUiClass;
+    value?: DataListUiClass;
+    dismiss?: DataListUiClass;
+    addTrigger?: DataListUiClass;
+    clearTrigger?: DataListUiClass;
+}
+/** UI slots rendered by the add-filter picker. */
+export interface DataListAddFilterUi {
+    trigger?: DataListUiClass;
+    popoverContent?: DataListUiClass;
+    panel?: DataListUiClass;
+    option?: DataListUiClass;
+    optionIcon?: DataListUiClass;
+    optionLabel?: DataListUiClass;
+    optionTrailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by the filter slideover. */
+export interface DataListFilterPanelUi {
+    trigger?: DataListUiClass;
+    triggerContent?: DataListUiClass;
+    count?: DataListUiClass;
+    overlay?: DataListUiClass;
+    content?: DataListUiClass;
+    header?: DataListUiClass;
+    wrapper?: DataListUiClass;
+    body?: DataListUiClass;
+    footer?: DataListUiClass;
+    title?: DataListUiClass;
+    description?: DataListUiClass;
+    close?: DataListUiClass;
+    fields?: DataListUiClass;
+    footerActions?: DataListUiClass;
+    clear?: DataListUiClass;
+    apply?: DataListUiClass;
+}
+/** UI slots rendered by the clear-filters control. */
+export interface DataListClearFiltersUi {
+    [slot: string]: DataListUiClass | undefined;
+    base?: DataListUiClass;
+    label?: DataListUiClass;
+    leadingIcon?: DataListUiClass;
+    trailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by the result count. */
+export interface DataListResultCountUi {
+    root?: DataListUiClass;
+}
+/** UI slots rendered by the refresh control. */
+export interface DataListRefreshUi {
+    [slot: string]: DataListUiClass | undefined;
+    base?: DataListUiClass;
+    label?: DataListUiClass;
+    leadingIcon?: DataListUiClass;
+    trailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by the column picker. */
+export interface DataListColumnPanelUi {
+    trigger?: DataListUiClass;
+    popoverContent?: DataListUiClass;
+    panel?: DataListUiClass;
+    searchHeader?: DataListUiClass;
+    search?: DataListUiClass;
+    list?: DataListUiClass;
+    section?: DataListUiClass;
+    row?: DataListUiClass;
+    handle?: DataListUiClass;
+    icon?: DataListUiClass;
+    label?: DataListUiClass;
+    stateIcon?: DataListUiClass;
+    empty?: DataListUiClass;
+    footer?: DataListUiClass;
+    footerSummary?: DataListUiClass;
+    reset?: DataListUiClass;
+}
+/** UI slots rendered by the sort dropdown. */
+export interface DataListSortMenuUi {
+    trigger?: DataListUiClass;
+    triggerLabel?: DataListUiClass;
+    triggerLeadingIcon?: DataListUiClass;
+    triggerTrailingIcon?: DataListUiClass;
+    content?: DataListUiClass;
+    group?: DataListUiClass;
+    item?: DataListUiClass;
+    itemLeadingIcon?: DataListUiClass;
+    itemLabel?: DataListUiClass;
+    itemTrailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by the table/grid switcher. */
+export interface DataListLayoutSwitchUi {
+    root?: DataListUiClass;
+    trigger?: DataListUiClass;
+    triggerLabel?: DataListUiClass;
+    triggerLeadingIcon?: DataListUiClass;
+    triggerTrailingIcon?: DataListUiClass;
+}
+/** UI slots rendered by the content state boundary. */
+export interface DataListContentUi {
+    root?: DataListUiClass;
+    error?: DataListUiClass;
+    errorBody?: DataListUiClass;
+    errorTitle?: DataListUiClass;
+    retry?: DataListUiClass;
+}
+/** UI slots rendered by the table mode. Nuxt UI table slots are forwarded unchanged. */
+export interface DataListTableUi {
+    root?: DataListUiClass;
+    base?: DataListUiClass;
+    caption?: DataListUiClass;
+    thead?: DataListUiClass;
+    tbody?: DataListUiClass;
+    tfoot?: DataListUiClass;
+    tr?: DataListUiClass;
+    th?: DataListUiClass;
+    td?: DataListUiClass;
+    separator?: DataListUiClass;
+    empty?: DataListUiClass;
+    loading?: DataListUiClass;
+    loadingOverlay?: DataListUiClass;
+    emptyOverlay?: DataListUiClass;
+}
+/** UI slots rendered by the grid mode and its built-in states. */
+export interface DataListGridUi {
+    root?: DataListUiClass;
+    viewport?: DataListUiClass;
+    canvas?: DataListUiClass;
+    row?: DataListUiClass;
+    item?: DataListUiClass;
+    flow?: DataListUiClass;
+    loading?: DataListUiClass;
+    error?: DataListUiClass;
+    errorCard?: DataListUiClass;
+    errorIcon?: DataListUiClass;
+    errorCopy?: DataListUiClass;
+    errorTitle?: DataListUiClass;
+    errorDescription?: DataListUiClass;
+    retry?: DataListUiClass;
+    empty?: DataListUiClass;
+    emptyCard?: DataListUiClass;
+    emptyIcon?: DataListUiClass;
+    emptyCopy?: DataListUiClass;
+    emptyTitle?: DataListUiClass;
+    emptyDescription?: DataListUiClass;
+    refreshing?: DataListUiClass;
+    refreshingLine?: DataListUiClass;
+    refreshingVeil?: DataListUiClass;
+}
+/** UI slots rendered by offset pagination. */
+export interface DataListPaginationUi {
+    root?: DataListUiClass;
+    inner?: DataListUiClass;
+    summary?: DataListUiClass;
+    controls?: DataListUiClass;
+    pageSize?: DataListUiClass;
+    pages?: DataListUiClass;
+    button?: DataListUiClass;
+}
+/** UI slots rendered by cursor pagination's automatic or manual loader. */
+export interface DataListInfiniteLoaderUi {
+    root?: DataListUiClass;
+    loading?: DataListUiClass;
+    retry?: DataListUiClass;
+    loadMore?: DataListUiClass;
+    end?: DataListUiClass;
+}
+export interface DataListPartConfig<TUi> {
+    /** Overrides the control size derived from the DataList density. */
+    size?: DataListControlSize;
+    /** Named class slots for this granular component. */
+    ui?: TUi;
+}
+export interface DataListSearchConfig extends DataListPartConfig<DataListSearchUi> {
+    /** CSS width for the search input; it remains capped to its container. */
+    width?: string;
+}
+/**
+ * Page-wide defaults for the granular DataList components.
+ *
+ * Values from `app.config.nuxtUiTools.dataList` are merged first, then the
+ * `DataListRoot` prop, then a granular component's own props and `ui` slots.
+ */
+export interface DataListUiConfig {
+    /** Default control density for the composed page. */
+    density?: DataListDensity;
+    /** Shared size fallback for controls that do not declare their own size. */
+    control?: {
+        size?: DataListControlSize;
+    };
+    default?: {
+        ui?: DataListDefaultUi;
+    };
+    search?: DataListSearchConfig;
+    filterTags?: DataListPartConfig<DataListFilterTagsUi>;
+    addFilter?: DataListPartConfig<DataListAddFilterUi>;
+    filterPanel?: DataListPartConfig<DataListFilterPanelUi>;
+    clearFilters?: DataListPartConfig<DataListClearFiltersUi>;
+    resultCount?: {
+        ui?: DataListResultCountUi;
+    };
+    refresh?: DataListPartConfig<DataListRefreshUi>;
+    columnPanel?: DataListPartConfig<DataListColumnPanelUi>;
+    sortMenu?: DataListPartConfig<DataListSortMenuUi>;
+    layoutSwitch?: DataListPartConfig<DataListLayoutSwitchUi>;
+    content?: {
+        ui?: DataListContentUi;
+    };
+    table?: {
+        ui?: DataListTableUi;
+    };
+    grid?: {
+        ui?: DataListGridUi;
+    };
+    pagination?: DataListPartConfig<DataListPaginationUi>;
+    infiniteLoader?: DataListPartConfig<DataListInfiniteLoaderUi>;
+}