@marktiderman/genesis-ui 2.9.0 → 2.10.0

package/dist/use-resource-table-DCVf_lEG.d.ts

@@ -0,0 +1,1113 @@
+import { R as ResourceActions, a as ResourceColumnDef, D as DataTable, c as DataTableColumn, d as DataTableSort } from './use-resource-page-DaJzuq3M.js';
+import * as React from 'react';
+import { ReactNode, ComponentType, ComponentProps, RefObject } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { UseFormReturn } from 'react-hook-form';
+import { c as PageHeaderAction, a as PageHeaderOptions, P as PageHeader } from './PageHeader-V9lVkZtF.js';
+import { V as ViewMode } from './view-toggle-CahQ87PW.js';
+import { Density } from './hooks/use-view-settings.js';
+import { WizardStep, MutationMode, UndoableWrite, UseResourceOptions } from '@marktiderman/genesis-core/hooks';
+import { ResourceFormFieldDef } from '@marktiderman/genesis-core';
+import { b as Slots, a as SlotPropsFor } from './slots-tR0wf89f.js';
+import { ViewModeDefault } from './hooks/use-view-preference.js';
+import { ResourceUrlStateOptions } from './hooks/use-resource-url-state.js';
+import { FilterParam, SortParam } from '@marktiderman/genesis-core/provider';
+import { a as NavigateFn, S as SearchParamsAdapter } from './navigation-Bha0R3Fu.js';
+
+interface DataPageShellProps {
+    /** Display title for the page */
+    title: string;
+    icon?: LucideIcon;
+    /** Singular entity name for generated text, e.g. "session" */
+    entityName?: string;
+    /** Subtitle text */
+    subtitle?: string;
+    createAction?: ReactNode;
+    /** Extra actions, rendered in the header's one overflow menu. */
+    secondaryActions?: PageHeaderAction[];
+    isLoading?: boolean;
+    isEmpty?: boolean;
+    emptyIcon?: LucideIcon;
+    emptyMessage?: string;
+    /**
+     * A sentence under the empty-state title — what this list is for, or what
+     * to do first. Forwarded to `EmptyState`'s `description`; hidden while
+     * filters are active, where "no results" is the whole story.
+     */
+    emptyDescription?: string;
+    emptyAction?: ReactNode;
+    /** Error state */
+    hasError?: boolean;
+    errorMessage?: string;
+    onRetry?: () => void;
+    /** Number of filtered/visible items */
+    count?: number;
+    /** Total items before filtering */
+    totalCount?: number;
+    viewMode?: ViewMode;
+    onViewModeChange?: (mode: ViewMode) => void;
+    /** View settings */
+    pageSize?: number;
+    onPageSizeChange?: (size: number) => void;
+    density?: Density;
+    onDensityChange?: (density: Density) => void;
+    /**
+     * Slot for a stat cards row. Forwarded to the header, which renders it
+     * full width under the title block and above the filters — but only when
+     * `headerOptions.showStats` is on (default off), so a page that gains
+     * `stats` shows nothing new until the developer or user opts in.
+     */
+    stats?: ReactNode;
+    /** Slot for filter bar */
+    filters?: ReactNode;
+    /** Whether filters are currently active */
+    hasActiveFilters?: boolean;
+    onClearFilters?: () => void;
+    /**
+     * When true, filters render inside PageHeader details (collapsed by default).
+     * Default false preserves always-visible filters on existing boards.
+     */
+    filtersCollapsible?: boolean;
+    defaultFiltersOpen?: boolean;
+    filtersOpen?: boolean;
+    onFiltersOpenChange?: (open: boolean) => void;
+    filtersLabel?: string;
+    filtersHint?: ReactNode;
+    /**
+     * PageHeader chrome config — developer defaults; users can further
+     * customize via the in-header Header options menu.
+     */
+    headerOptions?: PageHeaderOptions;
+    /** Persist user header-option overrides (localStorage) */
+    headerOptionsStorageKey?: string;
+    children: ReactNode;
+    /** Merged onto the root, not replacing its layout. */
+    className?: string;
+    /**
+     * Replace the header outright. It receives exactly the props
+     * `DataPageShell` would have given `PageHeader`, so the common case is a
+     * wrapper that renders `PageHeader` with one thing added — an overflow
+     * menu, a status strip, a second row — rather than a reimplementation.
+     *
+     * `null` ejects it: shell layout, states and filter row, no header.
+     *
+     * `"toolbar"` keeps the header's actions — count, view toggle, view
+     * settings, create, overflow menu — and drops the title block, for a list
+     * embedded in a tab or card whose page already has the heading. `title`
+     * still feeds the generated copy ("Failed to load …", the count's noun).
+     */
+    header?: ComponentType<ComponentProps<typeof PageHeader>> | null | "toolbar";
+}
+declare function DataPageShell({ title, icon, entityName, subtitle, createAction, secondaryActions, isLoading, isEmpty, emptyIcon, emptyMessage, emptyDescription, emptyAction, hasError, errorMessage, onRetry, count, totalCount, viewMode, onViewModeChange, pageSize, onPageSizeChange, density, onDensityChange, stats, filters, hasActiveFilters, onClearFilters, filtersCollapsible, defaultFiltersOpen, filtersOpen, onFiltersOpenChange, filtersLabel, filtersHint, headerOptions, headerOptionsStorageKey, children, className, header, }: DataPageShellProps): React.JSX.Element;
+
+interface FilterOption {
+    value: string;
+    label?: string;
+    count?: number;
+}
+interface FilterComboboxProps {
+    label: string;
+    icon: LucideIcon;
+    options: FilterOption[];
+    selected: string[];
+    onChange: (selected: string[]) => void;
+    searchPlaceholder?: string;
+    allLabel?: string;
+    /** Optional map of value -> display label */
+    labelMap?: Record<string, string>;
+}
+declare function FilterCombobox({ label, icon: Icon, options, selected, onChange, searchPlaceholder, allLabel, labelMap, }: FilterComboboxProps): React.JSX.Element;
+
+interface DataFilterConfig {
+    key: string;
+    label: string;
+    icon: LucideIcon;
+    options: FilterOption[];
+    selected: string[];
+    onChange: (values: string[]) => void;
+    searchPlaceholder?: string;
+    allLabel?: string;
+    labelMap?: Record<string, string>;
+}
+interface SavedViewItem {
+    id: string;
+    name: string;
+    filters: Record<string, unknown>;
+}
+/**
+ * One status chip. A plain string is shorthand for `{ value, label: value }`.
+ * `count` renders as a muted number after the label.
+ */
+interface StatusChipOption {
+    value: string;
+    label?: string;
+    count?: number;
+}
+/** Rendering of the status chips — a row of pills, or one segmented strip. */
+type StatusChipsVariant = "chips" | "tabs";
+interface DataFiltersProps {
+    search: string;
+    onSearchChange: (value: string) => void;
+    searchPlaceholder?: string;
+    sort: string;
+    onSortChange: (sort: string) => void;
+    sortOptions: Array<{
+        value: string;
+        label: string;
+    }>;
+    filters?: DataFilterConfig[];
+    /** Status chip toggles */
+    statusChips?: {
+        options: Array<string | StatusChipOption>;
+        selected: string[];
+        onChange: (values: string[]) => void;
+        /**
+         * `"chips"` (default) renders pills inside the filter row. `"tabs"`
+         * renders a segmented strip on its own row above the search row —
+         * the same border-and-fill look as `ViewToggle`. Selection is
+         * multi-select in both.
+         */
+        variant?: StatusChipsVariant;
+    };
+    /** Saved views */
+    savedViews?: SavedViewItem[];
+    onLoadView?: (filters: Record<string, unknown>) => void;
+    onSaveView?: (name: string) => void;
+    onDeleteView?: (id: string) => void;
+    canSaveViews?: boolean;
+    /** Called after a view is saved successfully */
+    onViewSaved?: (name: string) => void;
+    /** Called when an error occurs */
+    onError?: (message: string) => void;
+    /** Called when "Clear all" is clicked */
+    onClearAll?: () => void;
+    /** Expose the search input ref for keyboard nav "/" shortcut */
+    searchInputRef?: React.RefObject<HTMLInputElement | null>;
+    /** Show the search box. Default `true`; turn off when the data source can't search. */
+    showSearch?: boolean;
+    /** Show the sort select. Default `true`; turn off when the data source can't sort. */
+    showSort?: boolean;
+}
+declare function DataFilters({ search, onSearchChange, searchPlaceholder, sort, onSortChange, sortOptions, filters, statusChips, savedViews, onLoadView, onSaveView, onDeleteView, canSaveViews, onViewSaved, onClearAll, searchInputRef, showSearch, showSort, }: DataFiltersProps): React.JSX.Element;
+
+interface DataGridProps<T> {
+    items: T[];
+    viewMode: ViewMode;
+    /** Items per infinite scroll batch (grid only). Default 48 */
+    batchSize?: number;
+    /** Tailwind grid column classes */
+    gridCols?: string;
+    /** Render a single card in grid mode */
+    renderCard: (item: T, index: number) => ReactNode;
+    /** Render the table view (receives currently visible items) */
+    renderTable?: (items: T[]) => ReactNode;
+    /** Render a compact list row */
+    renderListItem?: (item: T, index: number) => ReactNode;
+    /** Animate cards with staggered fade-in. Default true */
+    staggerAnimation?: boolean;
+    /** Unique key extractor. Defaults to (item as any).id */
+    getKey?: (item: T) => string;
+    /** Keyboard navigation: focused item index (-1 = none) */
+    focusedIndex?: number;
+    /** Keyboard navigation: container ref for scroll management */
+    keyboardContainerRef?: RefObject<HTMLDivElement | null>;
+    /**
+     * Open an item. Makes each card (and list row) one keyboard-reachable
+     * button: click, Enter or Space activates it, with a focus ring. Clicks on
+     * a link, button or input inside the card are left to that control, so a
+     * card can still carry its own actions. Use this instead of wrapping cards
+     * in a hand-rolled `div role="button"`.
+     */
+    onItemClick?: ((item: T) => void) | undefined;
+    /** Accessible name for an activatable item, e.g. `Open ${item.name}`. Used with `onItemClick`. */
+    getItemLabel?: ((item: T) => string) | undefined;
+}
+declare function DataGrid<T>({ items, viewMode, batchSize, gridCols, renderCard, renderTable, renderListItem, staggerAnimation, getKey, focusedIndex, keyboardContainerRef, onItemClick, getItemLabel, }: DataGridProps<T>): React.JSX.Element;
+
+/**
+ * One button in the bulk action bar.
+ *
+ * @stability Stable
+ */
+interface BulkAction {
+    label: string;
+    icon: LucideIcon;
+    onClick: () => void;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    /**
+     * Makes this action inert: it renders with the Button primitive's native
+     * `disabled` attribute, so it is neither clickable nor focusable, and it
+     * picks up the disabled styling.
+     *
+     * The case this exists for is an in-flight bulk mutation. A consumer that
+     * fires a move/duplicate/delete over the selected ids wants every bulk
+     * action dead until it settles, so a user cannot double-fire a destructive
+     * operation on the same selection. Without this field the only guard
+     * available is an early return inside `onClick` — which does stop the
+     * second call, but leaves the button looking live, so the affordance lies
+     * about what pressing it will do. Concretely, that is what blocks a real
+     * consumer's hand-rolled bulk bar from migrating to `DataBulkBar`: it
+     * would have to give up its double-submit guard to do so.
+     *
+     * Optional and defaulted off — omitting it behaves exactly as before.
+     */
+    disabled?: boolean;
+    /**
+     * `data-testid` on the rendered button.
+     *
+     * Without it, a consumer migrating a hand-rolled bulk bar to `DataBulkBar`
+     * loses every selector its e2e suite uses to drive one — which is a real
+     * reason not to migrate, and the kind of small missing affordance that
+     * keeps a parallel implementation alive.
+     */
+    testId?: string;
+}
+interface DataBulkBarProps {
+    selected: Set<string>;
+    totalCount: number;
+    onToggleAll: () => void;
+    onClearSelection: () => void;
+    actions: BulkAction[];
+    /** Merged onto the bar, not replacing its positioning. */
+    className?: string;
+}
+declare function DataBulkBar({ selected, totalCount, onToggleAll, onClearSelection, actions, className, }: DataBulkBarProps): React.JSX.Element | null;
+
+/**
+ * Props for {@link DetailPanel} — a shell-agnostic record detail view.
+ * `layout` selects only the surrounding shell (inline / dialog / sheet);
+ * the header and content below it render identically across all three.
+ *
+ * @stability Beta
+ */
+interface DetailPanelProps<T> {
+    /** The record to display */
+    item: T | null;
+    /** Whether panel is visible */
+    open: boolean;
+    /** Close handler */
+    onClose: () => void;
+    /** Header title */
+    title?: string;
+    /** Header subtitle */
+    subtitle?: string;
+    /** Shows edit button if provided */
+    onEdit?: (item: T) => void;
+    /** Shows delete button if provided */
+    onDelete?: (item: T) => void;
+    /** Custom content renderer */
+    children?: (item: T) => ReactNode;
+    /** Field definitions for auto-rendering */
+    fields?: Array<{
+        key: string;
+        label: string;
+        render?: (value: unknown, item: T) => ReactNode;
+    }>;
+    /**
+     * Panel width. For `"sheet"` / `"inline"` this is a fixed pixel width
+     * (matching this component's original, pre-`layout` sizing exactly). For
+     * `"dialog"` it maps to Tailwind's modal max-width scale instead, since a
+     * centered modal has a different sizing idiom than an edge-anchored panel.
+     */
+    width?: "sm" | "md" | "lg";
+    /**
+     * Rendering shell for the header + content below.
+     * - `"sheet"` (default): fixed, right-anchored slide-in panel, composed
+     *   from the shared `Sheet` primitive. Matches this component's original
+     *   (pre-`layout`-prop) behavior — existing consumers that don't pass
+     *   `layout` see no change, other than an overlay now present at all
+     *   breakpoints (previously mobile-only) since it's a real `Sheet`.
+     * - `"dialog"`: centered modal overlay, composed from the shared `Dialog`
+     *   primitive.
+     * - `"inline"`: plain in-flow panel — no overlay, backdrop, or fixed
+     *   positioning — for master-detail / split-pane layouts.
+     */
+    layout?: "inline" | "dialog" | "sheet";
+}
+declare function DetailPanel<T extends Record<string, unknown>>({ item, open, onClose, title, subtitle, onEdit, onDelete, children, fields, width, layout, }: DetailPanelProps<T>): React.JSX.Element | null;
+
+interface ResourceFormProps {
+    resource: string;
+    action: "create" | "edit";
+    item?: Record<string, unknown>;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: string;
+    fields?: ResourceFormFieldDef[];
+    /** Full dataset used to auto-detect select fields from unique values. */
+    listData?: Record<string, unknown>[];
+    renderForm?: (form: UseFormReturn<Record<string, unknown>>, fields: ResourceFormFieldDef[]) => ReactNode;
+    onSuccess?: (data: Record<string, unknown>) => void;
+    onError?: (error: Error) => void;
+    /** Layout mode for the form container. Default "dialog". */
+    layout?: "dialog" | "sheet" | "page";
+    /** Form presentation mode. Default "standard". */
+    mode?: "standard" | "wizard";
+    /** Wizard step definitions. Required when mode is "wizard". */
+    steps?: WizardStep[];
+    /** Number of columns for the form layout. Default 1. */
+    columns?: 1 | 2;
+    /**
+     * Pre-fill a create form from the page URL: a query param named like a
+     * field (`?status=draft`) becomes that field's starting value. Default
+     * `true`, as before. Pass `false` when the page's query string means
+     * something else — a list's own filters, say — and must not leak into the
+     * new record.
+     */
+    prefillFromUrl?: boolean;
+    /**
+     * Generate a placeholder ("Enter name") for fields whose `placeholder` is
+     * unset. Default `false`: a placeholder that restates the label adds noise,
+     * and reads as a filled value at a glance. A field's own `placeholder`
+     * always shows. (Select fields keep their "Select…" prompt either way.)
+     */
+    autoPlaceholder?: boolean;
+    /**
+     * Warn before unsaved changes are lost. Default false. While the form is
+     * dirty, Cancel / Esc / clicking outside asks first, and closing or
+     * reloading the tab shows the browser's prompt. Pass `{ message }` to
+     * change the question. For router navigation, see `onDirtyChange`.
+     */
+    warnWhenUnsaved?: boolean | {
+        message?: string;
+    };
+    /**
+     * Called when the form becomes dirty or clean, with a `confirmLeave` that
+     * asks when needed: the hook for a router blocker (SKILL.md "Unsaved
+     * changes").
+     */
+    onDirtyChange?: (isDirty: boolean, confirmLeave: () => boolean) => void;
+    /**
+     * When a save reaches the list. Default `"pessimistic"`: the form waits
+     * for the provider. `"optimistic"` closes at once and updates the cached
+     * list, putting it back (and toasting the error) if the save fails.
+     * `"undoable"` does the same and shows an Undo toast; the save is sent
+     * after `undoDelayMs` unless undone (or at once, undone by the provider,
+     * when it serves `undo`). Needs a mounted `<Toaster />`.
+     */
+    mutationMode?: MutationMode;
+    /** How long an `undoable` save waits for an undo, in ms. Default 5000. */
+    undoDelayMs?: number;
+    /** Replaces the undo toast. */
+    onUndoable?: (write: UndoableWrite) => void;
+}
+declare function ResourceForm(props: ResourceFormProps): React.JSX.Element | null;
+
+/**
+ * Props for {@link ConfirmDeleteDialog}.
+ *
+ * @stability Beta
+ */
+interface ConfirmDeleteDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /**
+     * Runs the delete. The dialog stays open while it is pending, closes when
+     * it resolves, and shows the error's message (staying open, so the user
+     * can retry or cancel) when it rejects.
+     */
+    onConfirm: () => void | Promise<void>;
+    /** Default "Delete this record?". */
+    title?: string;
+    /**
+     * What happens to the record: `"permanent"` (default) or `"recycle"` when
+     * a delete moves it to a recycle bin. Sets the default description.
+     */
+    kind?: "permanent" | "recycle";
+    /**
+     * Default by `kind`: "This can't be undone.", or "It moves to the recycle
+     * bin, where it can be restored."
+     */
+    description?: ReactNode;
+    /** Default "Delete". */
+    confirmLabel?: string;
+    /** Default "Cancel". */
+    cancelLabel?: string;
+}
+/**
+ * The confirm step in front of a destructive delete: an `AlertDialog` (Radix
+ * owns focus trap, Escape and focus return), a pending state, and the
+ * failure shown in place rather than swallowed. `ResourcePage` renders it
+ * for `allowDelete` / `confirmDelete`, as its `deleteDialog` slot.
+ *
+ * @stability Beta
+ */
+declare function ConfirmDeleteDialog({ open, onOpenChange, onConfirm, title, kind, description, confirmLabel, cancelLabel, }: ConfirmDeleteDialogProps): React.JSX.Element;
+
+/**
+ * What a user may do with a list's records, for ResourcePage's `can`.
+ *
+ * @stability Beta
+ */
+type ResourceAction = "create" | "edit" | "delete";
+/**
+ * Row-bound actions handed to `renderCard`, on top of the resource-wide
+ * `ResourceActions`. `open` is per-row, which is why it lives here rather
+ * than on `ResourceActions` — that object is built once and shared by every
+ * row and column, so it cannot carry a row-specific callback.
+ *
+ * @stability Beta
+ */
+interface ResourceCardActions<T> extends ResourceActions<T> {
+    /**
+     * Activate this row — opens the configured detail panel / modal / route,
+     * exactly as clicking the built-in card does. Wire it to your card's
+     * `onClick` (and call `stopPropagation` on any nested control that should
+     * not also activate the row).
+     */
+    open: () => void;
+}
+/**
+ * Config-driven resource page: wires data-fetching (or a pre-fetched `data`
+ * array), search/filter/sort, table/grid/list views, and a detail
+ * panel/modal/route around a `DataProvider` resource — the CRUD page most
+ * apps hand-roll, expressed as one component tree. `renderCard` lets a
+ * consumer fully own item presentation while ResourcePage keeps handling
+ * data-fetching, filtering, and layout; see also the built-in
+ * `useKeyboardNavigation` wiring (`keyboardNavigation` prop) and `gridCols`.
+ *
+ * Three levels of control, and each option is available at all three:
+ *
+ * 1. **The primitive offers it** — table / grid / list views, search, sort,
+ *    status chips, column visibility and resizing, density, page size,
+ *    detail panel / modal / route, built-in create and edit forms.
+ * 2. **The instance turns it on or off** — every one of those is a prop, so
+ *    a given page decides which affordances it offers at all.
+ * 3. **The end user picks their own, and it sticks** — for the options left
+ *    on at level 2, the user's choice persists to their own storage:
+ *    `viewSettingsKey` for page size and density, `columnVisibilityKey` and
+ *    `resizeKey` for column layout, `savedViews` (pair with `useSavedViews`)
+ *    for named filter sets. Persistence needs a key; without one the choice
+ *    lasts only for the session.
+ *
+ * A server-paginated list drives the same component through the controlled
+ * props (`page`, `perPage`, `onPageChange`, `onSortChange`, `onSearchChange`
+ * and friends) — supplying any of them stops ResourcePage from searching,
+ * sorting or paging the `data` a second time. See that block in
+ * {@link ResourcePageProps}.
+ *
+ * @stability Beta
+ */
+/**
+ * Every interior part `ResourcePage` composes, with the props it composes it
+ * with. Each key is a slot: replace it via `slots`, feed it more props via
+ * `slotProps`, or eject it with `null`.
+ *
+ * The map is the contract. A part that is not named here cannot be reached,
+ * so adding a part to the render tree means adding it here in the same
+ * change — otherwise the next surface that needs it forks the whole page.
+ */
+type ResourcePageSlotMap<T extends Record<string, unknown> = Record<string, unknown>> = {
+    /** The page shell: header, count pill, loading / empty / error states. */
+    shell: ComponentProps<typeof DataPageShell>;
+    /** The filter row — search, sort, facets, saved views. */
+    filters: ComponentProps<typeof DataFilters>;
+    /** The selection bar. Ejecting it leaves selection working, just unshown. */
+    bulkBar: ComponentProps<typeof DataBulkBar>;
+    /** The card/table switch. */
+    grid: ComponentProps<typeof DataGrid<T>>;
+    /** The table inside the grid. `renderTable` stays the terser way to swap. */
+    table: ComponentProps<typeof DataTable<T>>;
+    /** The detail peek. */
+    detail: ComponentProps<typeof DetailPanel<T>>;
+    /** The create / edit form. */
+    form: ComponentProps<typeof ResourceForm>;
+    /**
+     * The confirm step in front of a delete. Rendered only when a delete is
+     * confirmed (`allowDelete`, or `onDelete` with `confirmDelete`).
+     */
+    deleteDialog: ComponentProps<typeof ConfirmDeleteDialog>;
+};
+/**
+ * `slots` for {@link ResourcePage}, with one asymmetry the map cannot express:
+ * every part may be ejected with `null` EXCEPT `shell`.
+ *
+ * The shell is not an interior part, it is the page — `Shell` is what the
+ * render returns, so ejecting it does not remove a piece, it removes the
+ * component (`const Shell = slots?.shell ?? DataPageShell` would become
+ * `null`, and React throws on the element). A caller who wants no shell wants
+ * rung 3 of the ladder, not a `null` here. Replacing it stays supported, which
+ * is the way to wrap it and change one thing.
+ */
+type ResourcePageSlots<T extends Record<string, unknown> = Record<string, unknown>> = Omit<Slots<ResourcePageSlotMap<T>>, "shell"> & {
+    shell?: ComponentType<ComponentProps<typeof DataPageShell>>;
+};
+/**
+ * `slotProps` for {@link ResourcePage}: extra props merged into a part you
+ * are keeping, winning over ResourcePage's own.
+ */
+type ResourcePageSlotProps<T extends Record<string, unknown> = Record<string, unknown>> = SlotPropsFor<ResourcePageSlotMap<T>>;
+/**
+ * Copy for the built-in delete confirmation. Every field is optional;
+ * omitted ones fall back to `ConfirmDeleteDialog`'s defaults.
+ *
+ * @stability Beta
+ */
+interface ResourceDeleteConfirmCopy<T> {
+    /** Default "Delete this record?". A function receives the row. */
+    title?: string | ((item: T) => string);
+    /** Default "This can't be undone." */
+    description?: ReactNode | ((item: T) => ReactNode);
+    /** Default "Delete". */
+    confirmLabel?: string;
+    /** Default "Cancel". */
+    cancelLabel?: string;
+}
+interface ResourcePageProps<T extends Record<string, unknown> = Record<string, unknown>> {
+    /** Client-side mode: resource name passed to useResource / DataProvider. */
+    resource?: string;
+    /** Server-data mode: pre-fetched data array. */
+    data?: T[];
+    /**
+     * Server-data mode: total record count (before client-side filtering).
+     *
+     * Required whenever `onPageChange` is supplied. It cannot be derived from
+     * `data`, which holds only the current page. Omitted, `displayTotal` falls
+     * back to `0`, so the range span reads "No records" and `Next` stays
+     * disabled while the rows render directly below it. Rather than show a
+     * pager that contradicts the list, the component refuses to render the
+     * pager and shows an error instead. See {@link perPage} and
+     * {@link onPageChange}.
+     */
+    total?: number;
+    /**
+     * How `resource` mode reaches rows past the first page. Ignored with
+     * `data` (server-data mode pages through the controlled props instead).
+     *
+     * - `"client"` (default): fetch up to `clientRowLimit` rows in one request
+     *   and search, sort, filter and page them in the browser — header-click
+     *   sort and instant search keep working. If the resource holds more rows
+     *   than that, a notice under the list says how many are shown (and a
+     *   console warning names this prop), rather than silently truncating.
+     * - `"server"`: fetch one page at a time. The pager under the list drives
+     *   `useResource`'s page, the header's page size its `perPage`, and
+     *   search / sort / status chips become provider queries (search is
+     *   debounced), and the current page stays on screen while the next one
+     *   loads. Give `statusFilter` explicit `options` here — derived ones can
+     *   only see the current page's values. Search needs `searchFields` (or
+     *   `resourceOptions.searchFields`) — the provider must be told which
+     *   columns to match — so the search box is hidden without them. Table
+     *   header sorting is withdrawn, as in server-data mode; the sort control
+     *   in the filter row drives the query.
+     */
+    pagination?: "client" | "server";
+    /**
+     * `pagination="client"` only: the most rows fetched. Default 1000. An
+     * explicit `resourceOptions.defaultPerPage` wins. Keep it at or under the
+     * provider's `maxPerPage` (`capabilities().maxPerPage`; 1000 by default for
+     * Supabase): a larger page is refused, not cut short.
+     */
+    clientRowLimit?: number;
+    title: string;
+    /** Page subtitle shown below the title. */
+    subtitle?: string;
+    icon?: LucideIcon;
+    columns?: Array<string | ResourceColumnDef<T>>;
+    /**
+     * A row's identity, for React keys and bulk selection. Defaults to
+     * `String(item.id)`. Supply it for rows keyed some other way — a composite
+     * key (`encodeRecordKey` from `@marktiderman/genesis-core/schema`), or a
+     * table whose key column isn't called `id`. Detail `route` mode still
+     * navigates by `item.id`.
+     */
+    getKey?: (item: T) => string;
+    /** How row-click detail is shown. Default "panel". */
+    detail?: "panel" | "modal" | "route" | "none";
+    detailWidth?: "sm" | "md" | "lg";
+    titleField?: string;
+    subtitleField?: string;
+    /**
+     * Name a record from more than one field (`${first} ${last}`). Wins over
+     * `titleField` for the detail title and the card's accessible name.
+     */
+    getTitle?: (item: T) => string;
+    /**
+     * The detail peek's subtitle, computed from the row ("2 staff", "Due
+     * Friday"). Wins over `subtitleField`, which can only show one column
+     * verbatim.
+     */
+    getSubtitle?: (item: T) => string | undefined;
+    renderDetail?: (item: T) => ReactNode;
+    detailFields?: Array<{
+        key: string;
+        label: string;
+        render?: (value: unknown, item: T) => ReactNode;
+    }>;
+    /**
+     * Adds a status-chip filter. There is no dedicated status-change
+     * callback: chip clicks update the same filter state that already
+     * reports through `onFiltersChange`, whether or not the page is in
+     * server-controlled mode. A caller combining `statusFilter` with server
+     * pagination (`onPageChange` et al.) must supply `onFiltersChange` — see
+     * that prop — or status changes will update the chip UI without ever
+     * reaching the server. In server-controlled mode a status change also
+     * resets to page 1 via `onPageChange(1)` — see {@link onPageChange}.
+     */
+    statusFilter?: string | {
+        field: string;
+        options?: string[];
+    };
+    searchFields?: string[];
+    searchPlaceholder?: string;
+    initialFilters?: FilterParam[];
+    onFiltersChange?: (filters: FilterParam[]) => void;
+    /**
+     * Extra multi-select filter comboboxes, handed straight to `DataFilters`
+     * and rendered beside the status chips. Each config owns its own
+     * `selected` array and `onChange` — ResourcePage never reads or writes
+     * them, because it cannot know what a caller's "Grade" or "Subject"
+     * combobox means against the row shape. That is deliberate rather than a
+     * gap: the built-in machinery (`searchFields`, `statusFilter`) covers the
+     * two shapes it *can* interpret, and this prop covers everything else by
+     * getting out of the way.
+     *
+     * Two consequences of that hands-off stance, stated rather than hidden:
+     * - These selections are invisible to `page.hasActiveFilters`, so the
+     *   header's "Clear filters" affordance does not appear for them alone,
+     *   and `onClearFilters` does not reset them. DataFilters' own "Clear all"
+     *   does call each config's `onChange([])`, so wire real clearing there.
+     * - In client-side mode the rows are NOT re-filtered by these selections.
+     *   A caller using them is expected to filter its own `data` (or ask the
+     *   server to), exactly as it already does in server-controlled mode.
+     */
+    filters?: DataFilterConfig[];
+    /** Current page, 1-based. Server-controlled mode only. */
+    page?: number;
+    /**
+     * Rows per page the server was asked for. Required whenever
+     * `onPageChange` is supplied: pager math (total pages, range start, Next)
+     * cannot be inferred from `data.length`, because a short final page is
+     * smaller than the real page size. Wins over the per-user page size
+     * persisted by `viewSettingsKey` — an explicit prop always beats a stored
+     * preference.
+     *
+     * Required whenever `onPageChange` is supplied. A short final page (the
+     * server's last page returning fewer rows than its page size) is
+     * indistinguishable from a small page size — there is no correct way to
+     * infer the divisor from the rows handed back. Rather than guess and
+     * render a wrong range or a stuck Next button, the component refuses to
+     * render the pager and shows an error instead when `onPageChange` is
+     * present without `perPage`.
+     *
+     * `total` is required on the same terms — see {@link total}. The error
+     * names every missing prop, not just the first.
+     */
+    perPage?: number;
+    /**
+     * Called with the next 1-based page number. The pager only renders when
+     * this is supplied AND both `perPage` and `total` are supplied — see
+     * {@link perPage} and {@link total}. Supplying this without either one
+     * renders an error naming the missing props instead of a pager.
+     *
+     * Status changes reach the server through `onFiltersChange` — not a
+     * dedicated callback here — because `statusFilter` state is tracked by
+     * the same filter machinery that already calls `onFiltersChange`
+     * regardless of controlled mode (see {@link statusFilter}). In
+     * server-controlled mode a status change also calls `onPageChange(1)`
+     * directly, since the previous page number is meaningless against a new
+     * filtered result set.
+     */
+    onPageChange?: (page: number) => void;
+    /** Called when the user picks a different page size in the header's view settings. */
+    onPerPageChange?: (perPage: number) => void;
+    /** Called when the user changes the sort, with `null` when the sort is cleared. */
+    onSortChange?: (sort: SortParam | null) => void;
+    /** Called when the user changes the search text (including clearing it). */
+    onSearchChange?: (search: string) => void;
+    /**
+     * Server-data mode: the caller's fetch is in flight, so render the shell's
+     * loading skeleton instead of the (as yet meaningless) `data`. Ignored in
+     * client-side mode, where `useResource`'s own loading state is used.
+     */
+    loading?: boolean;
+    /**
+     * Server-data mode: the caller's fetch failed, so render the shell's error
+     * panel instead of an empty table. Takes effect even when `data` is
+     * non-empty — stale rows beside no indication of failure are exactly the
+     * silent-failure this prop exists to prevent. Ignored in client-side mode,
+     * where `useResource`'s own error state is used.
+     */
+    error?: boolean;
+    /**
+     * Message shown in the error panel, in place of the shell's generic
+     * "Failed to load …". Forwarded in both modes — it is inert unless an
+     * error state is actually showing — so a client-side page can also give
+     * its failure a human sentence.
+     */
+    errorMessage?: string;
+    /**
+     * Server-data mode: invoked by the error panel's Retry button. The button
+     * only appears when this is supplied, so a caller with no way to retry
+     * simply omits it and gets an error panel without a dead control. In
+     * client-side mode the button is already wired to `useResource`'s own
+     * `refetch` and this prop is ignored.
+     */
+    onRetry?: () => void;
+    /** Saved filter views to offer. Pair with `useSavedViews` for per-user storage. */
+    savedViews?: SavedViewItem[];
+    onLoadView?: (filters: Record<string, unknown>) => void;
+    onSaveView?: (name: string) => void;
+    onDeleteView?: (id: string) => void;
+    /** Show the "save current view" affordance. */
+    canSaveViews?: boolean;
+    /**
+     * What the data source can do. A control it can't serve is hidden rather
+     * than left to error (DATA-STUDIO.md decision 9): `search: false` hides the
+     * search box, `sort: false` the sort select. Pass a provider's
+     * `capabilities()` straight in. Omitted, both show, as before.
+     */
+    capabilities?: {
+        search?: boolean;
+        sort?: boolean;
+    };
+    /** Show the column-visibility dropdown. DataTable's default is `true`. */
+    columnVisibility?: boolean;
+    /** Persist key for the user's column-visibility picks. */
+    columnVisibilityKey?: string;
+    /** Allow drag-resizing columns. DataTable's default is `true`. */
+    resizableColumns?: boolean;
+    /** Persist key for the user's column widths. */
+    resizeKey?: string;
+    /** Keep the table header visible while scrolling. DataTable's default is `true`. */
+    stickyHeader?: boolean;
+    /** Keep the first column visible while scrolling horizontally. */
+    stickyFirstColumn?: boolean;
+    /**
+     * Page-size choices offered by `DataTable`'s own pager. Client-side mode
+     * only — server-controlled mode switches that pager off. (The header's
+     * view-settings popover has its own fixed 10/25/50/100 list.)
+     */
+    pageSizeOptions?: number[];
+    onCreate?: () => void;
+    onEdit?: (item: T) => void;
+    /**
+     * Delete handler, shown as the detail peek's Delete button. Called
+     * directly, as before, unless `confirmDelete` is set — then it runs after
+     * the confirm dialog, which shows its error if the returned promise
+     * rejects, and closes the peek when it resolves.
+     */
+    onDelete?: (item: T) => void | Promise<void>;
+    /**
+     * What the signed-in user may do: `can("create")`, `can("edit", item)`,
+     * `can("delete", item)`. Return false to hide the New button, or a row's
+     * Edit or Delete (and the built-in edit form won't open for it). Omitted,
+     * everything the handlers allow is offered. A UI gate only: the server
+     * must still refuse the write.
+     */
+    can?: (action: ResourceAction, item?: T) => boolean;
+    /**
+     * @deprecated Use `can` — `can={(action, item) => !item || mayChange(item)}`.
+     * Removed in the next minor after one deprecation window. Still honoured:
+     * a row it refuses gets no Edit and no Delete.
+     */
+    canEditItem?: (item: T) => boolean;
+    createLabel?: string;
+    /**
+     * @deprecated Use `can` — `can={(action, item) => action !== "edit" || !item || mayEdit(item)}`.
+     * Still honoured: a row it refuses gets no Edit.
+     */
+    canEdit?: (item: T) => boolean;
+    /**
+     * @deprecated Use `can` — `can={(action, item) => action !== "delete" || !item || mayDelete(item)}`.
+     * Still honoured: a row it refuses gets no Delete.
+     */
+    canDelete?: (item: T) => boolean;
+    /**
+     * Built-in delete for `resource` mode (ignored if `onDelete` is
+     * provided): the peek's Delete button opens a confirm dialog, then calls
+     * `useResource`'s `remove` with the row's `getKey` (when supplied) or its
+     * `id` — which invalidates the list — and closes the peek. A failure shows
+     * in the dialog.
+     */
+    allowDelete?: boolean;
+    /**
+     * Confirm before deleting. Defaults to `true` for `allowDelete` and
+     * `false` for `onDelete` (which keeps its old, unconfirmed behaviour).
+     * Pass an object to set the dialog's copy.
+     */
+    confirmDelete?: boolean | ResourceDeleteConfirmCopy<T>;
+    /** Called after a confirmed or built-in delete succeeds — e.g. a toast. */
+    onDeleted?: (item: T) => void;
+    /**
+     * Extra header actions beyond the create button, in one overflow menu.
+     * See {@link PageHeaderAction} — the budget is one primary, the rest here.
+     */
+    secondaryActions?: PageHeaderAction[];
+    /** Enable built-in create form (ignored if onCreate callback is provided). */
+    allowCreate?: boolean;
+    /** Enable built-in edit form (ignored if onEdit callback is provided). */
+    allowEdit?: boolean;
+    /** Field definitions for the built-in form. */
+    formFields?: ResourceFormFieldDef[];
+    /** Custom form renderer — receives form instance and resolved fields. */
+    renderForm?: (form: UseFormReturn<Record<string, unknown>>, fields: ResourceFormFieldDef[]) => ReactNode;
+    /** Form presentation mode. Default "standard". */
+    formMode?: "standard" | "wizard";
+    /** Wizard step definitions. Required when formMode is "wizard". */
+    formSteps?: WizardStep[];
+    /** Layout mode for the built-in form container. If not set, defaults to sheet for edit, dialog for create. */
+    formLayout?: "dialog" | "sheet" | "page";
+    /**
+     * When the built-in form's saves and deletes reach the list: `"pessimistic"`
+     * (default, wait for the provider), `"optimistic"` or `"undoable"` (an Undo
+     * toast). See ResourceForm `mutationMode`. `resourceOptions.mutationMode`
+     * wins for deletes.
+     */
+    mutationMode?: MutationMode;
+    bulkActions?: Array<{
+        label: string;
+        icon?: LucideIcon;
+        variant?: "default" | "destructive";
+        onAction: (ids: string[]) => void | Promise<void>;
+        /**
+         * Forwarded straight to the rendered bulk button (see `BulkAction`).
+         * Exists so a consumer can kill every bulk action while one of them is
+         * in flight — an early return inside `onAction` blocks the second call
+         * but leaves the button looking live, which misstates what it will do.
+         */
+        disabled?: boolean;
+        /** `data-testid` on the rendered bulk button, so e2e can drive it. */
+        testId?: string;
+    }>;
+    /**
+     * Override the default card renderer used for grid view (and, absent a
+     * dedicated list layout, list view too — DataGrid falls back to the same
+     * renderer there). ResourcePage still owns data-fetching, filtering,
+     * sorting, and layout (grid columns, infinite-scroll batching, stagger
+     * animation) — this only swaps what's rendered inside each item slot.
+     *
+     * Receives `ResourceCardActions`: the row's `update`/`remove`/`refetch`
+     * plus `open()` to activate the row (opening the configured detail
+     * panel/modal/route). Row activation is *not* applied automatically to a
+     * custom card — wrapping it would double-fire against cards that bring
+     * their own click handling and would hijack clicks on nested buttons — so
+     * call `actions.open()` from wherever your card should activate.
+     */
+    renderCard?: (item: T, index: number, actions: ResourceCardActions<T>) => ReactNode;
+    /**
+     * Replace the built-in `DataTable` that table view renders, keeping every
+     * other piece of the page — header, counts, view settings, filters,
+     * bulk bar, detail panel, form, pager — exactly as it is. The counterpart
+     * to `renderCard`, which does the same for grid and list view.
+     *
+     * Receives the rows for the current view, which in server-controlled mode
+     * is precisely the page the server returned. Ownership is total: row
+     * click-through, selection, density, column visibility and resizing are
+     * all things the built-in table wires for you and a custom table must
+     * wire for itself. That is the trade this prop makes, and it is why
+     * `renderCard` remains the lighter option when only the *cells* need to
+     * change — a `ResourceColumnDef.render` is lighter still.
+     *
+     * Omitted, the default `DataTable` render is used unchanged.
+     */
+    renderTable?: (items: T[]) => ReactNode;
+    /**
+     * With a custom `renderCard`: make each whole card (and list row) one
+     * keyboard-reachable button that opens the detail, so the card needs no
+     * `actions.open()` wiring and no hand-rolled `div role="button"`. Links and
+     * buttons inside the card keep their own clicks. Off by default, because
+     * an existing card that already calls `open()` would fire it twice.
+     */
+    openOnCardClick?: boolean;
+    /**
+     * Tailwind grid-column classes for the card grid, passed through to
+     * `DataGrid`'s `gridCols` — e.g. `"grid-cols-1 sm:grid-cols-2 lg:grid-cols-3"`.
+     * Defaults to DataGrid's own responsive 1/2/3/4-column ramp.
+     */
+    gridCols?: string;
+    /**
+     * Built-in list keyboard navigation via `useKeyboardNavigation`: j/k (or
+     * Arrow Up/Down) move a focus cursor, Enter opens the focused item,
+     * Backspace (⌫) closes an open detail view, and x toggles the focused
+     * item's selection when `bulkActions` are configured. Set to `false` to
+     * opt out.
+     *
+     * Default-on, and scoped so that being on by default stays safe:
+     * - The j/k cursor runs while the grid or list view is showing. Table view
+     *   keeps its own sort/pagination, so there `DataTable` handles the keys on
+     *   its focusable rows instead (↑/↓ or j/k, Home/End, Enter, x); this prop
+     *   turns that off too.
+     * - Cursor keys suspend while a detail panel/modal or the built-in form
+     *   is open, so they can't drive the list behind the overlay; ⌫ stays
+     *   live there so it can close it.
+     * - Backspace is only intercepted while there's an open detail to close.
+     * - Modified chords (Ctrl/Cmd/Alt) are never captured, so an app's
+     *   Cmd+K-style shortcuts keep working.
+     */
+    keyboardNavigation?: boolean;
+    toolbar?: ReactNode;
+    /** The empty state's action, e.g. the create button. */
+    emptyState?: ReactNode;
+    /** The empty state's icon. */
+    emptyIcon?: LucideIcon;
+    /** The empty state's title, e.g. "No tasks yet". Default "No results found". */
+    emptyMessage?: string;
+    /** A sentence under the empty-state title — forwarded to `DataPageShell`. */
+    emptyDescription?: string;
+    /**
+     * `"page"` (default) renders the full header with the title. `"toolbar"`
+     * keeps the header's actions (count, view toggle, settings, create) and
+     * drops the title block — for a list inside a tab or card whose page
+     * already has the heading. See `DataPageShell`'s `header`.
+     */
+    header?: "page" | "toolbar";
+    /**
+     * Imperative navigation used only when `detail="route"` (navigates to
+     * `/{resource}/{id}` on row click). Defaults to a full-page navigation.
+     * Router consumers pass their navigate fn — e.g. RR `useNavigate()` or
+     * Next `router.push`.
+     */
+    onNavigate?: NavigateFn;
+    resourceOptions?: UseResourceOptions<T>;
+    /**
+     * Keep the list's state in the URL: the open record (`?id=`), the search
+     * (`q`), the sort (`sort=field:asc`) and, with `pagination="server"`, the
+     * page. Pass your router's search-params adapter
+     * (`useReactRouterSearchParams()`, `useTanStackRouterSearchParams()`, or
+     * `useBrowserSearchParams()` with no router), or `{ searchParams, params }`
+     * to rename the keys. A copied link reopens the same record, and Back
+     * closes one that was opened. Search and sort are read when the page
+     * mounts and written as they change. A server-controlled page owns its
+     * own page, sort and search: use `useResourceUrlState` there.
+     */
+    urlState?: SearchParamsAdapter | ResourceUrlStateOptions;
+    /**
+     * The view shown until the user picks one with the view toggle. Default
+     * `"table"`. Pass `{ mobile: "grid", desktop: "table" }` for cards on
+     * phones and a table on desktops. Only an explicit pick is persisted, so
+     * the responsive default stays responsive until the user chooses.
+     */
+    defaultView?: ViewModeDefault;
+    /**
+     * Persist key for density / page size via `useViewSettings`.
+     * Defaults to `resource` or a slug of `title`.
+     */
+    viewSettingsKey?: string;
+    /**
+     * The interior parts `ResourcePage` composes, by name. Replace one with your
+     * own component, or pass `null` to eject it entirely — see
+     * {@link ResourcePageSlots}.
+     *
+     * This is the reason a surface that needs one part to differ does not have
+     * to drop to the primitives and re-derive the pagination, selection and
+     * detail wiring that were already correct.
+     */
+    slots?: ResourcePageSlots<T>;
+    /** Extra props merged into a part you are KEEPING. Wins over ours. */
+    slotProps?: ResourcePageSlotProps<T>;
+    /** Merged onto the page shell's root. */
+    className?: string;
+}
+/**
+ * A list page for a resource: header, filters, table or cards, paging,
+ * the open record's panel, and the built-in form and confirmed delete.
+ * {@link useResourceTable} is the same behaviour without this markup.
+ */
+declare function ResourcePage<T extends Record<string, unknown> = Record<string, unknown>>(props: ResourcePageProps<T>): React.JSX.Element;
+
+/**
+ * What {@link useResourceTable} returns: the list's rows and the handlers a
+ * custom layout wires to its controls.
+ *
+ * @stability Beta
+ */
+interface ResourceTableState<T extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * The rows to show: filtered and sorted. With `pagination="client"` this
+     * is every matching row (page it yourself); with server paging it is the
+     * current page.
+     */
+    rows: T[];
+    /** How many rows match, across all pages. */
+    total: number;
+    loading: boolean;
+    /** The read failed. */
+    error: boolean;
+    /** True when more than `clientRowLimit` rows exist and only that many were loaded. */
+    truncated: boolean;
+    /** The columns, resolved to DataTable's format. */
+    columns: DataTableColumn<T>[];
+    /** Write actions for cell renderers (update, remove, …). */
+    actions: ResourceActions<T>;
+    /** A row's identity: `getKey`, else its `id`. */
+    getKey: (item: T) => string;
+    /** A row's title: `getTitle`, else its title field. */
+    getTitle: (item: T) => string;
+    /** The page's permission check (`can`, then the deprecated per-row predicates). */
+    can: (action: ResourceAction, item?: T) => boolean;
+    search: string;
+    setSearch: (value: string) => void;
+    /** Sort keys, primary first. */
+    sort: DataTableSort[];
+    setSort: (sort: DataTableSort[]) => void;
+    /** The status filter's choices, its selected values and its setter, when the list has one. */
+    statusFilter: {
+        options: string[];
+        selected: string[];
+        onChange: (values: string[]) => void;
+    } | undefined;
+    hasActiveFilters: boolean;
+    clearFilters: () => void;
+    /** The current page, from 1. */
+    page: number;
+    pageCount: number;
+    pageSize: number;
+    setPageSize: (size: number) => void;
+    /** Go to a page; undefined when the page is not controlled (client paging). */
+    setPage: ((page: number) => void) | undefined;
+    /** The 1-based range of the rows shown, for "21–40 of 95"; 0 when empty. */
+    rangeFrom: number;
+    rangeTo: number;
+    selectedIds: Set<string>;
+    toggleSelected: (id: string) => void;
+    toggleAll: () => void;
+    clearSelection: () => void;
+    /** The open row, kept current as the data changes. */
+    openItem: T | null;
+    detailOpen: boolean;
+    /** What clicking a row does: opens the peek, modal or route. */
+    openRow: (item: T) => void;
+    closeDetail: () => void;
+    /** A record linked by URL that does not exist (or was deleted). */
+    openItemMissing: boolean;
+    /** Undefined when the page cannot create. */
+    create: (() => void) | undefined;
+    edit: (item: T) => void;
+    /** The built-in form's state, for rendering your own form. */
+    form: {
+        open: boolean;
+        setOpen: (open: boolean) => void;
+        action: "create" | "edit";
+        /** The row being edited; null when creating. */
+        item: T | null;
+    };
+    /** Delete a row: asks first when the delete is confirmed. Undefined when the page cannot delete. */
+    remove: ((item: T) => void) | undefined;
+    /** The confirm step's state, when `remove` asks first. */
+    deleteConfirm: {
+        open: boolean;
+        setOpen: (open: boolean) => void;
+        /** The row being confirmed (kept through the close animation). */
+        item: T | null;
+        /** Run the delete; rejects with the failure. */
+        confirm: () => Promise<void>;
+        /** "recycle" when the provider soft-deletes, so the copy can say it can be restored. */
+        kind: "recycle" | "permanent";
+        copy: ResourceDeleteConfirmCopy<T> | undefined;
+    };
+}
+/**
+ * The list behind {@link ResourcePage}, without any markup: where the rows
+ * come from (a `resource` through the data provider, or `data` you pass),
+ * search, sort, status filter and paging, selection, the open record (and
+ * its URL state), the built-in create/edit form and confirmed delete, and
+ * the row handlers. Takes the same options as `ResourcePage`.
+ *
+ * Use it to build a different layout over the same behaviour; `ResourcePage`
+ * itself is this behaviour plus Genesis's markup.
+ *
+ * @stability Beta
+ */
+declare function useResourceTable<T extends Record<string, unknown> = Record<string, unknown>>(props: ResourcePageProps<T>): ResourceTableState<T>;
+
+export { type BulkAction as B, ConfirmDeleteDialog as C, DataBulkBar as D, FilterCombobox as F, type ResourceTableState as R, type SavedViewItem as S, type ConfirmDeleteDialogProps as a, type DataFilterConfig as b, DataFilters as c, DataGrid as d, DataPageShell as e, type DataPageShellProps as f, DetailPanel as g, type DetailPanelProps as h, type FilterOption as i, type ResourceAction as j, type ResourceCardActions as k, type ResourceDeleteConfirmCopy as l, ResourceForm as m, type ResourceFormProps as n, ResourcePage as o, type ResourcePageProps as p, type ResourcePageSlotMap as q, type ResourcePageSlotProps as r, type ResourcePageSlots as s, type StatusChipOption as t, useResourceTable as u, type StatusChipsVariant as v };