import * as react_jsx_runtime from 'react/jsx-runtime'; import * as React from 'react'; import { DataTableExtendedProps } from '../data-table/index.js'; import { ColumnDef } from '../data-table/types.js'; import { useTableState } from '../data-table/use-table-state.js'; import { ConditionalRule } from '../../lib/table-properties-types.js'; import { DataListDisplayOptions } from '../../lib/data-list-display-options.js'; import { DataListViewType } from '../../lib/data-list-view.js'; import { ListPageConnectedViewRenderers } from './list-page-connected-view-body.js'; import { HubTableProps, HubDrawerToolbarProps, HubTableRendererArgs, HubTableHandle } from './hub-table.js'; import '../ui/responsive-action-row.js'; import '../data-table/leo-loading-row.js'; import '../../lib/leo-generation.js'; import '../ui/leo-icon.js'; import '../data-table/data-table-toolbar.js'; import '../../lib/column-cell-kind.js'; import '../../lib/status-badge-tints.js'; import '../../lib/column-filter-context.js'; import '../../lib/column-filter-person-options.js'; import '../../lib/row-height.js'; import '../data-table/row-reorder-handle.js'; import '../../data-list-view-registry-BBKzJxGS.js'; import './list-page-board-template.js'; import '../../lib/list-page-table-properties.js'; import '../../lib/hub-table-embedded-preview.js'; type TableState> = ReturnType>; /** * Pagination enable + page chrome. * * When the hub omits `onPaginationChange`, `HubTable` owns the Properties * "Pagination" toggle internally (Library / Placements pattern). Without this, * the drawer toggle is wired to a no-op and pagination never activates. * * When `effectivePagination === true` and the parent did NOT supply * `paginationOverride`, `HubTable` owns the page/pageSize internally and wraps the * default table + list renderers with `` + ``. Hubs * that need full control (e.g. server-side pagination) keep using `paginationOverride`. */ declare function useHubPagination>(props: HubTableProps): { effectivePagination: boolean; handlePaginationChange: (enabled: boolean) => void; internalPage: number; setInternalPage: React.Dispatch>; internalPageSize: number; setInternalPageSize: React.Dispatch>; embeddedPreviewRowLimit: number | undefined; setEmbeddedExpanded: (expanded: boolean) => void; chromeOwnedPagination: boolean; embeddedPreviewActive: boolean; tableEdgeInset: boolean; effectivePaginationOverride: { page: number; pageSize: number; } | undefined; handlePageChange: (p: number) => void; handlePageSizeChange: (n: number) => void; resetPage: () => void; clampPageToCount: (count: number) => void; }; type HubPagination = ReturnType; /** * When `persistKey` is set, mirror the table lifecycle (sort/search/filters/ * columns/row-height/gridlines) and the hub-managed `extras` (conditional * rules + pagination) into `localStorage`. SSR-safe + debounced — handled * entirely inside `useTableStateLifecycle`. */ declare function useHubPersistence>({ persistKey, persistTabId, columns, tableState, conditionalRules, setConditionalRules, pg, }: { persistKey: string | undefined; persistTabId: string | undefined; columns: ColumnDef[]; tableState: TableState; conditionalRules: ConditionalRule[]; setConditionalRules: (rules: ConditionalRule[]) => void; pg: HubPagination; }): void; declare function useHubDrawerToolbarProps>({ props, tableState, supportedViewTypes, filterFields, fieldDefinitions, resolveColumnLabel, display, pg, }: { props: HubTableProps; tableState: TableState; supportedViewTypes: readonly DataListViewType[]; filterFields: HubDrawerToolbarProps["filterFields"]; fieldDefinitions: HubDrawerToolbarProps["fieldDefinitions"]; resolveColumnLabel: (key: string) => string; display: { displayOptions: DataListDisplayOptions; patchDisplay: (patch: Partial) => void; conditionalRules: ConditionalRule[]; addConditionalRule: HubDrawerToolbarProps["onAddConditionalRule"]; removeConditionalRule: HubDrawerToolbarProps["onRemoveConditionalRule"]; updateConditionalRule: HubDrawerToolbarProps["onUpdateConditionalRule"]; }; pg: HubPagination; }): HubDrawerToolbarProps; declare function useHubImperativeHandle>({ handleRef, tableState, drawerToolbarProps, chromeOwnedPagination, }: { handleRef: React.Ref> | undefined; tableState: TableState; drawerToolbarProps: HubDrawerToolbarProps; chromeOwnedPagination: boolean; }): void; declare function useHubToolbar>({ props, tableState, displayOptions, drawerToolbarProps, tableEdgeInset, }: { props: HubTableProps; tableState: TableState; displayOptions: DataListDisplayOptions; drawerToolbarProps: HubDrawerToolbarProps; tableEdgeInset: boolean; }): react_jsx_runtime.JSX.Element; /** * Default `data-table` renderer — full DataTable with toolbar + bulk actions. When * `pagination === true` and the parent did not provide `paginationOverride`, the chrome * (CountSyncer + PaginationBar) is wrapped automatically so the drawer toggle "Show * pagination" works out of the box. Hubs that need finer control (custom chrome, * server-side paging) can still override via `tableRenderer`. */ declare function HubDefaultTable>({ hub, pg, state, displayOptions, conditionalRules, drawerToolbarProps, bulkActionsSlot, }: { hub: HubTableProps; pg: HubPagination; state: TableState; displayOptions: DataListDisplayOptions; conditionalRules: ConditionalRule[]; drawerToolbarProps: HubDrawerToolbarProps; bulkActionsSlot: DataTableExtendedProps["bulkActionsSlot"]; }): react_jsx_runtime.JSX.Element; /** * Dev-time warning when a `supportedViewType` has no renderer AND no centralized * default is available. `data-table` always falls back to the built-in * default; `list-with-toolbar` and `board-with-toolbar` fall back to the synthesised * defaults when the hub passes `renderListRow` / `renderBoardCard` (the happy path * for most hubs). The warning only fires for exotic surfaces that genuinely need an * explicit renderer entry. */ declare function warnAboutMissingRenderers>(props: HubTableProps, supportedViewTypes: readonly DataListViewType[]): void; /** * Compose `ListPageConnectedViewBody` renderers: the built-in `data-table` (or hub override) * plus each hub-provided non-table renderer. Wrapping in `() => …` defers execution until * the active view actually selects that kind — so heavy bodies (dashboard charts) don't * pay render cost on a table tab. */ declare function composeHubRenderers>({ hub, pg, args, renderTable, }: { hub: HubTableProps; pg: HubPagination; args: HubTableRendererArgs; renderTable: (args: HubTableRendererArgs) => React.ReactNode; }): ListPageConnectedViewRenderers; /** * Creation drawer (hideTrigger=true, gated on `creatingViewType`). Mounted as a * sibling so it has its own portal and never fights the live toolbar's Properties * button. The trigger is suppressed — the parent controls open state via * `creatingViewType` (driven through the effect into `creationState.setSheetOpen`). */ declare function HubCreationDrawer>({ hub, creatingViewType, creationState, creationConditionalRules, creationDisplayOptions, patchCreationDisplay, addCreationCR, removeCreationCR, updateCreationCR, filterFields, fieldDefinitions, resolveColumnLabel, supportedViewTypes, viewTypeLabel, }: { hub: HubTableProps; creatingViewType: DataListViewType; creationState: TableState; creationConditionalRules: ConditionalRule[]; creationDisplayOptions: DataListDisplayOptions; patchCreationDisplay: (patch: Partial) => void; addCreationCR: HubDrawerToolbarProps["onAddConditionalRule"]; removeCreationCR: HubDrawerToolbarProps["onRemoveConditionalRule"]; updateCreationCR: HubDrawerToolbarProps["onUpdateConditionalRule"]; filterFields: HubDrawerToolbarProps["filterFields"]; fieldDefinitions: HubDrawerToolbarProps["fieldDefinitions"]; resolveColumnLabel: (key: string) => string; supportedViewTypes: readonly DataListViewType[]; viewTypeLabel: string | undefined; }): react_jsx_runtime.JSX.Element; export { HubCreationDrawer, HubDefaultTable, type HubPagination, composeHubRenderers, useHubDrawerToolbarProps, useHubImperativeHandle, useHubPagination, useHubPersistence, useHubToolbar, warnAboutMissingRenderers };