@craftainer/crud-views 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1176 @@
+import { ComponentType, ReactElement, ReactNode } from "react";
+import { Theme } from "@mui/material/styles";
+import { InfiniteData, QueryClient, UseInfiniteQueryResult, UseMutationResult, UseQueryResult } from "@tanstack/react-query";
+import { BulkResult, Capabilities, CrudClient, Filters, JsonObject, Resource, ResourceClient } from "@craftainer/crud-sdk";
+import { CrudQuery, InfiniteListInit, TanstackApi, UpdateVariables } from "@craftainer/crud-sdk/tanstack";
+import { DataGridProps } from "@mui/x-data-grid";
+//#region src/core/types.d.ts
+/** What a manifest field renders as. `array` and `json` are fallbacks for schema members the manifest `fields` list does not cover. */
+type FieldKind = "string" | "number" | "integer" | "boolean" | "date" | "datetime" | "enum" | "array" | "json";
+/** The manifest's `filter_ops` vocabulary (`eq` is the bare `field=` form). */
+type FilterOp = "eq" | "min" | "max" | "in" | "contains" | "icontains" | "regex";
+/** A JSON value as it travels on the wire. */
+type FieldValue = string | number | boolean | null | undefined | readonly FieldValue[] | {
+  readonly [key: string]: FieldValue;
+};
+/** Validation hints lifted from the read/create/update JSON Schemas. */
+interface FieldConstraints {
+  readonly minLength: number | undefined;
+  readonly maxLength: number | undefined;
+  readonly minimum: number | undefined;
+  readonly maximum: number | undefined;
+  readonly pattern: string | undefined;
+}
+/** One field of a resource, merged from the manifest `fields` and `schemas`. */
+interface FieldDescriptor {
+  readonly name: string;
+  /** Human label derived from `name` (`power_level` -> `Power level`). */
+  readonly label: string;
+  readonly kind: FieldKind;
+  /** The JSON Schema `format` (`email`, `uri`, `uuid`, ...), or `null`. */
+  readonly format: string | null;
+  /** The value may be `null` (the schema allows it). */
+  readonly nullable: boolean;
+  /** Neither `create` nor `update` accepts it: show it, never edit it. */
+  readonly readOnly: boolean;
+  /** `create` requires it. */
+  readonly required: boolean;
+  /** `enum` choices (from the manifest field, else the schema). */
+  readonly choices: readonly string[] | null;
+  /** For `array`, the kind of the items. */
+  readonly itemKind: FieldKind | null;
+  readonly constraints: FieldConstraints;
+  /** The manifest lists it as a field: it can be filtered/sorted per `filterOps`/`sortable`. */
+  readonly inManifest: boolean;
+  readonly sortable: boolean;
+  readonly filterOps: readonly FilterOp[];
+  readonly numeric: boolean;
+  readonly categorical: boolean;
+}
+/** One operand of a filter. `datetime` filters carry `Date`s, `date` filters `YYYY-MM-DD` strings (the SDK's query builder wants exactly that). */
+type FilterScalar = string | number | boolean | Date;
+/** The filter state of one field: operator -> operand (`in` takes an array). Absent or empty means no filter. */
+type FieldFilter = Readonly<Partial<Record<FilterOp, FilterScalar | readonly FilterScalar[]>>>;
+/** Filter state of a whole resource: field name -> its filter. */
+type FieldFilters = Readonly<Record<string, FieldFilter | undefined>>;
+/** Props every renderer gets. */
+interface RendererBase {
+  readonly field: FieldDescriptor;
+  /** The resource name, for renderers that special-case a field. */
+  readonly resource: string;
+  readonly size?: "small" | "medium" | undefined;
+}
+/** Shows a value. `value` is the wire value (`undefined` when the record has no such member). */
+interface DisplayRendererProps extends RendererBase {
+  readonly value: FieldValue;
+  readonly record?: Readonly<Record<string, FieldValue>> | undefined;
+}
+/**
+ * Edits a value. Wire values in and out: strings for `string`/`enum`/`date`
+ * (`YYYY-MM-DD`)/`datetime` (ISO-8601 UTC), numbers for `number`/`integer`,
+ * booleans, arrays and JSON for `array`/`json`. A cleared input emits `null`
+ * when the field is nullable, else `undefined` (leave the member out).
+ */
+interface InputRendererProps extends RendererBase {
+  readonly value: FieldValue;
+  readonly onChange: (value: FieldValue) => void;
+  readonly onBlur?: (() => void) | undefined;
+  /** Validation message to show (the form owns validation). */
+  readonly error?: string | undefined;
+  readonly helperText?: string | undefined;
+  readonly disabled?: boolean | undefined;
+  readonly autoFocus?: boolean | undefined;
+  readonly id?: string | undefined;
+  /**
+   * Reports whether the input's own draft is invalid, with the reason: it is
+   * called with a message when the draft cannot be turned into a valid value
+   * (non-numeric, malformed JSON, out of range) and with `null` when it is
+   * valid again (or the input unmounts). A form blocks submit while any field
+   * reports a reason. Additive to the frozen I4 (ADR 0002 addendum).
+   */
+  readonly onInvalid?: ((reason: string | null) => void) | undefined;
+}
+/** Edits the filter of one field. Emits `undefined` when cleared. */
+interface FilterRendererProps extends RendererBase {
+  readonly value: FieldFilter | undefined;
+  readonly onChange: (value: FieldFilter | undefined) => void;
+}
+type DisplayRenderer = ComponentType<DisplayRendererProps>;
+type InputRenderer = ComponentType<InputRendererProps>;
+type FilterRenderer = ComponentType<FilterRendererProps>;
+type RendererRole = "display" | "input" | "filter";
+/** The three renderers for one selector; each is optional. */
+interface FieldRenderers {
+  readonly display?: DisplayRenderer;
+  readonly input?: InputRenderer;
+  readonly filter?: FilterRenderer;
+}
+/**
+ * Selector -> renderers. A selector is `"<resource>.<field>"` (one field),
+ * `"<kind>:<format>"` (`string:email`) or `"<kind>"` (`date`).
+ */
+type RendererOverrides = Readonly<Record<string, FieldRenderers>>;
+//#endregion
+//#region src/core/provider.d.ts
+interface CrudProviderProps {
+  readonly client: CrudClient;
+  readonly queryClient: QueryClient;
+  /** Wraps the tree in this MUI theme. Omit to inherit the ambient theme. */
+  readonly theme?: Theme | undefined;
+  /** Renderer overrides for this tree (selector -> renderers). */
+  readonly renderers?: RendererOverrides | undefined;
+  readonly scope?: string | undefined;
+  readonly locale?: string | undefined;
+  readonly timeZone?: string | undefined;
+  readonly children?: ReactNode;
+}
+/** Provides the SDK client, the TanStack `QueryClient`, an optional MUI theme and renderer overrides. */
+export declare function CrudProvider({ client, queryClient, theme, renderers, scope, locale, timeZone, children }: CrudProviderProps): ReactElement;
+//#endregion
+//#region src/core/context.d.ts
+/** What `useCrud` returns. */
+interface CrudContextValue {
+  readonly client: CrudClient;
+  readonly queryClient: QueryClient;
+  /** Separates cached manifests of different callers (e.g. the user id). */
+  readonly scope: string;
+  /** BCP 47 tag for number and date formatting; `undefined` = the browser's. */
+  readonly locale: string | undefined;
+  /** IANA zone for `datetime` display; `undefined` = the browser's. */
+  readonly timeZone: string | undefined;
+  readonly renderers: RendererOverrides | undefined;
+}
+/** The provider's value; throws outside a `CrudProvider`. */
+export declare function useCrud(): CrudContextValue;
+//#endregion
+//#region src/core/useResource.d.ts
+/** TanStack hooks bound to one resource. Stable between renders while the resource is. */
+interface ResourceHooks<Read extends object = JsonObject, Create extends object = JsonObject, Update extends object = JsonObject> {
+  useList(query?: CrudQuery): UseQueryResult<Read[]>;
+  useInfiniteList(query?: CrudQuery, init?: InfiniteListInit): UseInfiniteQueryResult<InfiniteData<Read[], number>>;
+  useRecord(id: number): UseQueryResult<Read>;
+  useStats(query?: CrudQuery): UseQueryResult<JsonObject>;
+  usePredict(query?: CrudQuery): UseQueryResult<JsonObject>;
+  useRevisions(id: number): UseQueryResult<JsonObject[]>;
+  /** Invalidates lists, stats and predictions on success. */
+  useCreate(): UseMutationResult<Read, Error, Create>;
+  /** Variables carry `ifMatch` for `If-Match`; a stale one fails with `PreconditionFailed`. */
+  useUpdate(): UseMutationResult<Read, Error, UpdateVariables<Update>>;
+  useDelete(): UseMutationResult<unknown, Error, number>;
+}
+/** The loaded state of `useResource`. */
+interface ReadyResource<Read extends object = JsonObject, Create extends object = JsonObject, Update extends object = JsonObject> {
+  readonly status: "ready";
+  readonly error: null;
+  /** The manifest entry (schemas, fields, pagination, paths, ...). */
+  readonly resource: Resource;
+  /** Shortcut for `resource.capabilities`: gate every optional view on it. */
+  readonly capabilities: Capabilities;
+  readonly fields: readonly FieldDescriptor[];
+  field(name: string): FieldDescriptor | undefined;
+  /** The SDK handle, for calls the hooks do not cover (clone, publish, restore, bulk). */
+  readonly handle: ResourceClient<Read, Create, Update>;
+  readonly api: TanstackApi<Read, Create, Update>;
+  readonly hooks: ResourceHooks<Read, Create, Update>;
+}
+interface PendingResource {
+  readonly status: "pending";
+  readonly error: null;
+}
+interface FailedResource {
+  readonly status: "error";
+  readonly error: Error;
+}
+type UseResourceResult<Read extends object = JsonObject, Create extends object = JsonObject, Update extends object = JsonObject> = PendingResource | FailedResource | ReadyResource<Read, Create, Update>;
+/**
+ * Loads the manifest (once per caller scope) and returns the resource `name`
+ * (the highest `api_version` unless given) with its capabilities, described
+ * fields, SDK handle and TanStack hooks. Query keys use `name`, or
+ * `name@apiVersion` when `apiVersion` is given, so two versions never share a cache entry.
+ */
+export declare function useResource<Read extends object = JsonObject, Create extends object = JsonObject, Update extends object = JsonObject>(name: string, apiVersion?: string): UseResourceResult<Read, Create, Update>;
+//#endregion
+//#region src/core/ResourceGate.d.ts
+interface ResourceGateProps {
+  readonly name: string;
+  readonly apiVersion?: string | undefined;
+  /** Shown while the manifest loads. Default: a spinner. */
+  readonly pending?: ReactNode;
+  /** Shown on failure (unknown resource, network). Default: an error alert. */
+  readonly fallback?: ((error: Error) => ReactNode) | undefined;
+  readonly children: (ready: ReadyResource) => ReactNode;
+}
+/** Renders `children` once the resource is loaded; the common loading and error states otherwise. */
+export declare function ResourceGate({ name, apiVersion, pending, fallback, children }: ResourceGateProps): ReactElement;
+//#endregion
+//#region src/core/fields.d.ts
+/** `power_level` -> `Power level`. */
+export declare function humanize(name: string): string;
+/**
+ * Every field of `resource`, in read-schema order, then manifest fields the
+ * read schema does not list. The `id` field is included (read only).
+ */
+export declare function describeFields(resource: Resource): readonly FieldDescriptor[];
+//#endregion
+//#region src/core/registry.d.ts
+/** The renderer type of each role. */
+interface RendererByRole {
+  readonly display: DisplayRenderer;
+  readonly input: InputRenderer;
+  readonly filter: FilterRenderer;
+}
+/** The selectors that match `field` of `resource`, most specific first. */
+export declare function selectorsFor(field: FieldDescriptor, resource: string): readonly string[];
+/** One renderer role resolved from `layers` (nearest first); `undefined` when no layer has one. */
+export declare function resolveRenderer<R extends RendererRole>(role: R, field: FieldDescriptor, resource: string, layers: readonly (RendererOverrides | undefined)[]): RendererByRole[R] | undefined;
+/**
+ * Registers renderers process-wide (the layer between `CrudProvider`'s
+ * `renderers` and the built-ins). A later registration wins per role. Returns
+ * the function that removes exactly this registration, in any order.
+ * Prefer the provider's `renderers` prop in apps: this is shared state.
+ */
+export declare function registerFieldRenderer(selector: string, renderers: FieldRenderers): () => void;
+/** The process-wide registrations merged (a new object after every change). */
+export declare function getRegisteredRenderers(): RendererOverrides;
+//#endregion
+//#region src/core/renderers/builtins.d.ts
+/** The built-in layer: one entry per `FieldKind`. */
+export declare const builtinRenderers: RendererOverrides;
+//#endregion
+//#region src/core/fieldComponents.d.ts
+/** Props of the three field components: the renderer props plus a per-component override layer. */
+type WithOverrides<P> = P & {
+  /** Highest-precedence layer, for this one component. */
+  readonly renderers?: RendererOverrides | undefined;
+};
+/** Shows `value` with the resolved display renderer. */
+export declare function FieldDisplay({ renderers, ...props }: WithOverrides<DisplayRendererProps>): ReactElement;
+/** Edits a value with the resolved input renderer. */
+export declare function FieldInput({ renderers, ...props }: WithOverrides<InputRendererProps>): ReactElement;
+/** Edits the filter of a field with the resolved filter renderer. */
+export declare function FieldFilterInput({ renderers, ...props }: WithOverrides<FilterRendererProps>): ReactElement;
+//#endregion
+//#region src/core/values.d.ts
+/** What a cleared input emits: `null` for a nullable field, else `undefined`. */
+export declare const emptyValue: (field: FieldDescriptor) => FieldValue;
+//#endregion
+//#region src/core/filterState.d.ts
+/** Sets `op` on `current`; an empty operand removes it, and no operators left is `undefined`. */
+export declare function withOp(current: FieldFilter | undefined, op: FilterOp, operand: FilterScalar | readonly FilterScalar[] | undefined): FieldFilter | undefined;
+/** Whether the manifest lets a client filter on this field at all. */
+export declare const isFilterable: (field: FieldDescriptor) => boolean;
+//#endregion
+//#region src/core/filters.d.ts
+/**
+ * Turns per-field filter state into the SDK's flat `Filters`: `eq` is the bare
+ * field name, every other operator is `field__op`.
+ */
+export declare function toQueryFilters(filters: FieldFilters): Filters;
+//#endregion
+//#region src/core/shells.d.ts
+/** Props every shell shares. */
+interface ShellProps {
+  readonly title: ReactNode;
+  /** Buttons for the footer (dialog, drawer) or the header (page). */
+  readonly actions?: ReactNode;
+  readonly children?: ReactNode;
+}
+interface PageShellProps extends ShellProps {
+  readonly subtitle?: ReactNode;
+  /** Links shown above the title, e.g. `[<Link>Heroes</Link>]`. */
+  readonly breadcrumbs?: readonly ReactNode[] | undefined;
+  readonly maxWidth?: "sm" | "md" | "lg" | "xl" | false;
+}
+/** A full page: heading row (title, subtitle, actions) above the content. */
+export declare function PageShell({ title, subtitle, actions, breadcrumbs, maxWidth, children }: PageShellProps): ReactElement;
+interface OverlayShellProps extends ShellProps {
+  readonly open: boolean;
+  readonly onClose: () => void;
+  /** Label of the close button that is always present. Default "Close". */
+  readonly closeLabel?: string;
+}
+interface DialogShellProps extends OverlayShellProps {
+  readonly maxWidth?: "xs" | "sm" | "md" | "lg";
+}
+/** A modal dialog with a title, scrolling content and a footer of actions. */
+export declare function DialogShell({ open, onClose, title, actions, closeLabel, maxWidth, children }: DialogShellProps): ReactElement;
+interface DrawerShellProps extends OverlayShellProps {
+  readonly anchor?: "left" | "right";
+  /** Width in theme spacing units on screens from `sm` up (full width below). Default 60. */
+  readonly width?: number;
+}
+/** A side drawer with a title, scrolling content and a footer of actions. */
+export declare function DrawerShell({ open, onClose, title, actions, closeLabel, anchor, width, children }: DrawerShellProps): ReactElement;
+//#endregion
+//#region src/bulk/selection.d.ts
+/** Which records are selected: explicit ids, or every record matching the current filters. */
+interface BulkSelection {
+  /** Ids ticked by hand (empty while `allMatching`). */
+  readonly selected: readonly number[];
+  /** All records matching the list's filters are selected, on every page. */
+  readonly allMatching: boolean;
+  isSelected(id: number): boolean;
+  /**
+   * Ticks or unticks one record. Passing the visible page's ids lets an
+   * untick while `allMatching` keep the other visible records selected.
+   */
+  toggle(id: number, visible?: readonly number[]): void;
+  /** Ticks or unticks every id of the visible page. */
+  setPage(ids: readonly number[], on: boolean): void;
+  selectAllMatching(): void;
+  clear(): void;
+}
+/** Selection state for a list. Ticking a row after "select all matching" returns to explicit ids. */
+export declare function useBulkSelection(): BulkSelection;
+//#endregion
+//#region src/bulk/BulkToolbar.d.ts
+type BulkAction = "delete" | "export" | "publish";
+interface BulkDone {
+  readonly action: BulkAction;
+  /** Records the call touched. */
+  readonly count: number;
+}
+interface BulkToolbarProps {
+  readonly ready: ReadyResource;
+  readonly selection: BulkSelection;
+  /** The list's current filters. "Select all matching" needs at least one. */
+  readonly filters?: FieldFilters | undefined;
+  /** Actions to offer; each also needs the matching capability. Default: all. */
+  readonly actions?: readonly BulkAction[] | undefined;
+  /** Receives the CSV of "Export"; default: a file download. */
+  readonly onExport?: ((csv: string, filename: string) => void) | undefined;
+  readonly onDone?: ((done: BulkDone) => void) | undefined;
+}
+/** The toolbar over a list's selection: count, bulk delete, export and bulk publish. Hidden while nothing is selected. */
+export declare function BulkToolbar({ ready, selection, filters, actions, onExport, onDone }: BulkToolbarProps): ReactElement | null;
+//#endregion
+//#region src/bulk/BulkRecords.d.ts
+interface BulkPanelProps extends Pick<BulkToolbarProps, "actions" | "onExport" | "onDone"> {
+  readonly ready: ReadyResource;
+  readonly filters?: FieldFilters | undefined;
+  /** Columns to show; default: the first four non-system fields. */
+  readonly columns?: readonly string[] | undefined;
+  /** Page size; default 25. */
+  readonly limit?: number | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A selectable table over one page of an already loaded resource, with the bulk toolbar above it. */
+export declare function BulkPanel({ ready, filters, columns, limit, renderers, ...toolbar }: BulkPanelProps): ReactElement;
+interface BulkRecordsProps extends Omit<BulkPanelProps, "ready"> {
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+}
+/**
+ * Records with checkboxes and the bulk toolbar: selection count, bulk delete,
+ * export, bulk publish and filter-based select-all (no count preview). Bulk
+ * calls respect `bulk.max_matched`.
+ */
+export declare function BulkRecords({ resource, apiVersion, ...rest }: BulkRecordsProps): ReactElement;
+//#endregion
+//#region src/bulk/errors.d.ts
+/** More records than the server will touch in one call (`bulk.max_matched`). */
+export declare class BulkLimitError extends Error {
+  constructor(max: number);
+}
+/**
+ * A message for a failed bulk call. The server answers `400` when a filter
+ * matches more than `bulk.max_matched` records (or the request is bad for
+ * another reason, which its own message then says).
+ */
+export declare function describeBulkError(error: Error, max: number): string;
+//#endregion
+//#region src/bulk/export.d.ts
+/** RFC 4180 CSV: a header of field names, then one line per record. Objects and arrays become JSON. */
+export declare function toCsv(fields: readonly FieldDescriptor[], rows: readonly JsonObject[]): string;
+/** Offers `text` to the browser as a file download. */
+export declare function downloadText(filename: string, text: string, type?: string): void;
+//#endregion
+//#region src/delete/DeleteAction.d.ts
+/**
+ * - `immediate`: delete on click.
+ * - `confirm`: ask first, showing the record.
+ * - `undo`: hold the deletion back for `undoMs`; Undo cancels it.
+ * - `soft`: delete (the server archives the record) and offer Undo, which
+ *   restores it; renders lifecycle's `ArchiveButton`, needs the `archive_restore`
+ *   capability, else renders nothing.
+ */
+type DeleteVariant = "immediate" | "confirm" | "undo" | "soft";
+interface DeleteActionProps {
+  readonly name: string;
+  readonly apiVersion?: string | undefined;
+  readonly id: number;
+  /** Default `"confirm"`. */
+  readonly variant?: DeleteVariant;
+  /** Button text. Default "Delete". */
+  readonly label?: string | undefined;
+  /** What one record is called in messages. Default "record". */
+  readonly recordLabel?: string | undefined;
+  /** Called once the record is deleted on the server. */
+  readonly onDeleted?: ((id: number) => void) | undefined;
+  /** Called when Undo cancelled a pending deletion or restored the record. */
+  readonly onUndone?: ((id: number) => void) | undefined;
+  /** `undo`: how long the deletion waits, in milliseconds. Default 6000. */
+  readonly undoMs?: number | undefined;
+  /** `confirm`: the fields shown. Default the first three besides `id`. */
+  readonly summaryFields?: readonly string[] | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A delete button for one record; see `DeleteActionProps`. */
+export declare function DeleteAction(props: DeleteActionProps): ReactElement;
+//#endregion
+//#region src/detail/RecordDetail.d.ts
+type DetailVariant = "page" | "form" | "metadata" | "tabs" | "dialog" | "drawer";
+/** What `renderForm` receives: enough to mount VW2's edit form for this record. */
+interface DetailFormContext {
+  readonly ready: ReadyResource;
+  readonly id: number;
+  readonly record: JsonObject;
+  /** Call after a save so the detail refetches. */
+  readonly onDone: () => void;
+}
+interface DetailPanelProps {
+  readonly ready: ReadyResource;
+  readonly id: number;
+  readonly variant?: DetailVariant | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+  /** Replaces the page title; default `<Resource title> #<id>`. */
+  readonly title?: ReactNode;
+  /**
+   * The `form` variant renders this in place of the field list, so the edit
+   * form (VW2's `RecordForm`, or your own) lives in the detail page without
+   * this package importing it.
+   */
+  readonly renderForm?: ((context: DetailFormContext) => ReactNode) | undefined;
+  /** `dialog` and `drawer`: whether it is shown (default true). */
+  readonly open?: boolean | undefined;
+  /** `dialog` and `drawer`: called when the overlay asks to close. */
+  readonly onClose?: (() => void) | undefined;
+  /** Called after a publish, discard, archive or restore. */
+  readonly onChanged?: (() => void) | undefined;
+}
+interface BodyProps {
+  readonly ready: ReadyResource;
+  readonly record: JsonObject;
+  readonly renderers: RendererOverrides | undefined;
+}
+/** The server-maintained fields: ids, owner, lifecycle and audit timestamps. */
+export declare function DetailMetadata({ ready, record, renderers }: BodyProps): ReactElement;
+/** One record of an already loaded resource, in the chosen `variant` (default `page`). */
+export declare function DetailPanel({ variant, open, ...rest }: DetailPanelProps): ReactElement;
+interface RecordDetailProps extends Omit<DetailPanelProps, "ready"> {
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+}
+/**
+ * The detail of one record: `page` (read-only fields), `form` (an edit form
+ * from `renderForm`), `metadata` (fields beside a metadata panel), `tabs`,
+ * `dialog` or `drawer`. Status, publish, discard, archive and restore actions
+ * show only when the manifest's `capabilities` allow them.
+ */
+export declare function RecordDetail({ resource, apiVersion, ...rest }: RecordDetailProps): ReactElement;
+//#endregion
+//#region src/detail/FieldList.d.ts
+interface FieldListProps {
+  readonly resource: string;
+  readonly fields: readonly FieldDescriptor[];
+  readonly record: JsonObject;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A label and value for each field, as a description list. */
+export declare function FieldList({ resource, fields, record, renderers }: FieldListProps): ReactElement;
+//#endregion
+//#region src/filter/FacetSidebar.d.ts
+interface FacetSidebarProps {
+  readonly ready: ReadyResource;
+  readonly filters: FieldFilters;
+  readonly onChange: (filters: FieldFilters) => void;
+  /** Field names to show. Default: every categorical field with known values. */
+  readonly fields?: readonly string[] | undefined;
+}
+/** Checkboxes for the categorical fields: pick values, the list narrows to them. */
+export declare function FacetSidebar({ ready, filters, onChange, fields }: FacetSidebarProps): ReactElement | null;
+//#endregion
+//#region src/filter/FilterBar.d.ts
+interface FilterBarProps {
+  readonly ready: ReadyResource;
+  readonly filters: FieldFilters;
+  readonly onChange: (filters: FieldFilters) => void;
+  /** Field names to show, in order. Default: every filterable field except the id. */
+  readonly fields?: readonly string[] | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** One filter control per field, side by side: the filters are all visible at once. */
+export declare function FilterBar({ ready, filters, onChange, fields, renderers }: FilterBarProps): ReactElement;
+//#endregion
+//#region src/filter/FilterBuilder.d.ts
+interface FilterBuilderProps {
+  readonly ready: ReadyResource;
+  readonly filters: FieldFilters;
+  readonly onChange: (filters: FieldFilters) => void;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/**
+ * A list of conditions, each "field, operator, operand". Operands use the
+ * field's filter renderer where it edits that operator, a text box otherwise.
+ * Several conditions on one field combine as the API does: all must hold.
+ */
+export declare function FilterBuilder({ ready, filters, onChange, renderers }: FilterBuilderProps): ReactElement;
+//#endregion
+//#region src/filter/FilterControl.d.ts
+interface FilterControlProps {
+  readonly field: FieldDescriptor;
+  readonly resource: string;
+  readonly value: FieldFilter | undefined;
+  readonly onChange: (value: FieldFilter | undefined) => void;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** The filter renderer of one field. A datetime filter says its operands are UTC. */
+export declare function FilterControl({ field, resource, value, onChange, renderers }: FilterControlProps): ReactElement;
+//#endregion
+//#region src/filter/QuickSearch.d.ts
+interface QuickSearchProps {
+  /** The string fields to search (`icontains`); see `QueryStateApi.searchFields`. */
+  readonly fields: readonly FieldDescriptor[];
+  readonly value: string;
+  /** The searched field; with several, a selector appears (the API cannot OR fields). */
+  readonly field: string | undefined;
+  readonly onChange: (value: string) => void;
+  readonly onFieldChange: (field: string) => void;
+  /** Wait this long after the last keystroke before calling `onChange`. Default 300. */
+  readonly debounceMs?: number | undefined;
+}
+/** A search box: case-insensitive "contains" on one string field. Renders nothing without one. */
+export declare function QuickSearch({ fields, value, field, onChange, onFieldChange, debounceMs }: QuickSearchProps): ReactElement | null;
+//#endregion
+//#region src/filter/queryState.d.ts
+/** One sort key: a sortable field and its direction. */
+interface SortKey {
+  readonly field: string;
+  readonly desc: boolean;
+}
+/** Everything a list view reads: filters, quick search, sort, paging and the visibility toggles. */
+interface QueryState {
+  readonly filters: FieldFilters;
+  /** Quick-search text (`icontains` on `qField`); empty means off. */
+  readonly q: string;
+  readonly qField: string | undefined;
+  readonly sort: readonly SortKey[];
+  /** 1-based. */
+  readonly page: number;
+  readonly pageSize: number;
+  readonly includeArchived: boolean;
+  readonly includeUnpublished: boolean;
+}
+/** Values the state falls back to while the URL says nothing. */
+interface QueryDefaults {
+  /** Default filter values; the user clears them and the URL remembers that. */
+  readonly filters?: FieldFilters | undefined;
+  readonly sort?: readonly SortKey[] | undefined;
+  readonly pageSize?: number | undefined;
+}
+/** What the codecs need to know about the resource. */
+interface QueryContext {
+  readonly fields: readonly FieldDescriptor[];
+  readonly defaults: QueryDefaults;
+  /** Prefix of every URL parameter, so several lists can share one page. */
+  readonly prefix: string;
+  /** Default quick-search field, from the `searchField` option or the first searchable one. */
+  readonly searchField: string | undefined;
+  /** The largest page size the server accepts, less one (the view asks for one extra row to learn whether a next page exists). */
+  readonly maxPageSize: number;
+}
+export declare const DEFAULT_PAGE_SIZE = 25;
+/** Fields the quick search can target: strings with `icontains`. */
+export declare const searchableFields: (fields: readonly FieldDescriptor[]) => FieldDescriptor[];
+/** The sort a header click or dropdown can use. */
+export declare const sortableFields: (fields: readonly FieldDescriptor[]) => FieldDescriptor[];
+/** The state with nothing in the URL. */
+export declare function initialState(ctx: QueryContext): QueryState;
+/** Reads typed text as the operand of `op` on `field` (`in` takes a comma-separated list); `undefined` when it does not parse. */
+export declare function parseOperand(field: FieldDescriptor, op: FilterOp, text: string): FilterScalar | readonly FilterScalar[] | undefined;
+/** The text form of an operand: the inverse of `parseOperand`. */
+export declare function formatOperand(operand: FilterScalar | readonly FilterScalar[]): string;
+/**
+ * The query string for `state`, merged into `base` (other parameters of the
+ * page survive). Values equal to the defaults are left out; a filter set that
+ * differs from the defaults is written with an `f` marker, so clearing a
+ * default filter sticks.
+ */
+export declare function encodeState(state: QueryState, ctx: QueryContext, base?: string): string;
+/** The state a query string describes; anything invalid for the resource is ignored. */
+export declare function decodeState(search: string, ctx: QueryContext): QueryState;
+/** The filters including the quick search, as per-field state. */
+export declare function effectiveFilters(state: QueryState): FieldFilters;
+/**
+ * The SDK query for `state`. `paged` adds `skip` and `limit` (one extra row,
+ * to learn whether a next page exists); an infinite list pages itself.
+ */
+export declare function toCrudQuery(state: QueryState, paged: boolean): CrudQuery;
+/** Whether any filter or quick search narrows the list. */
+export declare const isFiltered: (state: QueryState) => boolean;
+//#endregion
+//#region src/filter/urlAdapter.d.ts
+/** Reads and writes the query string (no leading `?`) the list state is kept in. */
+interface UrlAdapter {
+  /** The current query string. */
+  read(): string;
+  /** Replaces the query string; `push` adds a history entry, `replace` does not. */
+  write(search: string, mode: "push" | "replace"): void;
+  /** Calls `listener` whenever the query string changes, from anywhere; returns the unsubscribe. */
+  subscribe(listener: () => void): () => void;
+}
+/** An in-memory adapter: tests, stories, and embedded lists that must not touch the address bar. */
+export declare function memoryUrlAdapter(initial?: string): UrlAdapter;
+/** The default adapter: `window.location` and `history` (back and forward work). */
+export declare function windowUrlAdapter(): UrlAdapter;
+/** The process-wide window adapter, so every list on a page shares one listener set. */
+export declare function defaultUrlAdapter(): UrlAdapter;
+//#endregion
+//#region src/filter/useQueryState.d.ts
+interface QueryStateOptions {
+  /** Where the state lives. Default: the window's query string. */
+  readonly adapter?: UrlAdapter | undefined;
+  /** Prefix of this list's URL parameters; give each list on a page its own. */
+  readonly prefix?: string | undefined;
+  readonly defaults?: QueryDefaults | undefined;
+  /** The field the quick search targets first. Default: the first string field with `icontains`. */
+  readonly searchField?: string | undefined;
+}
+/** The URL-synced state of one list plus the setters and the SDK queries derived from it. */
+interface QueryStateApi {
+  readonly state: QueryState;
+  readonly fields: readonly FieldDescriptor[];
+  /** Fields the quick search can target. */
+  readonly searchFields: readonly FieldDescriptor[];
+  /** The query of a paged view: `skip` and `limit` (page size + 1, to detect a next page). */
+  readonly pagedQuery: CrudQuery;
+  /** The query of an infinite view: filters and sort only. */
+  readonly feedQuery: CrudQuery;
+  /** Any change but the page itself returns to page 1. */
+  setFilters(filters: FieldFilters): void;
+  setQuickSearch(q: string): void;
+  setQuickSearchField(field: string): void;
+  setSort(sort: readonly SortKey[]): void;
+  setPage(page: number): void;
+  setPageSize(pageSize: number): void;
+  setIncludeArchived(on: boolean): void;
+  setIncludeUnpublished(on: boolean): void;
+  /** Back to the defaults. */
+  reset(): void;
+}
+/**
+ * Filter, sort and paging state for `ready`, kept in the URL through the
+ * adapter. Operands are validated against the manifest, so a stale or
+ * hand-edited link degrades to the defaults instead of failing the request.
+ */
+export declare function useQueryState(ready: ReadyResource, options?: QueryStateOptions): QueryStateApi;
+//#endregion
+//#region src/form/sections.d.ts
+/** A titled group of fields, by field name. */
+interface FormSection {
+  readonly title: string;
+  readonly fields: readonly string[];
+}
+type FormLayoutKind = "flat" | "sections" | "tabs" | "stepper";
+/**
+ * The sections of a form. Given `sections`, fields they do not name go to a
+ * trailing "Other" section; without them, required fields come first under
+ * "Required", the rest under "Optional". Empty sections are dropped.
+ */
+export declare function groupFields(fields: readonly FieldDescriptor[], sections: readonly FormSection[] | undefined): readonly FormSection[];
+//#endregion
+//#region src/form/ResourceForm.d.ts
+type Row$2 = Readonly<Record<string, FieldValue>>;
+interface ResourceFormProps {
+  /** The manifest resource name. */
+  readonly name: string;
+  readonly apiVersion?: string | undefined;
+  /** Edit this record; without it the form creates one. */
+  readonly id?: number | undefined;
+  /** Where the form renders. Default `"page"`. */
+  readonly presentation?: "page" | "dialog" | "drawer";
+  /** Dialog and drawer: whether it shows (a closed one renders nothing). */
+  readonly open?: boolean | undefined;
+  readonly onClose?: (() => void) | undefined;
+  /** How fields are arranged. Default `"flat"`. */
+  readonly layout?: FormLayoutKind;
+  /** Titled groups of field names for `sections`, `tabs` and `stepper`; default Required and Optional. */
+  readonly sections?: readonly FormSection[] | undefined;
+  /** Only these fields (in the resource's order). Default every writable field. */
+  readonly fields?: readonly string[] | undefined;
+  /** Create: starting values. */
+  readonly initial?: Row$2 | undefined;
+  /** Edit: save by itself after a pause in typing, while the form is valid. */
+  readonly autoSave?: boolean | undefined;
+  /** Pause before an auto-save, in milliseconds. Default 1000. */
+  readonly autoSaveDelayMs?: number | undefined;
+  /**
+   * The record's current ETag, sent as `If-Match` on every save (edit only,
+   * when the resource has `conditional_requests`). Called before each save,
+   * because a save changes the ETag. Without it no header is sent by the form
+   * (the SDK cache's `autoIfMatch` can still add one).
+   */
+  readonly etag?: ((id: number) => string | undefined | Promise<string | undefined>) | undefined;
+  readonly onSaved?: ((record: JsonObject) => void) | undefined;
+  /** Heading override. Default "New <recordLabel>" or "Edit <recordLabel> <id>". */
+  readonly title?: ReactNode;
+  /** What one record is called in titles. Default "record". */
+  readonly recordLabel?: string | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A create or edit form for a resource; see `ResourceFormProps`. */
+export declare function ResourceForm(props: ResourceFormProps): ReactElement | null;
+//#endregion
+//#region src/form/problem.d.ts
+/** What a failed save shows. */
+interface SaveFailure {
+  /** 412: the record changed since it was loaded. */
+  readonly conflict: boolean;
+  /** Messages by field name, from 422 `errors`. */
+  readonly fieldErrors: Readonly<Record<string, string>>;
+  /** Text for an alert: everything not tied to a visible field. */
+  readonly message: string | null;
+}
+/** Splits a mutation error into field messages, a conflict flag and an alert message. */
+export declare function describeFailure(error: unknown, fieldNames: readonly string[]): SaveFailure;
+//#endregion
+//#region src/form/validate.d.ts
+/**
+ * The message for the first schema constraint `value` breaks, or `null`.
+ * A missing value breaks only `required`; booleans are never missing.
+ */
+export declare function validateValue(field: FieldDescriptor, value: FieldValue): string | null;
+/** Errors by field name for every field whose value breaks a constraint. */
+export declare function validateAll(fields: readonly FieldDescriptor[], values: Readonly<Record<string, FieldValue>>): Record<string, string>;
+//#endregion
+//#region src/lifecycle/DraftControls.d.ts
+interface StatusBadgeProps {
+  readonly ready: ReadyResource;
+  readonly record: JsonObject;
+}
+/** A chip with the record's state. Hidden unless the resource has drafts or an archive. */
+export declare function StatusBadge({ ready, record }: StatusBadgeProps): ReactElement | null;
+interface RecordActionProps {
+  readonly ready: ReadyResource;
+  readonly id: number;
+  /** Called after the server accepted the change. */
+  readonly onDone?: (() => void) | undefined;
+}
+/** Publishes a draft. Hidden unless `capabilities.draft_publish`. */
+export declare function PublishButton({ ready, id, onDone }: RecordActionProps): ReactElement | null;
+/** Discards a draft after a confirmation (a draft has no published state to fall back to, so it is deleted). */
+export declare function DiscardDraftButton({ ready, id, onDone }: RecordActionProps): ReactElement | null;
+interface DraftControlsProps {
+  readonly ready: ReadyResource;
+  readonly record: JsonObject;
+  readonly id: number;
+  /** Called after a publish or a discard. */
+  readonly onChanged?: (() => void) | undefined;
+}
+/** Status badge plus, for a draft, Publish and Discard draft. Hidden without `draft_publish`. */
+export declare function DraftControls({ ready, record, id, onChanged }: DraftControlsProps): ReactElement | null;
+//#endregion
+//#region src/lifecycle/ArchiveControls.d.ts
+interface ArchivedToggleProps {
+  readonly ready: ReadyResource;
+  /** Maps to the list query's `includeArchived`. */
+  readonly checked: boolean;
+  readonly onChange: (checked: boolean) => void;
+}
+/** "Show archived" switch. Hidden unless `capabilities.archive_restore`. */
+export declare function ArchivedToggle({ ready, checked, onChange }: ArchivedToggleProps): ReactElement | null;
+/**
+ * Archives a record (the server's delete is a soft delete when it has an
+ * archive) and offers Undo, which restores it. Hidden without `archive_restore`.
+ */
+export declare function ArchiveButton({ ready, id, onDone, onArchived, onUndone, label, ariaLabel, archived }: RecordActionProps & {
+  /** Button text. Default "Archive". */
+  readonly label?: string | undefined;
+  /** Accessible name when the text alone is ambiguous, e.g. "Delete hero 1". */
+  readonly ariaLabel?: string | undefined;
+  /** Called once the record is archived (`onDone` also runs, as after an undo). */
+  readonly onArchived?: (() => void) | undefined;
+  /** Called once Undo restored the record. */
+  readonly onUndone?: (() => void) | undefined;
+  /** The record is archived already: the button hides, an Undo toast can still show. */
+  readonly archived?: boolean;
+}): ReactElement | null;
+/** Restores an archived record. Hidden without `archive_restore`. */
+export declare function RestoreButton({ ready, id, onDone }: RecordActionProps): ReactElement | null;
+//#endregion
+//#region src/lifecycle/ConfirmDialog.d.ts
+interface ConfirmDialogProps {
+  readonly open: boolean;
+  readonly title: string;
+  readonly children: ReactNode;
+  readonly confirmLabel: string;
+  readonly busy?: boolean;
+  readonly onConfirm: () => void;
+  readonly onClose: () => void;
+}
+/** A small confirmation built on `DialogShell`: Cancel and one destructive action. */
+export declare function ConfirmDialog({ open, title, children, confirmLabel, busy, onConfirm, onClose }: ConfirmDialogProps): ReactElement;
+//#endregion
+//#region src/lifecycle/mutations.d.ts
+/**
+ * Refreshes every cached query of one resource (all API versions), for the
+ * calls the core's hooks do not cover: publish, restore and bulk.
+ */
+export declare function useInvalidateResource(name: string): () => Promise<void>;
+/** `POST publish?id=`: turns a draft into a published record. */
+export declare function usePublish(ready: ReadyResource): UseMutationResult<JsonObject, Error, number>;
+/** `POST restore?id=`: brings an archived record back. */
+export declare function useRestore(ready: ReadyResource): UseMutationResult<BulkResult, Error, number>;
+//#endregion
+//#region src/lifecycle/status.d.ts
+type RecordStatus = "published" | "draft" | "archived";
+/** Fields the server maintains (lifecycle and audit); the detail view shows them in its metadata panel. */
+export declare const SYSTEM_FIELDS: readonly string[];
+/** `archived` wins over `draft`; a record with neither marker is `published`. */
+export declare function recordStatus(record: JsonObject): RecordStatus;
+type StatusFilterValue = "published" | "draft" | "all";
+/** What a list query needs for a status choice: spread into `useList`'s query. */
+interface StatusQuery {
+  readonly includeUnpublished: boolean;
+  readonly filters: Readonly<Record<string, unknown>>;
+}
+/**
+ * The list query for a status choice. The server hides drafts unless
+ * `include_unpublished` is set; `draft` also filters on `is_draft`.
+ */
+export declare function statusQuery(value: StatusFilterValue): StatusQuery;
+//#endregion
+//#region src/lifecycle/StatusFilter.d.ts
+interface StatusFilterProps {
+  readonly ready: ReadyResource;
+  readonly value: StatusFilterValue;
+  readonly onChange: (value: StatusFilterValue) => void;
+}
+/** Published / Draft / All. Hidden unless `capabilities.draft_publish`. */
+export declare function StatusFilter({ ready, value, onChange }: StatusFilterProps): ReactElement | null;
+//#endregion
+//#region src/lifecycle/TrashList.d.ts
+interface TrashPanelProps {
+  readonly ready: ReadyResource;
+  readonly renderers?: RendererOverrides | undefined;
+  /** Columns to show; default: the first three non-system fields. */
+  readonly columns?: readonly string[] | undefined;
+  /** Called after a record was restored. */
+  readonly onRestored?: ((id: number) => void) | undefined;
+}
+/** The archived records of an already loaded resource, each with Restore. Hidden without `archive_restore`. */
+export declare function TrashPanel(props: TrashPanelProps): ReactElement | null;
+interface TrashListProps extends Omit<TrashPanelProps, "ready"> {
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+}
+/** The trash: archived records with Restore. Renders nothing for a resource without an archive. */
+export declare function TrashList({ resource, apiVersion, ...rest }: TrashListProps): ReactElement;
+//#endregion
+//#region src/list/columns.d.ts
+/** A column: a field name, or a name with a header and a size. */
+type ColumnSpec = string | {
+  readonly field: string;
+  /** Header text. Default: the field's label. */
+  readonly header?: string | undefined;
+  /** Width in pixels (a number) for the table. */
+  readonly width?: number | undefined;
+};
+/** A resolved column. */
+interface Column {
+  readonly field: FieldDescriptor;
+  readonly header: string;
+  readonly width: number | undefined;
+}
+/**
+ * The columns to show. Default: every described field except JSON ones.
+ * Names the resource does not have are skipped.
+ */
+export declare function resolveColumns(ready: ReadyResource, columns?: readonly ColumnSpec[]): Column[];
+//#endregion
+//#region src/list/RecordCard.d.ts
+type Row = Readonly<Record<string, FieldValue>>;
+interface RecordCardProps {
+  readonly ready: ReadyResource;
+  readonly row: Row;
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  /** The field shown as the card's heading. Default: the first column. */
+  readonly titleField?: string | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+  readonly onClick?: ((row: Row) => void) | undefined;
+}
+/** One record as a card: a heading and a label/value pair per other column. */
+export declare function RecordCard({ ready, row, columns, titleField, renderers, onClick }: RecordCardProps): ReactElement;
+//#endregion
+//#region src/list/CardGridList.d.ts
+interface CardGridListProps {
+  readonly ready: ReadyResource;
+  readonly state: QueryStateApi;
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  readonly titleField?: string | undefined;
+  readonly onRowClick?: ((row: Row) => void) | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A page of cards in a responsive grid, with Previous and Next (the server reports no total). */
+export declare function CardGridList({ ready, state, columns, titleField, onRowClick, renderers }: CardGridListProps): ReactElement;
+//#endregion
+//#region src/list/CardList.d.ts
+interface CardListProps {
+  readonly ready: ReadyResource;
+  readonly rows: readonly Row[];
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  readonly titleField?: string | undefined;
+  /** `list`: one card per row; `grid`: as many as fit. */
+  readonly layout: "list" | "grid";
+  readonly onRowClick?: ((row: Row) => void) | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** The cards of the card views (and their empty state). */
+export declare function CardList({ ready, rows, columns, titleField, layout, onRowClick, renderers }: CardListProps): ReactElement;
+//#endregion
+//#region src/list/ColumnsMenu.d.ts
+interface ColumnsMenuProps {
+  readonly columns: readonly Column[];
+  /** Field names currently hidden. */
+  readonly hidden: ReadonlySet<string>;
+  readonly onChange: (hidden: ReadonlySet<string>) => void;
+}
+/** A button that opens a checklist of the columns, to show or hide each. */
+export declare function ColumnsMenu({ columns, hidden, onChange }: ColumnsMenuProps): ReactElement;
+//#endregion
+//#region src/list/DataTableList.d.ts
+type Row$1 = Readonly<Record<string, FieldValue>>;
+/** DataGrid props a caller may pass through (not the ones this view controls). */
+type GridOptions = Partial<Omit<DataGridProps, "onRowClick" | "rows" | "columns">>;
+interface DataTableListProps {
+  readonly ready: ReadyResource;
+  /** Filter, sort and paging state; see `useQueryState`. */
+  readonly state: QueryStateApi;
+  /** Columns in order. Default: every field but JSON ones. */
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  /** Show only columns the server can sort by. */
+  readonly sortableOnly?: boolean | undefined;
+  /** Let the user hide columns (a "Columns" button). Default true. */
+  readonly configurableColumns?: boolean | undefined;
+  /** Edit cells in place (double-click or Enter; Enter saves, Escape cancels). Read-only fields stay read-only. */
+  readonly editable?: boolean | undefined;
+  /**
+   * The ETag of a row, sent as `If-Match` on an inline edit (a stale one fails
+   * with 412 and the view reloads the row). The list endpoint returns no ETags,
+   * so the app supplies them (for example from its SDK cache); without this
+   * prop the edit is unconditional.
+   */
+  readonly ifMatch?: ((row: Row$1) => string | undefined) | undefined;
+  readonly pageSizeOptions?: readonly number[] | undefined;
+  readonly onRowClick?: ((row: Row$1) => void) | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+  /** Passed to the DataGrid last (a way to reach options this view does not expose). */
+  readonly gridProps?: GridOptions | undefined;
+}
+/** A paged data table (MUI X DataGrid): server-side sort and paging, optional inline editing. */
+export declare function DataTableList({ ready, state, columns, sortableOnly, configurableColumns, editable, ifMatch, pageSizeOptions, onRowClick, renderers, gridProps }: DataTableListProps): ReactElement;
+//#endregion
+//#region src/list/LoadMoreList.d.ts
+interface LoadMoreListProps {
+  readonly ready: ReadyResource;
+  readonly state: QueryStateApi;
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  readonly titleField?: string | undefined;
+  /** `list`: one card per row; `grid`: cards side by side. Default `list`. */
+  readonly layout?: "list" | "grid" | undefined;
+  readonly onRowClick?: ((row: Row) => void) | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+}
+/** A growing list: the first page, then "Load more" appends the next (`useInfiniteList`). The page number is not used. */
+export declare function LoadMoreList({ ready, state, columns, titleField, layout, onRowClick, renderers }: LoadMoreListProps): ReactElement;
+//#endregion
+//#region src/list/ResourceList.d.ts
+/** `table`: paged data table; `loadMore`: growing list; `cards`: paged card grid. */
+type ListVariant = "table" | "loadMore" | "cards";
+/** `quick`: search box; `bar`: a control per field; `builder`: field/operator/operand rows; `facets`: checkboxes for categorical fields. */
+type FilterVariant = "quick" | "bar" | "builder" | "facets";
+interface ResourceListProps {
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+  readonly variant?: ListVariant | undefined;
+  /** Which filter UIs to show, in addition to default filter values. Default `["quick"]`. */
+  readonly filters?: readonly FilterVariant[] | undefined;
+  /** Fields of the filter bar, in order. Default: all filterable fields. */
+  readonly barFields?: readonly string[] | undefined;
+  /** Fields of the facet sidebar. Default: all categorical fields. */
+  readonly facetFields?: readonly string[] | undefined;
+  readonly columns?: readonly ColumnSpec[] | undefined;
+  readonly titleField?: string | undefined;
+  /** Table only: edit cells in place. */
+  readonly editable?: boolean | undefined;
+  readonly ifMatch?: ((row: Row) => string | undefined) | undefined;
+  readonly sortableOnly?: boolean | undefined;
+  /** Show the sort dropdown. Default: for the card variants, which have no header to click. */
+  readonly sortDropdown?: boolean | undefined;
+  /** Where the state lives. Default: the window's query string. */
+  readonly urlAdapter?: UrlAdapter | undefined;
+  /** Prefix of this list's URL parameters. */
+  readonly prefix?: string | undefined;
+  readonly defaults?: QueryDefaults | undefined;
+  readonly searchField?: string | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+  readonly onRowClick?: ((row: Row) => void) | undefined;
+  readonly gridProps?: GridOptions | undefined;
+}
+/** A resource's list, ready to use: filters, sort and paging in the URL, one of three layouts. */
+export declare function ResourceList({ resource, apiVersion, ...props }: ResourceListProps): ReactElement;
+//#endregion
+//#region src/list/SortDropdown.d.ts
+interface SortDropdownProps {
+  readonly ready: ReadyResource;
+  readonly sort: readonly SortKey[];
+  readonly onChange: (sort: readonly SortKey[]) => void;
+}
+/** Sort by one field, for layouts with no header row to click. Lists only fields the manifest marks sortable. */
+export declare function SortDropdown({ ready, sort, onChange }: SortDropdownProps): ReactElement | null;
+//#endregion
+//#region src/revisions/revision.d.ts
+/** One entry of a record's history (`GET revisions?id=`, newest first). */
+interface Revision {
+  readonly id: number;
+  readonly action: string;
+  readonly actor: string;
+  /** ISO-8601 UTC. */
+  readonly createdAt: string;
+  /** The record as it was after the action. */
+  readonly snapshot: JsonObject;
+}
+/** Reads the server's revision rows. A row without a snapshot gets an empty one. */
+export declare function toRevisions(rows: readonly JsonObject[]): Revision[];
+/** Names of the `fields` whose value differs between two snapshots. */
+export declare function changedFields(fields: readonly FieldDescriptor[], before: JsonObject, after: JsonObject): string[];
+/**
+ * The `PATCH` body that puts a record back to `snapshot`: the writable fields
+ * the snapshot has. A `null` for a field that does not take `null` is left out,
+ * as a cleared optional field is everywhere else.
+ */
+export declare function restorePatch(fields: readonly FieldDescriptor[], snapshot: JsonObject): JsonObject;
+//#endregion
+//#region src/revisions/Revisions.d.ts
+type RevisionsVariant = "list" | "audit" | "diff" | "preview";
+interface RevisionsPanelProps {
+  readonly ready: ReadyResource;
+  readonly id: number;
+  readonly variant?: RevisionsVariant | undefined;
+  readonly renderers?: RendererOverrides | undefined;
+  /** Called after a revision was restored (list variant). */
+  readonly onRestored?: ((revision: Revision) => void) | undefined;
+}
+/** The history of one record of an already loaded resource. Hidden without `capabilities.revisions`. */
+export declare function RevisionsPanel(props: RevisionsPanelProps): ReactElement | null;
+interface RecordRevisionsProps extends Omit<RevisionsPanelProps, "ready"> {
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+}
+/**
+ * A record's revisions in one of four shapes: `list` (with Restore), `audit`
+ * (table), `diff` (two revisions compared) or `preview` (one snapshot).
+ */
+export declare function RecordRevisions({ resource, apiVersion, ...rest }: RecordRevisionsProps): ReactElement;
+//#endregion
+//#region src/stats/model.d.ts
+/** The time buckets the server aggregates by. */
+type Bucket = "day" | "week" | "month";
+//#endregion
+//#region src/stats/shared.d.ts
+/** Props every stats and prediction variant takes. */
+interface ViewProps {
+  /** The manifest resource name (`"heroes"`). */
+  readonly resource: string;
+  readonly apiVersion?: string | undefined;
+  /** Field-renderer overrides, passed to every `FieldDisplay` the view renders. */
+  readonly renderers?: RendererOverrides | undefined;
+}
+//#endregion
+//#region src/stats/StatsKpiCards.d.ts
+/** Variant 1: one card for the record count and one per numeric field (average, with its range). Hidden without the `stats` capability. */
+export declare function StatsKpiCards({ resource, apiVersion, renderers }: ViewProps): ReactElement;
+//#endregion
+//#region src/stats/StatsTimeSeries.d.ts
+interface StatsTimeSeriesProps extends ViewProps {
+  /** The initial bucket size. Default `"day"`. */
+  readonly bucket?: Bucket | undefined;
+}
+/**
+ * Variant 2: records created per UTC bucket as a line chart, with a
+ * day/week/month toggle. Buckets with no records are absent from the server's
+ * series and stay absent on the time axis. Hidden without the `stats`
+ * capability.
+ */
+export declare function StatsTimeSeries({ resource, apiVersion, bucket: initial }: StatsTimeSeriesProps): ReactElement;
+//#endregion
+//#region src/stats/StatsCategoryChart.d.ts
+type CategoryChartKind = "bar" | "pie";
+interface StatsCategoryChartProps extends ViewProps {
+  /** The initial chart. Default `"bar"`. */
+  readonly kind?: CategoryChartKind | undefined;
+  /** The categorical field shown first. Default: the first the server reports. */
+  readonly field?: string | undefined;
+}
+/**
+ * Variant 3: the value distribution of a boolean or enum field as a bar or pie
+ * chart, with a field picker and a chart-type toggle. Hidden without the
+ * `stats` capability.
+ */
+export declare function StatsCategoryChart({ resource, apiVersion, kind, field }: StatsCategoryChartProps): ReactElement;
+//#endregion
+//#region src/stats/StatsTablePanel.d.ts
+/**
+ * Variant 4: two tables, the numeric aggregates of every numeric field and
+ * the value counts of every categorical field. Values go through the field
+ * renderers. Hidden without the `stats` capability.
+ */
+export declare function StatsTablePanel({ resource, apiVersion, renderers }: ViewProps): ReactElement;
+//#endregion
+//#region src/stats/StatsDashboard.d.ts
+/** All four statistics variants on one page. Hidden without the `stats` capability. */
+export declare function StatsDashboard(props: ViewProps): ReactElement;
+//#endregion
+//#region src/stats/predictShared.d.ts
+/** What `/predict` is asked: a numeric field (default the record count), how many buckets ahead, and the bucket size. */
+interface PredictionQuery {
+  /** A numeric field to forecast the per-bucket sum of; omit to forecast the record count. */
+  readonly field?: string | undefined;
+  /** Buckets to project, 1 to 52. Default 4. */
+  readonly periods?: number | undefined;
+  /** Default `"day"`. */
+  readonly bucket?: Bucket | undefined;
+}
+type PredictionProps = ViewProps & PredictionQuery;
+//#endregion
+//#region src/stats/PredictionChart.d.ts
+/**
+ * Predictions variant 1: a line chart of the known series and the forecast
+ * after it. The history is the server's count series, so it is drawn only
+ * when the forecast is of the record count (no `field`) and `stats` is
+ * available; a field forecast shows its last known value and the projection.
+ * Hidden without the `predict` capability.
+ */
+export declare function PredictionChart(props: PredictionProps): ReactElement;
+//#endregion
+//#region src/stats/PredictionTable.d.ts
+/**
+ * Predictions variant 2: the last known value and every forecast bucket as a
+ * table, values shown by the field's renderer. Hidden without the `predict`
+ * capability.
+ */
+export declare function PredictionTable(props: PredictionProps): ReactElement;
+//#endregion
+//#region src/stats/PredictionKpi.d.ts
+/**
+ * Predictions variant 3: a card with the first forecast bucket's value and how
+ * it moves from the last known one. Hidden without the `predict` capability.
+ */
+export declare function PredictionKpi(props: PredictionProps): ReactElement;
+//#endregion
+//#region src/stats/PredictionsDashboard.d.ts
+/** All three prediction variants with the controls that drive them (field, buckets ahead, bucket size). Hidden without the `predict` capability. */
+export declare function PredictionsDashboard(props: ViewProps): ReactElement;
+//#endregion
+export type { ArchivedToggleProps, Bucket, BulkAction, BulkDone, BulkPanelProps, BulkRecordsProps, BulkSelection, BulkToolbarProps, CardGridListProps, CardListProps, CategoryChartKind, Column, ColumnSpec, ColumnsMenuProps, ConfirmDialogProps, CrudContextValue, CrudProviderProps, DataTableListProps, DeleteActionProps, DeleteVariant, DetailFormContext, DetailPanelProps, DetailVariant, DialogShellProps, DisplayRenderer, DisplayRendererProps, DraftControlsProps, DrawerShellProps, FacetSidebarProps, FailedResource, FieldConstraints, FieldDescriptor, FieldFilter, FieldFilters, FieldKind, FieldListProps, FieldRenderers, FieldValue, FilterBarProps, FilterBuilderProps, FilterControlProps, FilterOp, FilterRenderer, FilterRendererProps, FilterScalar, FilterVariant, FormLayoutKind, FormSection, GridOptions, InputRenderer, InputRendererProps, ListVariant, LoadMoreListProps, OverlayShellProps, PageShellProps, PendingResource, PredictionProps, PredictionQuery, QueryContext, QueryDefaults, QueryState, QueryStateApi, QueryStateOptions, QuickSearchProps, ReadyResource, RecordActionProps, RecordCardProps, RecordDetailProps, RecordRevisionsProps, RecordStatus, RendererByRole, RendererOverrides, RendererRole, ResourceFormProps, ResourceGateProps, ResourceHooks, ResourceListProps, Revision, RevisionsPanelProps, RevisionsVariant, Row, SaveFailure, ShellProps, SortDropdownProps, SortKey, StatsCategoryChartProps, StatsTimeSeriesProps, ViewProps as StatsViewProps, StatusBadgeProps, StatusFilterProps, StatusFilterValue, StatusQuery, TrashListProps, TrashPanelProps, UrlAdapter, UseResourceResult };
+//# sourceMappingURL=index.d.mts.map