nuxt-ui-tools 0.1.2 → 1.0.0

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

@@ -2,146 +2,195 @@ import type { MaybeComputedRef, TableApi, TableSchemaView } from '../types/index
 declare function createTableInternals<TSchema>(options: {
     rawSchema: MaybeComputedRef<TSchema>;
 }): {
-    schema: import("vue").ComputedRef<TableSchemaView>;
-    layout: {
-        activeLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        tableEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-    };
-    startup: {
-        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
-        isBooting: import("vue").ComputedRef<boolean>;
-        isActive: import("vue").ComputedRef<boolean>;
-        start: () => void;
-        scheduleStart: () => void;
-        dispose: () => void;
+    actions: {
+        actions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        bulkActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        definitions: import("vue").ComputedRef<(import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>)[]>;
+        execute: (definition: import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>) => Promise<void>;
+        runningKeys: import("vue").Ref<string[], string[]>;
+        toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
     };
-    queryState: {
-        pagination: import("vue").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;
+    controls: {
+        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
+        columnsPanelSearch: import("vue").Ref<string, string>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        headerControls: import("vue").ComputedRef<Record<keyof import("../types/index.js").TableControlsSchema, boolean>>;
+        layoutState: import("vue").ComputedRef<{
+            active: import("../types/index.js").TableLayout;
+            available: import("../types/index.js").TableLayout[];
         }>;
-        paginationMode: "offset" | "cursor" | "none";
-        paginationRevision: import("vue").Ref<number, number>;
-        resetPagination: () => void;
-        setOffsetPagination: (value: {
-            pageIndex: number;
-            pageSize: number;
-        }) => void;
-        sorting: import("vue").WritableComputedRef<{
+        rawControls: {
+            actions: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            columns: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            filters: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            layout: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            refresh: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            sort: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+        };
+        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
+        tableEnabled: import("vue").ComputedRef<boolean>;
+        tableLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+    };
+    filterPresentation: {
+        activateDynamicFilter: (input: {
             key: string;
-            dir: "asc" | "desc";
-        } | null, {
+        }) => void;
+        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        activePanelCount: import("vue").ComputedRef<number>;
+        applyPanelDraft: () => void;
+        clearPanelDraft: () => void;
+        clearPanelFilter: (input: {
             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: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterGroup<string>>;
-    queryContent: import("./use-table-data.js").UseTableDataReturn;
-    tableApi: TableApi<TSchema>;
-    selection: {
-        selectionEnabled: import("vue").ComputedRef<boolean>;
-        rowSelection: import("vue").WritableComputedRef<{
-            [k: string]: boolean;
-        }, Record<string, boolean> | undefined>;
-        selectedKeys: import("vue").Ref<string[], string[]>;
-        selectedRows: import("vue").ComputedRef<object[]>;
-        selectedCount: import("vue").ComputedRef<number>;
-        allSelected: import("vue").ComputedRef<boolean>;
-        partiallySelected: import("vue").ComputedRef<boolean>;
-        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
-        getRowId: (params: {
-            row: import("../types/index.js").GenericObject;
-            index?: number;
-        }) => string;
-        isRowSelected: (params: {
-            rowId: string;
-        }) => boolean;
-        setRowSelection: (params: {
-            selection: Record<string, boolean>;
         }) => void;
-        selectRows: (params: {
-            rowIds: string[];
+        closePanel: () => void;
+        commitPanelDraft: (input?: {
+            close?: boolean;
         }) => void;
-        unselectRows: (params: {
-            rowIds: string[];
+        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
+        getPanelDraftFilterState: (input: {
+            key: string;
+        }) => {
+            key: string;
+            operator?: import("../types/index.js").TableFilterOperator | undefined;
+            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
+                from?: number | undefined;
+                to?: number | undefined;
+            } | {
+                from?: Date | undefined;
+                to?: Date | undefined;
+            };
+        } | undefined;
+        getPanelFilterOperator: (input: {
+            key: string;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        hasPanelFilters: import("vue").ComputedRef<boolean>;
+        openPanel: () => void;
+        panelCommitMode: import("vue").Ref<import("../types/index.js").DataListFilterPanelCommitMode, import("../types/index.js").DataListFilterPanelCommitMode>;
+        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        panelOpen: import("vue").Ref<boolean, boolean>;
+        panelSections: import("vue").ComputedRef<{
+            items: import("../types/index.js").TableUiFilterDefinition[];
+            label: string;
+        }[]>;
+        releaseDynamicSession: (input: {
+            key: string;
         }) => void;
-        clearSelection: () => void;
-        selectAllRows: () => void;
-        toggleAllRows: (params: {
-            selected: boolean;
+        resetPanelDraft: () => void;
+        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
+        setPanelCommitMode: (mode: import("../types/index.js").DataListFilterPanelCommitMode) => void;
+        setPanelFilterOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
         }) => void;
-        toggleRowSelection: (params: {
-            rowId: string;
-            selected?: boolean;
-            shiftKey?: boolean;
+        setPanelOptionFilterValues: (input: {
+            key: string;
+            values: (string | number | boolean)[];
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        setPanelScalarFilterValue: (input: {
+            key: string;
+            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
+            operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
+        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
     };
     filters: {
-        searchQuery: import("vue").WritableComputedRef<string, string>;
-        searchPlaceholder: import("vue").ComputedRef<string>;
-        hasActiveSearch: import("vue").ComputedRef<boolean>;
-        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
         activeUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
-        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
+        clearAllFilters: () => void;
+        clearFilter: (input: {
+            key: string;
+        }) => void;
+        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        effectiveUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
+        getActiveFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterValueForOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
+        }) => import("../types/index.js").TableQueryStateFilterValue;
         getDefinition: (input: {
             key: string;
         }) => import("../types/index.js").TableUiFilterDefinition | undefined;
-        getFilterState: (input: {
+        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
+        getFilterOperator: (input: {
             key: string;
-        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        getFilterOperatorOptions: (input: {
+            key: string;
+        }) => {
+            label: string;
+            value: import("../types/index.js").TableFilterOperator;
+        }[];
         getFilterOptionEntries: (input: {
             key: string;
             entries?: import("../types/index.js").TableFilterOptionEntry[];
-            facetCounts?: Array<{
+            facetCounts?: {
                 value: string | number | boolean;
                 count: number;
-            }>;
+            }[];
         }) => (import("../types/index.js").TableResolvedFilterOptionEntry<import("../types/index.js").TableFilterPrimitiveValue> & {
             value: string | number | boolean;
         })[];
         getFilterPreview: (input: {
             key: string;
-            entries?: Array<{
-                label: string;
-                value: string | number | boolean;
-            }>;
-        }) => import("../utils/index.js").FilterPreviewResult;
-        getFilterOperator: (input: {
-            key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        getFilterOperatorOptions: (input: {
-            key: string;
+            entries?: import("../utils/index.js").FilterPreviewOptionEntry[];
         }) => {
-            value: import("../types/index.js").TableFilterOperator;
-            label: string;
-        }[];
-        getDefaultFilterValueForOperator: (input: {
+            active: boolean;
+            dirty: boolean;
+            count: number;
+            tags: string[];
+            entries: import("../utils/filters/preview/types.js").FilterPreviewEntry[];
+            summary: string;
+        };
+        getFilterState: (input: {
             key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => import("../types/index.js").TableQueryStateFilterValue;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        hasActiveSearch: import("vue").ComputedRef<boolean>;
+        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
+        replaceFilters: (input: {
+            rules: import("../types/index.js").TableQueryStateFilterRule[];
+        }) => void;
+        searchPlaceholder: import("vue").ComputedRef<string>;
+        searchQuery: import("vue").WritableComputedRef<string, string>;
         setFilterOperator: (input: {
             key: string;
             operator: import("../types/index.js").TableFilterOperator;
@@ -151,211 +200,305 @@ declare function createTableInternals<TSchema>(options: {
             values: import("../types/index.js").TableFilterPrimitiveValue[];
             operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        toggleOptionFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableFilterPrimitiveValue;
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
         setScalarFilterValue: (input: {
             key: string;
             value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
             operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        clearFilter: (input: {
+        toggleOptionFilterValue: (input: {
             key: string;
+            value: import("../types/index.js").TableFilterPrimitiveValue;
+            operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        clearAllFilters: () => void;
-        replaceFilters: (input: {
-            rules: import("../types/index.js").TableQueryStateFilterRule[];
-        }) => void;
-        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
     };
-    filterPresentation: {
-        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
-        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
-        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        panelSections: import("vue").ComputedRef<{
-            label: string;
-            items: import("../types/index.js").TableUiFilterDefinition[];
-        }[]>;
-        hasPanelFilters: import("vue").ComputedRef<boolean>;
-        activePanelCount: import("vue").ComputedRef<number>;
-        panelOpen: import("vue").Ref<boolean, boolean>;
-        activateDynamicFilter: (input: {
-            key: string;
-        }) => void;
-        releaseDynamicSession: (input: {
-            key: string;
-        }) => void;
-        openPanel: () => void;
-        closePanel: () => void;
-        resetPanelDraft: () => void;
-        clearPanelDraft: () => void;
-        applyPanelDraft: () => void;
-        getPanelDraftFilterState: (input: {
-            key: string;
-        }) => {
-            key: string;
-            operator?: import("../types/index.js").TableFilterOperator | undefined;
-            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
-                from?: number | undefined;
-                to?: number | undefined;
-            } | {
-                from?: Date | undefined;
-                to?: Date | undefined;
-            };
-        } | undefined;
-        getPanelFilterOperator: (input: {
+    grid: {
+        cardsPerRow: import("vue").ComputedRef<number>;
+        columnCount: import("vue").ComputedRef<number>;
+        itemColumnSpan: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
+        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
+        rows: import("vue").ComputedRef<object[]>;
+    };
+    layout: {
+        activeLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        tableEnabled: import("vue").ComputedRef<boolean>;
+    };
+    pagination: {
+        canNextPage: import("vue").ComputedRef<boolean>;
+        canPreviousPage: import("vue").ComputedRef<boolean>;
+        currentPage: import("vue").ComputedRef<number>;
+        cursorState: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "cursor";
+            totalCount: number | null;
+        }>;
+        isLoadingMore: import("vue").ComputedRef<boolean>;
+        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+        loadMoreError: import("vue").ComputedRef<unknown>;
+        loadedCount: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<"none" | "offset" | "cursor">;
+        next: () => void;
+        noneState: import("vue").ComputedRef<{
+            loadedCount: number;
+            mode: "none";
+            totalCount: number | null;
+        }>;
+        offsetState: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            loadedCount: number;
+            mode: "offset";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number;
+        }>;
+        pageSize: import("vue").ComputedRef<number>;
+        pageSizeOptions: import("vue").ComputedRef<number[]>;
+        previous: () => void;
+        reset: () => void;
+        rowCount: import("vue").ComputedRef<number | null>;
+        setPage: (page: number) => void;
+        setPageSize: (nextPageSize: number) => void;
+        state: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "none" | "offset" | "cursor";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number | null;
+        }>;
+        totalPages: import("vue").ComputedRef<number>;
+    };
+    queryContent: import("./use-table-data.js").UseTableDataReturn;
+    queryState: {
+        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>[];
+        }>;
+        pagination: import("vue").ComputedRef<{
+            readonly mode: "none";
+            readonly count?: undefined;
+            readonly cursor?: undefined;
+            readonly pageSize?: undefined;
+            readonly pageIndex?: undefined;
+        } | {
+            readonly count: "exact" | "none";
+            readonly cursor: null;
+            readonly mode: "cursor";
+            readonly pageSize: number;
+            readonly pageIndex?: undefined;
+        } | {
+            readonly count: "exact";
+            readonly mode: "offset";
+            readonly pageIndex: number;
+            readonly pageSize: number;
+            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<{
+            dir: "desc" | "asc";
             key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        setPanelFilterOperator: (input: {
+        } | null, {
             key: string;
-            operator: import("../types/index.js").TableFilterOperator;
+            dir: "asc" | "desc";
+        } | null>;
+    };
+    resolvedFilterState: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterGroup<string>>;
+    schema: import("vue").ComputedRef<TableSchemaView>;
+    selection: {
+        allSelected: import("vue").ComputedRef<boolean>;
+        bulkScope: import("vue").Ref<"selection" | "all", "selection" | "all">;
+        clearSelection: () => void;
+        getRowId: (params: {
+            row: import("../types/index.js").GenericObject;
+            index?: number;
+        }) => string;
+        isRowSelected: (params: {
+            rowId: string;
+        }) => boolean;
+        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
+        partiallySelected: import("vue").ComputedRef<boolean>;
+        rowSelection: import("vue").WritableComputedRef<{
+            [k: string]: boolean;
+        }, Record<string, boolean> | undefined>;
+        selectAllRows: () => void;
+        selectRows: (params: {
+            rowIds: string[];
         }) => void;
-        setPanelScalarFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
-            operator?: import("../types/index.js").TableFilterOperator;
+        selectedCount: import("vue").ComputedRef<number>;
+        selectedKeys: import("vue").Ref<string[], string[]>;
+        selectedRows: import("vue").ComputedRef<object[]>;
+        selectionEnabled: import("vue").ComputedRef<boolean>;
+        setBulkScope: (scope: "selection" | "all") => void;
+        setRowSelection: (params: {
+            selection: Record<string, boolean>;
         }) => void;
-        setPanelOptionFilterValues: (input: {
-            key: string;
-            values: Array<string | number | boolean>;
-            operator?: import("../types/index.js").TableFilterOperator;
+        toggleAllRows: (params: {
+            selected: boolean;
         }) => void;
-        clearPanelFilter: (input: {
-            key: string;
+        toggleRowSelection: (params: {
+            rowId: string;
+            selected?: boolean;
+            shiftKey?: boolean;
+        }) => void;
+        unselectRows: (params: {
+            rowIds: string[];
         }) => void;
     };
-    grid: {
-        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
-        rows: import("vue").ComputedRef<object[]>;
-        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
-        columnCount: import("vue").ComputedRef<number>;
-        itemColumnSpan: import("vue").ComputedRef<number>;
-        cardsPerRow: import("vue").ComputedRef<number>;
+    startup: {
+        dispose: () => void;
+        isActive: import("vue").ComputedRef<boolean>;
+        isBooting: import("vue").ComputedRef<boolean>;
+        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
+        scheduleStart: () => void;
+        start: () => void;
     };
-    controls: {
-        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
-        columnsPanelSearch: import("vue").Ref<string, string>;
-        tableLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        layoutState: import("vue").ComputedRef<{
-            active: "table" | "grid";
-            available: import("../types/index.js").TableLayout[];
-        }>;
-        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
+    summaries: {
+        cell: (columnId: string) => import("./use-table-summaries.js").TableSummaryCell;
+        cells: import("vue").ShallowRef<Record<string, import("./use-table-summaries.js").TableSummaryCell>, Record<string, import("./use-table-summaries.js").TableSummaryCell>>;
+        columns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        count: import("vue").ComputedRef<number>;
+        enabled: import("vue").ComputedRef<boolean>;
+        format: (columnId: string) => import("../types/index.js").TableSummaryValue;
+        label: import("vue").ComputedRef<import("../types/index.js").LazyTextValue | undefined>;
+        loading: import("vue").ComputedRef<boolean>;
+        rows: import("vue").ComputedRef<object[]>;
+        scope: import("vue").Ref<import("../types/index.js").TableSummaryScope, import("../types/index.js").TableSummaryScope>;
+        scopes: import("vue").ComputedRef<import("../types/index.js").TableSummaryScope[]>;
+        setScope: (next: import("../types/index.js").TableSummaryScope) => void;
     };
+    tableApi: TableApi<TSchema>;
     tableColumns: {
-        tableState: import("vue").Ref<{
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
-        }, import("../utils/index.js").TableColumnState | {
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
+        clearSorting: () => void;
+        columnDefs: import("vue").ComputedRef<import("../utils/index.js").DataListColumnDef[]>;
+        getMenuItems: (options: {
+            columnId: string;
+        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
+        getPinnedState: (options: {
+            columnId: string;
+        }) => "right" | "left" | null;
+        getSortState: (options: {
+            columnId: string;
+        }) => "desc" | "asc" | null;
+        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        reset: () => void;
+        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        setOrder: (options: {
+            columnIds: string[];
+        }) => void;
+        setPinning: (options: {
+            columnId: string;
+            pinned?: "left" | "right";
+        }) => void;
+        setSortDirection: (direction: "asc" | "desc") => void;
+        setSortKey: (key?: string) => void;
+        setSorting: (sorting: {
+            key: string;
+            dir: "asc" | "desc";
+        } | null) => void;
+        setVisibility: (options: {
+            columnId: string;
+            visible: boolean;
+        }) => void;
+        sortKeys: import("vue").ComputedRef<string[]>;
+        sortingState: import("vue").ComputedRef<{
+            active: boolean;
+            dir: "desc" | "asc" | undefined;
+            key: string | undefined;
         }>;
         tableColumns: import("vue").ComputedRef<({
-            id: string;
-            header: () => import("vue/jsx-runtime").JSX.Element;
             cell: ({ row }: {
                 row: {
                     id: string;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
             enableHiding: boolean;
             enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => import("vue/jsx-runtime").JSX.Element;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
-            header: () => null;
             cell: ({ row }: {
                 row: {
                     original: import("../types/index.js").GenericObject;
                     index: number;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
             enableHiding: boolean;
             enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => null;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
             accessorFn: ((row: import("../types/index.js").GenericObject) => unknown) | undefined;
+            cell: ({ row }: {
+                row: {
+                    original: import("../types/index.js").GenericObject;
+                    index: number;
+                };
+            }) => import("vue/jsx-runtime").JSX.Element;
+            enableHiding: boolean;
+            enablePinning: boolean;
+            enableResizing: boolean;
+            enableSorting: boolean;
             header: ({ column: tableColumn, header, }: {
                 column: {
                     getCanHide?: () => boolean;
@@ -366,261 +509,275 @@ declare function createTableInternals<TSchema>(options: {
                     getResizeHandler?: () => (event: Event) => void;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            cell: ({ row }: {
-                row: {
-                    original: import("../types/index.js").GenericObject;
-                    index: number;
-                };
-            }) => import("vue/jsx-runtime").JSX.Element;
-            enableSorting: boolean;
-            enableHiding: boolean;
-            enablePinning: boolean;
-            enableResizing: boolean;
-            size: number | undefined;
-            minSize: number;
+            id: string;
             maxSize: number | undefined;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: ({ column: headerColumn }: {
+                    td: ({ column: cellColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
-                    td: ({ column: cellColumn }: {
+                    th: ({ column: headerColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            minSize: number;
+            size: number | undefined;
         })[]>;
-        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        visibleOrderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        reset: () => void;
-        setVisibility: (options: {
-            columnId: string;
-            visible: boolean;
-        }) => void;
-        setPinning: (options: {
-            columnId: string;
-            pinned?: "left" | "right";
-        }) => void;
-        setOrder: (options: {
-            columnIds: string[];
-        }) => void;
-        getSortState: (options: {
-            columnId: string;
-        }) => "asc" | "desc" | null;
-        getPinnedState: (options: {
-            columnId: string;
-        }) => "left" | "right" | null;
-        getMenuItems: (options: {
-            columnId: string;
-        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
-        sortingState: import("vue").ComputedRef<{
-            key: string | undefined;
-            dir: "asc" | "desc" | undefined;
-            active: boolean;
+        tableState: import("vue").Ref<{
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
+        }, import("../utils/index.js").TableColumnState | {
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
         }>;
-        sortKeys: import("vue").ComputedRef<string[]>;
-        setSorting: (sorting: {
-            key: string;
-            dir: "asc" | "desc";
-        } | null) => void;
-        setSortKey: (key?: string) => void;
-        setSortDirection: (direction: "asc" | "desc") => void;
-        clearSorting: () => void;
         toggleSorting: (key: string) => void;
-    };
-    pagination: {
-        mode: import("vue").ComputedRef<"offset" | "cursor" | "none">;
-        rowCount: import("vue").ComputedRef<number | null>;
-        loadedCount: import("vue").ComputedRef<number>;
-        currentPage: import("vue").ComputedRef<number>;
-        pageSize: import("vue").ComputedRef<number>;
-        totalPages: import("vue").ComputedRef<number>;
-        canPreviousPage: import("vue").ComputedRef<boolean>;
-        canNextPage: import("vue").ComputedRef<boolean>;
-        isLoadingMore: import("vue").ComputedRef<boolean>;
-        loadMoreError: import("vue").ComputedRef<unknown>;
-        state: import("vue").ComputedRef<{
-            mode: "offset" | "cursor" | "none";
-            pageIndex: number;
-            pageSize: number;
-            pageCount: number;
-            loadedCount: number;
-            totalCount: number | null;
-            hasNextPage: boolean;
-            hasPreviousPage: boolean;
-            isLoadingMore: boolean;
-            loadMoreError: unknown;
-        }>;
-        pageSizeOptions: import("vue").ComputedRef<number[]>;
-        setPage: (page: number) => void;
-        setPageSize: (nextPageSize: number) => void;
-        next: () => void;
-        previous: () => void;
-        reset: () => void;
-        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+        visibleOrderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
     };
 };
 declare function provideTableInternals(internals: TableInternals): void;
 declare function useProvideTableInternals<TSchema>(options: {
     rawSchema: MaybeComputedRef<TSchema>;
 }): {
-    schema: import("vue").ComputedRef<TableSchemaView>;
-    layout: {
-        activeLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        tableEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-    };
-    startup: {
-        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
-        isBooting: import("vue").ComputedRef<boolean>;
-        isActive: import("vue").ComputedRef<boolean>;
-        start: () => void;
-        scheduleStart: () => void;
-        dispose: () => void;
+    actions: {
+        actions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        bulkActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        definitions: import("vue").ComputedRef<(import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>)[]>;
+        execute: (definition: import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>) => Promise<void>;
+        runningKeys: import("vue").Ref<string[], string[]>;
+        toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
     };
-    queryState: {
-        pagination: import("vue").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;
+    controls: {
+        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
+        columnsPanelSearch: import("vue").Ref<string, string>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        headerControls: import("vue").ComputedRef<Record<keyof import("../types/index.js").TableControlsSchema, boolean>>;
+        layoutState: import("vue").ComputedRef<{
+            active: import("../types/index.js").TableLayout;
+            available: import("../types/index.js").TableLayout[];
         }>;
-        paginationMode: "offset" | "cursor" | "none";
-        paginationRevision: import("vue").Ref<number, number>;
-        resetPagination: () => void;
-        setOffsetPagination: (value: {
-            pageIndex: number;
-            pageSize: number;
+        rawControls: {
+            actions: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            columns: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            filters: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            layout: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            refresh: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            sort: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+        };
+        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
+        tableEnabled: import("vue").ComputedRef<boolean>;
+        tableLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+    };
+    filterPresentation: {
+        activateDynamicFilter: (input: {
+            key: string;
         }) => void;
-        sorting: import("vue").WritableComputedRef<{
+        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        activePanelCount: import("vue").ComputedRef<number>;
+        applyPanelDraft: () => void;
+        clearPanelDraft: () => void;
+        clearPanelFilter: (input: {
             key: string;
-            dir: "asc" | "desc";
-        } | null, {
+        }) => void;
+        closePanel: () => void;
+        commitPanelDraft: (input?: {
+            close?: boolean;
+        }) => void;
+        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
+        getPanelDraftFilterState: (input: {
+            key: string;
+        }) => {
+            key: string;
+            operator?: import("../types/index.js").TableFilterOperator | undefined;
+            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
+                from?: number | undefined;
+                to?: number | undefined;
+            } | {
+                from?: Date | undefined;
+                to?: Date | undefined;
+            };
+        } | undefined;
+        getPanelFilterOperator: (input: {
+            key: string;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        hasPanelFilters: import("vue").ComputedRef<boolean>;
+        openPanel: () => void;
+        panelCommitMode: import("vue").Ref<import("../types/index.js").DataListFilterPanelCommitMode, import("../types/index.js").DataListFilterPanelCommitMode>;
+        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        panelOpen: import("vue").Ref<boolean, boolean>;
+        panelSections: import("vue").ComputedRef<{
+            items: import("../types/index.js").TableUiFilterDefinition[];
+            label: string;
+        }[]>;
+        releaseDynamicSession: (input: {
             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: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterGroup<string>>;
-    queryContent: import("./use-table-data.js").UseTableDataReturn;
-    tableApi: TableApi<TSchema>;
-    selection: {
-        selectionEnabled: import("vue").ComputedRef<boolean>;
-        rowSelection: import("vue").WritableComputedRef<{
-            [k: string]: boolean;
-        }, Record<string, boolean> | undefined>;
-        selectedKeys: import("vue").Ref<string[], string[]>;
-        selectedRows: import("vue").ComputedRef<object[]>;
-        selectedCount: import("vue").ComputedRef<number>;
-        allSelected: import("vue").ComputedRef<boolean>;
-        partiallySelected: import("vue").ComputedRef<boolean>;
-        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
-        getRowId: (params: {
-            row: import("../types/index.js").GenericObject;
-            index?: number;
-        }) => string;
-        isRowSelected: (params: {
-            rowId: string;
-        }) => boolean;
-        setRowSelection: (params: {
-            selection: Record<string, boolean>;
-        }) => void;
-        selectRows: (params: {
-            rowIds: string[];
         }) => void;
-        unselectRows: (params: {
-            rowIds: string[];
+        resetPanelDraft: () => void;
+        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
+        setPanelCommitMode: (mode: import("../types/index.js").DataListFilterPanelCommitMode) => void;
+        setPanelFilterOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
         }) => void;
-        clearSelection: () => void;
-        selectAllRows: () => void;
-        toggleAllRows: (params: {
-            selected: boolean;
+        setPanelOptionFilterValues: (input: {
+            key: string;
+            values: (string | number | boolean)[];
+            operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        toggleRowSelection: (params: {
-            rowId: string;
-            selected?: boolean;
-            shiftKey?: boolean;
+        setPanelScalarFilterValue: (input: {
+            key: string;
+            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
+            operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
+        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
     };
     filters: {
-        searchQuery: import("vue").WritableComputedRef<string, string>;
-        searchPlaceholder: import("vue").ComputedRef<string>;
-        hasActiveSearch: import("vue").ComputedRef<boolean>;
-        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
         activeUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
-        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
+        clearAllFilters: () => void;
+        clearFilter: (input: {
+            key: string;
+        }) => void;
+        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        effectiveUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
+        getActiveFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterValueForOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
+        }) => import("../types/index.js").TableQueryStateFilterValue;
         getDefinition: (input: {
             key: string;
         }) => import("../types/index.js").TableUiFilterDefinition | undefined;
-        getFilterState: (input: {
+        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
+        getFilterOperator: (input: {
             key: string;
-        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        getFilterOperatorOptions: (input: {
+            key: string;
+        }) => {
+            label: string;
+            value: import("../types/index.js").TableFilterOperator;
+        }[];
         getFilterOptionEntries: (input: {
             key: string;
             entries?: import("../types/index.js").TableFilterOptionEntry[];
-            facetCounts?: Array<{
+            facetCounts?: {
                 value: string | number | boolean;
                 count: number;
-            }>;
+            }[];
         }) => (import("../types/index.js").TableResolvedFilterOptionEntry<import("../types/index.js").TableFilterPrimitiveValue> & {
             value: string | number | boolean;
         })[];
         getFilterPreview: (input: {
             key: string;
-            entries?: Array<{
-                label: string;
-                value: string | number | boolean;
-            }>;
-        }) => import("../utils/index.js").FilterPreviewResult;
-        getFilterOperator: (input: {
-            key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        getFilterOperatorOptions: (input: {
-            key: string;
+            entries?: import("../utils/index.js").FilterPreviewOptionEntry[];
         }) => {
-            value: import("../types/index.js").TableFilterOperator;
-            label: string;
-        }[];
-        getDefaultFilterValueForOperator: (input: {
+            active: boolean;
+            dirty: boolean;
+            count: number;
+            tags: string[];
+            entries: import("../utils/filters/preview/types.js").FilterPreviewEntry[];
+            summary: string;
+        };
+        getFilterState: (input: {
             key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => import("../types/index.js").TableQueryStateFilterValue;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        hasActiveSearch: import("vue").ComputedRef<boolean>;
+        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
+        replaceFilters: (input: {
+            rules: import("../types/index.js").TableQueryStateFilterRule[];
+        }) => void;
+        searchPlaceholder: import("vue").ComputedRef<string>;
+        searchQuery: import("vue").WritableComputedRef<string, string>;
         setFilterOperator: (input: {
             key: string;
             operator: import("../types/index.js").TableFilterOperator;
@@ -630,211 +787,305 @@ declare function useProvideTableInternals<TSchema>(options: {
             values: import("../types/index.js").TableFilterPrimitiveValue[];
             operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        toggleOptionFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableFilterPrimitiveValue;
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
         setScalarFilterValue: (input: {
             key: string;
             value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
             operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        clearFilter: (input: {
-            key: string;
-        }) => void;
-        clearAllFilters: () => void;
-        replaceFilters: (input: {
-            rules: import("../types/index.js").TableQueryStateFilterRule[];
-        }) => void;
-        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
-    };
-    filterPresentation: {
-        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
-        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
-        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        panelSections: import("vue").ComputedRef<{
-            label: string;
-            items: import("../types/index.js").TableUiFilterDefinition[];
-        }[]>;
-        hasPanelFilters: import("vue").ComputedRef<boolean>;
-        activePanelCount: import("vue").ComputedRef<number>;
-        panelOpen: import("vue").Ref<boolean, boolean>;
-        activateDynamicFilter: (input: {
-            key: string;
-        }) => void;
-        releaseDynamicSession: (input: {
-            key: string;
-        }) => void;
-        openPanel: () => void;
-        closePanel: () => void;
-        resetPanelDraft: () => void;
-        clearPanelDraft: () => void;
-        applyPanelDraft: () => void;
-        getPanelDraftFilterState: (input: {
-            key: string;
-        }) => {
-            key: string;
-            operator?: import("../types/index.js").TableFilterOperator | undefined;
-            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
-                from?: number | undefined;
-                to?: number | undefined;
-            } | {
-                from?: Date | undefined;
-                to?: Date | undefined;
-            };
-        } | undefined;
-        getPanelFilterOperator: (input: {
-            key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        setPanelFilterOperator: (input: {
-            key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        setPanelScalarFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        setPanelOptionFilterValues: (input: {
+        toggleOptionFilterValue: (input: {
             key: string;
-            values: Array<string | number | boolean>;
+            value: import("../types/index.js").TableFilterPrimitiveValue;
             operator?: import("../types/index.js").TableFilterOperator;
         }) => void;
-        clearPanelFilter: (input: {
-            key: string;
-        }) => void;
     };
     grid: {
-        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
-        rows: import("vue").ComputedRef<object[]>;
-        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
+        cardsPerRow: import("vue").ComputedRef<number>;
         columnCount: import("vue").ComputedRef<number>;
         itemColumnSpan: import("vue").ComputedRef<number>;
-        cardsPerRow: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
+        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
+        rows: import("vue").ComputedRef<object[]>;
     };
-    controls: {
-        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
-        columnsPanelSearch: import("vue").Ref<string, string>;
-        tableLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        layoutState: import("vue").ComputedRef<{
-            active: "table" | "grid";
-            available: import("../types/index.js").TableLayout[];
-        }>;
-        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
+    layout: {
+        activeLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        tableEnabled: import("vue").ComputedRef<boolean>;
     };
-    tableColumns: {
-        tableState: import("vue").Ref<{
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
-        }, import("../utils/index.js").TableColumnState | {
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
+    pagination: {
+        canNextPage: import("vue").ComputedRef<boolean>;
+        canPreviousPage: import("vue").ComputedRef<boolean>;
+        currentPage: import("vue").ComputedRef<number>;
+        cursorState: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "cursor";
+            totalCount: number | null;
         }>;
-        tableColumns: import("vue").ComputedRef<({
-            id: string;
-            header: () => import("vue/jsx-runtime").JSX.Element;
-            cell: ({ row }: {
-                row: {
-                    id: string;
-                };
-            }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
-            enableHiding: boolean;
-            enablePinning: boolean;
+        isLoadingMore: import("vue").ComputedRef<boolean>;
+        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+        loadMoreError: import("vue").ComputedRef<unknown>;
+        loadedCount: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<"none" | "offset" | "cursor">;
+        next: () => void;
+        noneState: import("vue").ComputedRef<{
+            loadedCount: number;
+            mode: "none";
+            totalCount: number | null;
+        }>;
+        offsetState: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            loadedCount: number;
+            mode: "offset";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number;
+        }>;
+        pageSize: import("vue").ComputedRef<number>;
+        pageSizeOptions: import("vue").ComputedRef<number[]>;
+        previous: () => void;
+        reset: () => void;
+        rowCount: import("vue").ComputedRef<number | null>;
+        setPage: (page: number) => void;
+        setPageSize: (nextPageSize: number) => void;
+        state: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "none" | "offset" | "cursor";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number | null;
+        }>;
+        totalPages: import("vue").ComputedRef<number>;
+    };
+    queryContent: import("./use-table-data.js").UseTableDataReturn;
+    queryState: {
+        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>[];
+        }>;
+        pagination: import("vue").ComputedRef<{
+            readonly mode: "none";
+            readonly count?: undefined;
+            readonly cursor?: undefined;
+            readonly pageSize?: undefined;
+            readonly pageIndex?: undefined;
+        } | {
+            readonly count: "exact" | "none";
+            readonly cursor: null;
+            readonly mode: "cursor";
+            readonly pageSize: number;
+            readonly pageIndex?: undefined;
+        } | {
+            readonly count: "exact";
+            readonly mode: "offset";
+            readonly pageIndex: number;
+            readonly pageSize: number;
+            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<{
+            dir: "desc" | "asc";
+            key: string;
+        } | null, {
+            key: string;
+            dir: "asc" | "desc";
+        } | null>;
+    };
+    resolvedFilterState: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterGroup<string>>;
+    schema: import("vue").ComputedRef<TableSchemaView>;
+    selection: {
+        allSelected: import("vue").ComputedRef<boolean>;
+        bulkScope: import("vue").Ref<"selection" | "all", "selection" | "all">;
+        clearSelection: () => void;
+        getRowId: (params: {
+            row: import("../types/index.js").GenericObject;
+            index?: number;
+        }) => string;
+        isRowSelected: (params: {
+            rowId: string;
+        }) => boolean;
+        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
+        partiallySelected: import("vue").ComputedRef<boolean>;
+        rowSelection: import("vue").WritableComputedRef<{
+            [k: string]: boolean;
+        }, Record<string, boolean> | undefined>;
+        selectAllRows: () => void;
+        selectRows: (params: {
+            rowIds: string[];
+        }) => void;
+        selectedCount: import("vue").ComputedRef<number>;
+        selectedKeys: import("vue").Ref<string[], string[]>;
+        selectedRows: import("vue").ComputedRef<object[]>;
+        selectionEnabled: import("vue").ComputedRef<boolean>;
+        setBulkScope: (scope: "selection" | "all") => void;
+        setRowSelection: (params: {
+            selection: Record<string, boolean>;
+        }) => void;
+        toggleAllRows: (params: {
+            selected: boolean;
+        }) => void;
+        toggleRowSelection: (params: {
+            rowId: string;
+            selected?: boolean;
+            shiftKey?: boolean;
+        }) => void;
+        unselectRows: (params: {
+            rowIds: string[];
+        }) => void;
+    };
+    startup: {
+        dispose: () => void;
+        isActive: import("vue").ComputedRef<boolean>;
+        isBooting: import("vue").ComputedRef<boolean>;
+        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
+        scheduleStart: () => void;
+        start: () => void;
+    };
+    summaries: {
+        cell: (columnId: string) => import("./use-table-summaries.js").TableSummaryCell;
+        cells: import("vue").ShallowRef<Record<string, import("./use-table-summaries.js").TableSummaryCell>, Record<string, import("./use-table-summaries.js").TableSummaryCell>>;
+        columns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        count: import("vue").ComputedRef<number>;
+        enabled: import("vue").ComputedRef<boolean>;
+        format: (columnId: string) => import("../types/index.js").TableSummaryValue;
+        label: import("vue").ComputedRef<import("../types/index.js").LazyTextValue | undefined>;
+        loading: import("vue").ComputedRef<boolean>;
+        rows: import("vue").ComputedRef<object[]>;
+        scope: import("vue").Ref<import("../types/index.js").TableSummaryScope, import("../types/index.js").TableSummaryScope>;
+        scopes: import("vue").ComputedRef<import("../types/index.js").TableSummaryScope[]>;
+        setScope: (next: import("../types/index.js").TableSummaryScope) => void;
+    };
+    tableApi: TableApi<TSchema>;
+    tableColumns: {
+        clearSorting: () => void;
+        columnDefs: import("vue").ComputedRef<import("../utils/index.js").DataListColumnDef[]>;
+        getMenuItems: (options: {
+            columnId: string;
+        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
+        getPinnedState: (options: {
+            columnId: string;
+        }) => "right" | "left" | null;
+        getSortState: (options: {
+            columnId: string;
+        }) => "desc" | "asc" | null;
+        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        reset: () => void;
+        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        setOrder: (options: {
+            columnIds: string[];
+        }) => void;
+        setPinning: (options: {
+            columnId: string;
+            pinned?: "left" | "right";
+        }) => void;
+        setSortDirection: (direction: "asc" | "desc") => void;
+        setSortKey: (key?: string) => void;
+        setSorting: (sorting: {
+            key: string;
+            dir: "asc" | "desc";
+        } | null) => void;
+        setVisibility: (options: {
+            columnId: string;
+            visible: boolean;
+        }) => void;
+        sortKeys: import("vue").ComputedRef<string[]>;
+        sortingState: import("vue").ComputedRef<{
+            active: boolean;
+            dir: "desc" | "asc" | undefined;
+            key: string | undefined;
+        }>;
+        tableColumns: import("vue").ComputedRef<({
+            cell: ({ row }: {
+                row: {
+                    id: string;
+                };
+            }) => import("vue/jsx-runtime").JSX.Element;
+            enableHiding: boolean;
+            enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => import("vue/jsx-runtime").JSX.Element;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
-            header: () => null;
             cell: ({ row }: {
                 row: {
                     original: import("../types/index.js").GenericObject;
                     index: number;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
             enableHiding: boolean;
             enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => null;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
             accessorFn: ((row: import("../types/index.js").GenericObject) => unknown) | undefined;
+            cell: ({ row }: {
+                row: {
+                    original: import("../types/index.js").GenericObject;
+                    index: number;
+                };
+            }) => import("vue/jsx-runtime").JSX.Element;
+            enableHiding: boolean;
+            enablePinning: boolean;
+            enableResizing: boolean;
+            enableSorting: boolean;
             header: ({ column: tableColumn, header, }: {
                 column: {
                     getCanHide?: () => boolean;
@@ -845,153 +1096,388 @@ declare function useProvideTableInternals<TSchema>(options: {
                     getResizeHandler?: () => (event: Event) => void;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            cell: ({ row }: {
-                row: {
-                    original: import("../types/index.js").GenericObject;
-                    index: number;
-                };
-            }) => import("vue/jsx-runtime").JSX.Element;
-            enableSorting: boolean;
-            enableHiding: boolean;
-            enablePinning: boolean;
-            enableResizing: boolean;
-            size: number | undefined;
-            minSize: number;
+            id: string;
             maxSize: number | undefined;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: ({ column: headerColumn }: {
+                    td: ({ column: cellColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
-                    td: ({ column: cellColumn }: {
+                    th: ({ column: headerColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            minSize: number;
+            size: number | undefined;
         })[]>;
-        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        tableState: import("vue").Ref<{
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
+        }, import("../utils/index.js").TableColumnState | {
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
+        }>;
+        toggleSorting: (key: string) => void;
         visibleOrderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        reset: () => void;
-        setVisibility: (options: {
-            columnId: string;
-            visible: boolean;
+    };
+};
+declare function useTableInternals(): {
+    actions: {
+        actions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        bulkActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+        definitions: import("vue").ComputedRef<(import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>)[]>;
+        execute: (definition: import("../types/index.js").TableBulkAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }> | import("../types/index.js").TableToolbarAction<object, {
+            [x: string]: unknown;
+        }, {
+            [x: string]: unknown;
+        }>) => Promise<void>;
+        runningKeys: import("vue").Ref<string[], string[]>;
+        toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
+    };
+    controls: {
+        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
+        columnsPanelSearch: import("vue").Ref<string, string>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        headerControls: import("vue").ComputedRef<Record<keyof import("../types/index.js").TableControlsSchema, boolean>>;
+        layoutState: import("vue").ComputedRef<{
+            active: import("../types/index.js").TableLayout;
+            available: import("../types/index.js").TableLayout[];
+        }>;
+        rawControls: {
+            actions: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            columns: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            filters: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            layout: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            refresh: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+            sort: {
+                grid: import("vue").ComputedRef<boolean | null>;
+                table: import("vue").ComputedRef<boolean | null>;
+            };
+        };
+        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
+        tableEnabled: import("vue").ComputedRef<boolean>;
+        tableLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+    };
+    filterPresentation: {
+        activateDynamicFilter: (input: {
+            key: string;
         }) => void;
-        setPinning: (options: {
-            columnId: string;
-            pinned?: "left" | "right";
+        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        activePanelCount: import("vue").ComputedRef<number>;
+        applyPanelDraft: () => void;
+        clearPanelDraft: () => void;
+        clearPanelFilter: (input: {
+            key: string;
         }) => void;
-        setOrder: (options: {
-            columnIds: string[];
+        closePanel: () => void;
+        commitPanelDraft: (input?: {
+            close?: boolean;
         }) => void;
-        getSortState: (options: {
-            columnId: string;
-        }) => "asc" | "desc" | null;
-        getPinnedState: (options: {
-            columnId: string;
-        }) => "left" | "right" | null;
-        getMenuItems: (options: {
-            columnId: string;
-        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
-        sortingState: import("vue").ComputedRef<{
-            key: string | undefined;
-            dir: "asc" | "desc" | undefined;
+        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
+        getPanelDraftFilterState: (input: {
+            key: string;
+        }) => {
+            key: string;
+            operator?: import("../types/index.js").TableFilterOperator | undefined;
+            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
+                from?: number | undefined;
+                to?: number | undefined;
+            } | {
+                from?: Date | undefined;
+                to?: Date | undefined;
+            };
+        } | undefined;
+        getPanelFilterOperator: (input: {
+            key: string;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        hasPanelFilters: import("vue").ComputedRef<boolean>;
+        openPanel: () => void;
+        panelCommitMode: import("vue").Ref<import("../types/index.js").DataListFilterPanelCommitMode, import("../types/index.js").DataListFilterPanelCommitMode>;
+        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        panelOpen: import("vue").Ref<boolean, boolean>;
+        panelSections: import("vue").ComputedRef<{
+            items: import("../types/index.js").TableUiFilterDefinition[];
+            label: string;
+        }[]>;
+        releaseDynamicSession: (input: {
+            key: string;
+        }) => void;
+        resetPanelDraft: () => void;
+        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
+        setPanelCommitMode: (mode: import("../types/index.js").DataListFilterPanelCommitMode) => void;
+        setPanelFilterOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        setPanelOptionFilterValues: (input: {
+            key: string;
+            values: (string | number | boolean)[];
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        setPanelScalarFilterValue: (input: {
+            key: string;
+            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+    };
+    filters: {
+        activeUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
+        clearAllFilters: () => void;
+        clearFilter: (input: {
+            key: string;
+        }) => void;
+        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
+        effectiveUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
+        getActiveFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterState: (input: {
+            key: string;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        getDefaultFilterValueForOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
+        }) => import("../types/index.js").TableQueryStateFilterValue;
+        getDefinition: (input: {
+            key: string;
+        }) => import("../types/index.js").TableUiFilterDefinition | undefined;
+        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
+        getFilterOperator: (input: {
+            key: string;
+        }) => import("../types/index.js").TableFilterOperator | undefined;
+        getFilterOperatorOptions: (input: {
+            key: string;
+        }) => {
+            label: string;
+            value: import("../types/index.js").TableFilterOperator;
+        }[];
+        getFilterOptionEntries: (input: {
+            key: string;
+            entries?: import("../types/index.js").TableFilterOptionEntry[];
+            facetCounts?: {
+                value: string | number | boolean;
+                count: number;
+            }[];
+        }) => (import("../types/index.js").TableResolvedFilterOptionEntry<import("../types/index.js").TableFilterPrimitiveValue> & {
+            value: string | number | boolean;
+        })[];
+        getFilterPreview: (input: {
+            key: string;
+            entries?: import("../utils/index.js").FilterPreviewOptionEntry[];
+        }) => {
             active: boolean;
-        }>;
-        sortKeys: import("vue").ComputedRef<string[]>;
-        setSorting: (sorting: {
+            dirty: boolean;
+            count: number;
+            tags: string[];
+            entries: import("../utils/filters/preview/types.js").FilterPreviewEntry[];
+            summary: string;
+        };
+        getFilterState: (input: {
             key: string;
-            dir: "asc" | "desc";
-        } | null) => void;
-        setSortKey: (key?: string) => void;
-        setSortDirection: (direction: "asc" | "desc") => void;
-        clearSorting: () => void;
-        toggleSorting: (key: string) => void;
+        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
+        hasActiveSearch: import("vue").ComputedRef<boolean>;
+        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
+        replaceFilters: (input: {
+            rules: import("../types/index.js").TableQueryStateFilterRule[];
+        }) => void;
+        searchPlaceholder: import("vue").ComputedRef<string>;
+        searchQuery: import("vue").WritableComputedRef<string, string>;
+        setFilterOperator: (input: {
+            key: string;
+            operator: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        setOptionFilterValues: (input: {
+            key: string;
+            values: import("../types/index.js").TableFilterPrimitiveValue[];
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        setScalarFilterValue: (input: {
+            key: string;
+            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
+        toggleOptionFilterValue: (input: {
+            key: string;
+            value: import("../types/index.js").TableFilterPrimitiveValue;
+            operator?: import("../types/index.js").TableFilterOperator;
+        }) => void;
     };
-    pagination: {
-        mode: import("vue").ComputedRef<"offset" | "cursor" | "none">;
-        rowCount: import("vue").ComputedRef<number | null>;
-        loadedCount: import("vue").ComputedRef<number>;
-        currentPage: import("vue").ComputedRef<number>;
-        pageSize: import("vue").ComputedRef<number>;
-        totalPages: import("vue").ComputedRef<number>;
-        canPreviousPage: import("vue").ComputedRef<boolean>;
+    grid: {
+        cardsPerRow: import("vue").ComputedRef<number>;
+        columnCount: import("vue").ComputedRef<number>;
+        itemColumnSpan: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
+        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
+        rows: import("vue").ComputedRef<object[]>;
+    };
+    layout: {
+        activeLayout: import("vue").WritableComputedRef<import("../types/index.js").TableLayout, import("../types/index.js").TableLayout>;
+        gridEnabled: import("vue").ComputedRef<boolean>;
+        tableEnabled: import("vue").ComputedRef<boolean>;
+    };
+    pagination: {
         canNextPage: import("vue").ComputedRef<boolean>;
+        canPreviousPage: import("vue").ComputedRef<boolean>;
+        currentPage: import("vue").ComputedRef<number>;
+        cursorState: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "cursor";
+            totalCount: number | null;
+        }>;
         isLoadingMore: import("vue").ComputedRef<boolean>;
+        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
         loadMoreError: import("vue").ComputedRef<unknown>;
-        state: import("vue").ComputedRef<{
-            mode: "offset" | "cursor" | "none";
-            pageIndex: number;
-            pageSize: number;
-            pageCount: number;
+        loadedCount: import("vue").ComputedRef<number>;
+        mode: import("vue").ComputedRef<"none" | "offset" | "cursor">;
+        next: () => void;
+        noneState: import("vue").ComputedRef<{
             loadedCount: number;
+            mode: "none";
             totalCount: number | null;
+        }>;
+        offsetState: import("vue").ComputedRef<{
             hasNextPage: boolean;
             hasPreviousPage: boolean;
-            isLoadingMore: boolean;
-            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "offset";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number;
         }>;
+        pageSize: import("vue").ComputedRef<number>;
         pageSizeOptions: import("vue").ComputedRef<number[]>;
-        setPage: (page: number) => void;
-        setPageSize: (nextPageSize: number) => void;
-        next: () => void;
         previous: () => void;
         reset: () => void;
-        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
-    };
-};
-declare function useTableInternals(): {
-    schema: import("vue").ComputedRef<TableSchemaView>;
-    layout: {
-        activeLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        tableEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-    };
-    startup: {
-        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
-        isBooting: import("vue").ComputedRef<boolean>;
-        isActive: import("vue").ComputedRef<boolean>;
-        start: () => void;
-        scheduleStart: () => void;
-        dispose: () => void;
+        rowCount: import("vue").ComputedRef<number | null>;
+        setPage: (page: number) => void;
+        setPageSize: (nextPageSize: number) => void;
+        state: import("vue").ComputedRef<{
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            isLoadingMore: boolean;
+            loadMoreError: unknown;
+            loadedCount: number;
+            mode: "none" | "offset" | "cursor";
+            pageCount: number;
+            pageIndex: number;
+            pageSize: number;
+            totalCount: number | null;
+        }>;
+        totalPages: import("vue").ComputedRef<number>;
     };
+    queryContent: import("./use-table-data.js").UseTableDataReturn;
     queryState: {
+        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>[];
+        }>;
         pagination: import("vue").ComputedRef<{
             readonly mode: "none";
+            readonly count?: undefined;
             readonly cursor?: undefined;
             readonly pageSize?: undefined;
-            readonly count?: undefined;
             readonly pageIndex?: undefined;
         } | {
-            readonly mode: "cursor";
+            readonly count: "exact" | "none";
             readonly cursor: null;
+            readonly mode: "cursor";
             readonly pageSize: number;
-            readonly count: "exact" | "none";
             readonly pageIndex?: undefined;
         } | {
+            readonly count: "exact";
             readonly mode: "offset";
             readonly pageIndex: number;
             readonly pageSize: number;
-            readonly count: "exact";
             readonly cursor?: undefined;
         }>;
-        paginationMode: "offset" | "cursor" | "none";
+        paginationMode: "none" | "offset" | "cursor";
         paginationRevision: import("vue").Ref<number, number>;
         resetPagination: () => void;
         setOffsetPagination: (value: {
@@ -999,34 +1485,19 @@ declare function useTableInternals(): {
             pageSize: number;
         }) => void;
         sorting: import("vue").WritableComputedRef<{
+            dir: "desc" | "asc";
             key: string;
-            dir: "asc" | "desc";
         } | 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: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterGroup<string>>;
-    queryContent: import("./use-table-data.js").UseTableDataReturn;
-    tableApi: TableApi<unknown>;
+    schema: import("vue").ComputedRef<TableSchemaView>;
     selection: {
-        selectionEnabled: import("vue").ComputedRef<boolean>;
-        rowSelection: import("vue").WritableComputedRef<{
-            [k: string]: boolean;
-        }, Record<string, boolean> | undefined>;
-        selectedKeys: import("vue").Ref<string[], string[]>;
-        selectedRows: import("vue").ComputedRef<object[]>;
-        selectedCount: import("vue").ComputedRef<number>;
         allSelected: import("vue").ComputedRef<boolean>;
-        partiallySelected: import("vue").ComputedRef<boolean>;
-        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
+        bulkScope: import("vue").Ref<"selection" | "all", "selection" | "all">;
+        clearSelection: () => void;
         getRowId: (params: {
             row: import("../types/index.js").GenericObject;
             index?: number;
@@ -1034,17 +1505,23 @@ declare function useTableInternals(): {
         isRowSelected: (params: {
             rowId: string;
         }) => boolean;
-        setRowSelection: (params: {
-            selection: Record<string, boolean>;
-        }) => void;
+        lastTouchedRowId: import("vue").Ref<string | null, string | null>;
+        partiallySelected: import("vue").ComputedRef<boolean>;
+        rowSelection: import("vue").WritableComputedRef<{
+            [k: string]: boolean;
+        }, Record<string, boolean> | undefined>;
+        selectAllRows: () => void;
         selectRows: (params: {
             rowIds: string[];
         }) => void;
-        unselectRows: (params: {
-            rowIds: string[];
+        selectedCount: import("vue").ComputedRef<number>;
+        selectedKeys: import("vue").Ref<string[], string[]>;
+        selectedRows: import("vue").ComputedRef<object[]>;
+        selectionEnabled: import("vue").ComputedRef<boolean>;
+        setBulkScope: (scope: "selection" | "all") => void;
+        setRowSelection: (params: {
+            selection: Record<string, boolean>;
         }) => void;
-        clearSelection: () => void;
-        selectAllRows: () => void;
         toggleAllRows: (params: {
             selected: boolean;
         }) => void;
@@ -1053,264 +1530,146 @@ declare function useTableInternals(): {
             selected?: boolean;
             shiftKey?: boolean;
         }) => void;
-    };
-    filters: {
-        searchQuery: import("vue").WritableComputedRef<string, string>;
-        searchPlaceholder: import("vue").ComputedRef<string>;
-        hasActiveSearch: import("vue").ComputedRef<boolean>;
-        definitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        activeUiFilters: import("vue").ComputedRef<import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue>[]>;
-        hasActiveUiFilters: import("vue").ComputedRef<boolean>;
-        getDefinition: (input: {
-            key: string;
-        }) => import("../types/index.js").TableUiFilterDefinition | undefined;
-        getFilterState: (input: {
-            key: string;
-        }) => import("../types/index.js").TableQueryStateFilterRule<string, import("../types/index.js").TableFilterOperator, import("../types/index.js").TableQueryStateFilterValue> | undefined;
-        getFilterOptionEntries: (input: {
-            key: string;
-            entries?: import("../types/index.js").TableFilterOptionEntry[];
-            facetCounts?: Array<{
-                value: string | number | boolean;
-                count: number;
-            }>;
-        }) => (import("../types/index.js").TableResolvedFilterOptionEntry<import("../types/index.js").TableFilterPrimitiveValue> & {
-            value: string | number | boolean;
-        })[];
-        getFilterPreview: (input: {
-            key: string;
-            entries?: Array<{
-                label: string;
-                value: string | number | boolean;
-            }>;
-        }) => import("../utils/index.js").FilterPreviewResult;
-        getFilterOperator: (input: {
-            key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        getFilterOperatorOptions: (input: {
-            key: string;
-        }) => {
-            value: import("../types/index.js").TableFilterOperator;
-            label: string;
-        }[];
-        getDefaultFilterValueForOperator: (input: {
-            key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => import("../types/index.js").TableQueryStateFilterValue;
-        setFilterOperator: (input: {
-            key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        setOptionFilterValues: (input: {
-            key: string;
-            values: import("../types/index.js").TableFilterPrimitiveValue[];
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        toggleOptionFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableFilterPrimitiveValue;
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        setScalarFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
-            operator?: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        clearFilter: (input: {
-            key: string;
-        }) => void;
-        clearAllFilters: () => void;
-        replaceFilters: (input: {
-            rules: import("../types/index.js").TableQueryStateFilterRule[];
+        unselectRows: (params: {
+            rowIds: string[];
         }) => void;
-        getFilterLabelText: typeof import("../utils/index.js").getFilterLabelText;
     };
-    filterPresentation: {
-        resolved: import("vue").ComputedRef<import("../types/index.js").TableResolvedFilterPresentation<string>[]>;
-        tagDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        activeDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dormantDynamicDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        dynamicSessionDefinition: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition | undefined>;
-        panelDefinitions: import("vue").ComputedRef<import("../types/index.js").TableUiFilterDefinition[]>;
-        panelSections: import("vue").ComputedRef<{
-            label: string;
-            items: import("../types/index.js").TableUiFilterDefinition[];
-        }[]>;
-        hasPanelFilters: import("vue").ComputedRef<boolean>;
-        activePanelCount: import("vue").ComputedRef<number>;
-        panelOpen: import("vue").Ref<boolean, boolean>;
-        activateDynamicFilter: (input: {
-            key: string;
-        }) => void;
-        releaseDynamicSession: (input: {
-            key: string;
-        }) => void;
-        openPanel: () => void;
-        closePanel: () => void;
-        resetPanelDraft: () => void;
-        clearPanelDraft: () => void;
-        applyPanelDraft: () => void;
-        getPanelDraftFilterState: (input: {
-            key: string;
-        }) => {
-            key: string;
-            operator?: import("../types/index.js").TableFilterOperator | undefined;
-            value: string | number | boolean | Date | import("../types/index.js").TableFilterPrimitiveValue[] | {
-                from?: number | undefined;
-                to?: number | undefined;
-            } | {
-                from?: Date | undefined;
-                to?: Date | undefined;
-            };
-        } | undefined;
-        getPanelFilterOperator: (input: {
-            key: string;
-        }) => import("../types/index.js").TableFilterOperator | undefined;
-        setPanelFilterOperator: (input: {
-            key: string;
-            operator: import("../types/index.js").TableFilterOperator;
-        }) => void;
-        setPanelScalarFilterValue: (input: {
-            key: string;
-            value: import("../types/index.js").TableQueryStateFilterValue | null | undefined;
-            operator?: import("../types/index.js").TableFilterOperator;
+    startup: {
+        dispose: () => void;
+        isActive: import("vue").ComputedRef<boolean>;
+        isBooting: import("vue").ComputedRef<boolean>;
+        phase: import("vue").ShallowRef<"active" | "booting" | "scheduled", "active" | "booting" | "scheduled">;
+        scheduleStart: () => void;
+        start: () => void;
+    };
+    summaries: {
+        cell: (columnId: string) => import("./use-table-summaries.js").TableSummaryCell;
+        cells: import("vue").ShallowRef<Record<string, import("./use-table-summaries.js").TableSummaryCell>, Record<string, import("./use-table-summaries.js").TableSummaryCell>>;
+        columns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        count: import("vue").ComputedRef<number>;
+        enabled: import("vue").ComputedRef<boolean>;
+        format: (columnId: string) => import("../types/index.js").TableSummaryValue;
+        label: import("vue").ComputedRef<import("../types/index.js").LazyTextValue | undefined>;
+        loading: import("vue").ComputedRef<boolean>;
+        rows: import("vue").ComputedRef<object[]>;
+        scope: import("vue").Ref<import("../types/index.js").TableSummaryScope, import("../types/index.js").TableSummaryScope>;
+        scopes: import("vue").ComputedRef<import("../types/index.js").TableSummaryScope[]>;
+        setScope: (next: import("../types/index.js").TableSummaryScope) => void;
+    };
+    tableApi: TableApi<unknown>;
+    tableColumns: {
+        clearSorting: () => void;
+        columnDefs: import("vue").ComputedRef<import("../utils/index.js").DataListColumnDef[]>;
+        getMenuItems: (options: {
+            columnId: string;
+        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
+        getPinnedState: (options: {
+            columnId: string;
+        }) => "right" | "left" | null;
+        getSortState: (options: {
+            columnId: string;
+        }) => "desc" | "asc" | null;
+        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        reset: () => void;
+        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
+        setOrder: (options: {
+            columnIds: string[];
         }) => void;
-        setPanelOptionFilterValues: (input: {
-            key: string;
-            values: Array<string | number | boolean>;
-            operator?: import("../types/index.js").TableFilterOperator;
+        setPinning: (options: {
+            columnId: string;
+            pinned?: "left" | "right";
         }) => void;
-        clearPanelFilter: (input: {
+        setSortDirection: (direction: "asc" | "desc") => void;
+        setSortKey: (key?: string) => void;
+        setSorting: (sorting: {
             key: string;
+            dir: "asc" | "desc";
+        } | null) => void;
+        setVisibility: (options: {
+            columnId: string;
+            visible: boolean;
         }) => void;
-    };
-    grid: {
-        mode: import("vue").ComputedRef<import("../types/index.js").TableGridMode>;
-        rows: import("vue").ComputedRef<object[]>;
-        rowChunks: import("vue").ComputedRef<import("./use-table-grid.js").GridRowChunk<object>[]>;
-        columnCount: import("vue").ComputedRef<number>;
-        itemColumnSpan: import("vue").ComputedRef<number>;
-        cardsPerRow: import("vue").ComputedRef<number>;
-    };
-    controls: {
-        columnsPanelOpen: import("vue").Ref<boolean, boolean>;
-        columnsPanelSearch: import("vue").Ref<string, string>;
-        tableLayout: import("vue").WritableComputedRef<"table" | "grid", "table" | "grid">;
-        gridEnabled: import("vue").ComputedRef<string | boolean | (() => boolean | string) | null>;
-        layoutState: import("vue").ComputedRef<{
-            active: "table" | "grid";
-            available: import("../types/index.js").TableLayout[];
-        }>;
-        setTableLayout: (layout: import("../types/index.js").TableLayout) => void;
-    };
-    tableColumns: {
-        tableState: import("vue").Ref<{
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
-        }, import("../utils/index.js").TableColumnState | {
-            columnOrder: string[];
-            columnVisibility: Record<string, boolean>;
-            columnPinning: {
-                left?: string[] | undefined;
-                right?: string[] | undefined;
-            };
-            columnSizing: Record<string, number>;
-            columnSizingInfo: {
-                startOffset: number | null;
-                startSize: number | null;
-                deltaOffset: number | null;
-                deltaPercentage: number | null;
-                isResizingColumn: false | string;
-                columnSizingStart: Array<[string, number]>;
-            };
-            sorting: {
-                id: string;
-                desc: boolean;
-            }[];
+        sortKeys: import("vue").ComputedRef<string[]>;
+        sortingState: import("vue").ComputedRef<{
+            active: boolean;
+            dir: "desc" | "asc" | undefined;
+            key: string | undefined;
         }>;
         tableColumns: import("vue").ComputedRef<({
-            id: string;
-            header: () => import("vue/jsx-runtime").JSX.Element;
             cell: ({ row }: {
                 row: {
                     id: string;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
             enableHiding: boolean;
             enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => import("vue/jsx-runtime").JSX.Element;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
-            header: () => null;
             cell: ({ row }: {
                 row: {
                     original: import("../types/index.js").GenericObject;
                     index: number;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            size: number;
-            enableSorting: boolean;
             enableHiding: boolean;
             enablePinning: boolean;
             enableResizing: boolean;
+            enableSorting: boolean;
+            header: () => null;
+            id: string;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: () => {
-                        width: string;
-                        minWidth: string;
-                        maxWidth: string;
-                    };
                     td: () => {
-                        width: string;
+                        maxWidth: string;
                         minWidth: string;
+                        width: string;
+                    };
+                    th: () => {
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            size: number;
         } | {
-            id: string;
             accessorFn: ((row: import("../types/index.js").GenericObject) => unknown) | undefined;
+            cell: ({ row }: {
+                row: {
+                    original: import("../types/index.js").GenericObject;
+                    index: number;
+                };
+            }) => import("vue/jsx-runtime").JSX.Element;
+            enableHiding: boolean;
+            enablePinning: boolean;
+            enableResizing: boolean;
+            enableSorting: boolean;
             header: ({ column: tableColumn, header, }: {
                 column: {
                     getCanHide?: () => boolean;
@@ -1321,115 +1680,80 @@ declare function useTableInternals(): {
                     getResizeHandler?: () => (event: Event) => void;
                 };
             }) => import("vue/jsx-runtime").JSX.Element;
-            cell: ({ row }: {
-                row: {
-                    original: import("../types/index.js").GenericObject;
-                    index: number;
-                };
-            }) => import("vue/jsx-runtime").JSX.Element;
-            enableSorting: boolean;
-            enableHiding: boolean;
-            enablePinning: boolean;
-            enableResizing: boolean;
-            size: number | undefined;
-            minSize: number;
+            id: string;
             maxSize: number | undefined;
             meta: {
                 class: {
-                    th: string;
                     td: string;
+                    th: string;
                 };
                 style: {
-                    th: ({ column: headerColumn }: {
+                    td: ({ column: cellColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
-                    td: ({ column: cellColumn }: {
+                    th: ({ column: headerColumn }: {
                         column: {
                             getSize: () => number;
                         };
                     }) => {
-                        width: string;
-                        minWidth: string;
                         maxWidth: string;
+                        minWidth: string;
+                        width: string;
                     };
                 };
             };
+            minSize: number;
+            size: number | undefined;
         })[]>;
-        runtimeColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        orderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        visibleOrderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
-        reset: () => void;
-        setVisibility: (options: {
-            columnId: string;
-            visible: boolean;
-        }) => void;
-        setPinning: (options: {
-            columnId: string;
-            pinned?: "left" | "right";
-        }) => void;
-        setOrder: (options: {
-            columnIds: string[];
-        }) => void;
-        getSortState: (options: {
-            columnId: string;
-        }) => "asc" | "desc" | null;
-        getPinnedState: (options: {
-            columnId: string;
-        }) => "left" | "right" | null;
-        getMenuItems: (options: {
-            columnId: string;
-        }) => import("@nuxt/ui/runtime/components/DropdownMenu.d.vue.js").DropdownMenuItem[][];
-        sortingState: import("vue").ComputedRef<{
-            key: string | undefined;
-            dir: "asc" | "desc" | undefined;
-            active: boolean;
+        tableState: import("vue").Ref<{
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
+        }, import("../utils/index.js").TableColumnState | {
+            columnOrder: string[];
+            columnVisibility: Record<string, boolean>;
+            columnPinning: {
+                left?: string[] | undefined;
+                right?: string[] | undefined;
+            };
+            columnSizing: Record<string, number>;
+            columnSizingInfo: {
+                startOffset: number | null;
+                startSize: number | null;
+                deltaOffset: number | null;
+                deltaPercentage: number | null;
+                isResizingColumn: false | string;
+                columnSizingStart: [string, number][];
+            };
+            sorting: {
+                id: string;
+                desc: boolean;
+            }[];
         }>;
-        sortKeys: import("vue").ComputedRef<string[]>;
-        setSorting: (sorting: {
-            key: string;
-            dir: "asc" | "desc";
-        } | null) => void;
-        setSortKey: (key?: string) => void;
-        setSortDirection: (direction: "asc" | "desc") => void;
-        clearSorting: () => void;
         toggleSorting: (key: string) => void;
-    };
-    pagination: {
-        mode: import("vue").ComputedRef<"offset" | "cursor" | "none">;
-        rowCount: import("vue").ComputedRef<number | null>;
-        loadedCount: import("vue").ComputedRef<number>;
-        currentPage: import("vue").ComputedRef<number>;
-        pageSize: import("vue").ComputedRef<number>;
-        totalPages: import("vue").ComputedRef<number>;
-        canPreviousPage: import("vue").ComputedRef<boolean>;
-        canNextPage: import("vue").ComputedRef<boolean>;
-        isLoadingMore: import("vue").ComputedRef<boolean>;
-        loadMoreError: import("vue").ComputedRef<unknown>;
-        state: import("vue").ComputedRef<{
-            mode: "offset" | "cursor" | "none";
-            pageIndex: number;
-            pageSize: number;
-            pageCount: number;
-            loadedCount: number;
-            totalCount: number | null;
-            hasNextPage: boolean;
-            hasPreviousPage: boolean;
-            isLoadingMore: boolean;
-            loadMoreError: unknown;
-        }>;
-        pageSizeOptions: import("vue").ComputedRef<number[]>;
-        setPage: (page: number) => void;
-        setPageSize: (nextPageSize: number) => void;
-        next: () => void;
-        previous: () => void;
-        reset: () => void;
-        loadMore: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+        visibleOrderedColumns: import("vue").ComputedRef<import("../utils/index.js").TableRuntimeColumn[]>;
     };
 };
 export type TableInternals = ReturnType<typeof createTableInternals>;