@declarion/react 0.60.0 → 0.63.0

package/dist-lib/index.d.ts

@@ -1,150 +1,2516 @@
-import "./globals.css";
-export { App } from "./app";
-export { App as Declarion } from "./app";
-export type { LocalizedString, LanguageDef, Schema, Entity, EntityField, Screen, NavNode, Action, ChildRelation, StatusDef, StatusGroupDef, PropertyDef, EnumDef, ParameterDef, StructureDef, PkValues, } from "./types/schema";
-export { OrderedMap, fieldDisplayName, getPrimaryKeyFields, extractPkValues, pkValuePartsToId, pkValuesToId, pkValuesToDetailId, pkValuesFromId, resolveDetailRoute, buildDetailHrefFromId, buildEntityDetailHref, buildRowDetailHref, } from "./types/schema";
-export type { ListResponse, DataResponse, ListMeta, ApiError, AuthUser, LoginResponse, CheckSetupResponse, ListParams, Tenant, StatusInfo, PropertyValue, PublicParam, V2Meta, Refs, V2StatusInstance, V2PropertyInstance, V2ParamInstance, V2ListResponse, V2ListParams, EnrichedRow, } from "./types/api";
-export { CURSOR_SEMANTICS_MISMATCH, CURSOR_LANGUAGE_CHANGED, isCursorStaleError } from "./types/api";
-export { coerceDisplayString } from "./lib/display-value";
-export { EntityClient, RefCache, entityClient } from "./api/entities";
-export type { RowHelpers } from "./api/entities";
-export { executeAction, buildActionBody, ActionBatchError, deleteObject, restoreObject } from "./api/data";
-export type { ActionExecuteRequest, ActionExecuteResponse, ActionItemError, ActionItemSkip, } from "./api/data";
-export { Batch } from "./api/batch";
-export type { BatchOp, BatchOpResult, BatchResponse } from "./api/batch";
-export { useSchema } from "./hooks/useSchema";
-export { useEntity } from "./hooks/useEntity";
-export { useScreen } from "./hooks/useScreen";
-export { useCurrentScreen, CurrentScreenProvider } from "./hooks/useCurrentScreen";
-export type { CurrentScreen } from "./hooks/useCurrentScreen";
-export { useAuth } from "./hooks/useAuth";
-export { useEntityData, useEntityCount, entityDataQueryKey } from "./hooks/useEntityData";
-export { useCursorEntityData, cursorEntityDataQueryKey, cursorEntityStableKey, } from "./hooks/useCursorEntityData";
-export type { CursorEntityDataParams, CursorEntityDataResult, } from "./hooks/useCursorEntityData";
-export { useAllEntityData } from "./hooks/useAllEntityData";
-export { useObject, objectQueryKey } from "./hooks/useObject";
-export { useLiveObject } from "./hooks/useLiveObject";
-export type { LiveObjectResult } from "./hooks/useLiveObject";
-export { useActionData, useCursorActionData, actionDataQueryKey, cursorActionDataQueryKey, ACTION_DATA_KEY, ACTION_DATA_CURSOR_KEY, } from "./hooks/useActionData";
-export type { ActionListPage, CursorActionDataResult } from "./hooks/useActionData";
-export { useCreateObject, useUpdateObject, useDeleteObject } from "./hooks/useMutations";
-export { useDebounce } from "./hooks/useDebounce";
-export { ResponsiveModeProvider, useResponsiveMode, resolveViewportCategory, DEFAULT_RESPONSIVE_BREAKPOINTS, } from "./hooks/useResponsiveMode";
-export type { ResponsiveBreakpoints, ResponsiveMode, ResponsiveViewport, ViewportCategory, } from "./hooks/useResponsiveMode";
-export { usePublicParams, useResolvedParam, useEffectiveParam, useParam } from "./hooks/useParams";
-export { useSetStatus } from "./hooks/useObjectStatus";
-export { useSetProperty, useDeleteProperty } from "./hooks/useProperties";
-export { useFilters } from "./hooks/useFilters";
-export { useColumns } from "./hooks/useColumns";
-export { useViews } from "./hooks/useViews";
-export { useParams, useNavigate, useLocation, useSearchParams } from "react-router";
-export { registerScreen } from "./stores/screen-registry";
-export type { CustomScreenProps } from "./stores/screen-registry";
-export { setIconRegistry, getIcon } from "./stores/icon-registry";
-export type { IconDef } from "./stores/icon-registry";
-export { registerLayoutWidget, getLayoutWidget, hasLayoutWidget, type LayoutWidget, type LayoutWidgetProps, } from "./components/detail-layout/widgets/registry";
-export { useLanguage, useDeploymentLanguage, reresolveLanguage } from "./hooks/useLanguage";
-export { useText } from "./hooks/useText";
-export { pickLocalized, pluralText, textWithNodes, makeTextFn, MANDATORY_LANGUAGE } from "./lib/language";
-export type { TextFn, TextVars } from "./lib/language";
-export { failureTitle } from "./lib/failure";
-export { useTabStore, type TabItem, type ReturnTarget } from "./stores/tabs";
-export { useTabNavigate } from "./hooks/useTabNavigate";
-export { useScreenBack } from "./hooks/useScreenBack";
-export type { UseScreenBackOptions, ScreenBack } from "./hooks/useScreenBack";
-export { usePageState } from "./hooks/usePageState";
-export type { PageStateSetter } from "./hooks/usePageState";
-export { canonicalUrl } from "./lib/canonical-url";
-export type { CanonicalLocation } from "./lib/canonical-url";
-export { useRegisterRetainedQuery } from "./hooks/usePageStateRuntime";
-export { usePageStateTtl, PAGE_STATE_TTL_PARAM } from "./hooks/usePageStateTtl";
-export { useScreenTab } from "./hooks/useScreenTab";
-export type { UseScreenTabOptions } from "./hooks/useScreenTab";
-export { useTabSearchMirror } from "./hooks/useTabSearchMirror";
-export { useVirtualScrollRestoration, usePlainScrollRestoration, useSavedScrollOffset, SCROLL_STATE_KEY, } from "./lib/scroll-restoration";
-export type { ScrollAnchor, ScrollableVirtualizer } from "./lib/scroll-restoration";
-export { SmartListPage } from "./components/pages/SmartListPage";
-export { SmartDetailPage } from "./components/pages/SmartDetailPage";
-export { SmartRecordListPage } from "./components/pages/SmartRecordListPage";
-export { DynamicIcon } from "./components/shared/DynamicIcon";
-export { PageHeader } from "./components/chrome/PageHeader";
-export { EmptyState } from "./components/shared/EmptyState";
-export { ConfirmDialog } from "./components/shared/ConfirmDialog";
-export { FilterDrawer } from "./components/filters/FilterDrawer";
-export { FilterChips } from "./components/filters/FilterChips";
-export { ColumnPicker } from "./components/list/ColumnPicker";
-export { ViewSwitcher } from "./components/list/ViewSwitcher";
-export { ActionRunnerProvider, useActionRunner } from "./components/actions/ActionRunner";
-export type { RunActionOptions } from "./components/actions/ActionRunner";
-export { ObjectActionBar, useObjectActions } from "./components/actions/ObjectActionBar";
-export type { ObjectActionBarProps, ObjectActionBarSlot, ObjectActionSelection, UseObjectActionsResult, } from "./components/actions/ObjectActionBar";
-export { RefreshControl } from "./components/shared/RefreshControl";
-export type { RefreshControlProps } from "./components/shared/RefreshControl";
-export { RefCombobox } from "./components/fields/RefCombobox";
-export type { RefComboboxProps } from "./components/fields/RefCombobox";
-export { QuickPeek, QEField } from "./components/list/QuickPeek";
-export type { QuickPeekProps, QuickPeekFieldSpec, QEFieldProps, } from "./components/list/QuickPeek";
-export { InlineEditCell } from "./components/list/InlineEditCell";
-export type { InlineEditCellProps, InlineEditTrigger, InlineEditKind, } from "./components/list/InlineEditCell";
-export { SignIn } from "./components/pages/auth/SignIn";
-export { SignUp } from "./components/pages/auth/SignUp";
-export { Forgot } from "./components/pages/auth/Forgot";
-export { Reset } from "./components/pages/auth/Reset";
-export { TwoFA } from "./components/pages/auth/TwoFA";
-export { AuthShell } from "./components/pages/auth/AuthShell";
-export type { AuthShellProps } from "./components/pages/auth/AuthShell";
-export { Profile } from "./components/pages/profile/Profile";
-export { Preferences } from "./components/pages/profile/Preferences";
-export { ChangePasswordDialog } from "./components/shared/ChangePasswordDialog";
-export type { ChangePasswordDialogProps } from "./components/shared/ChangePasswordDialog";
-export { Icon, Btn, IconBtn, Pill, Kbd, Avatar, BrandGlyph, Dropdown, HoverCard, Tooltip, InfoTooltip, Chip, SectionCard, RecordIdBadge, RowField, BoolToggle, MenuItem, Check, Spinner, FieldLabel, TextInput, TextArea, Select, MultiSelect, DateInput, PasswordInput, TagsInput, JsonField, RefField, ViewField, QuickEditCell, } from "./components/primitives";
-export type { IconProps, IconName, BtnProps, BtnKind, BtnSize, IconBtnProps, PillProps, PillTone, PillSize, AvatarProps, BrandGlyphProps, DropdownProps, HoverCardProps, HoverCardAlign, TooltipProps, InfoTooltipProps, ChipProps, SectionCardProps, SectionBadge, SectionEmphasis, RecordIdBadgeProps, RowFieldProps, BoolToggleProps, MenuItemProps, CheckProps, FieldLabelProps, TextInputProps, TextAreaProps, SelectProps, MultiSelectProps, SelectOption, DateInputProps, PasswordInputProps, TagsInputProps, JsonFieldProps, RefFieldProps, RefFieldItem, ViewFieldProps, QuickEditCellProps, } from "./components/primitives";
-export { SquareImage, CircleImage, WideBanner, registerFileWidget, getFileWidget, hasFileWidget, uploadFile, discardFile, validateClientSide, formatBytes, UploadError, setImageCropper, getImageCropper, FileDraftScope, useFileDraftScope, useDraftRegistration, } from "./components/file-widgets";
-export type { FileFieldDef, FileFieldDisplay, FileFieldMode, FileWidget, FileWidgetProps, HydratedFile, UploadProgress, UploadedFile, ImageCropper, CropperOptions, CropperResult, FileDraftScopeApi, DraftEntry, } from "./components/file-widgets";
-export type { UploadCheck } from "./components/file-widgets/upload";
-export { Rail } from "./components/layout/Rail";
-export type { RailProps, RailAreaItem } from "./components/layout/Rail";
-export { Sidebar, buildSections } from "./components/layout/Sidebar";
-export type { SidebarProps } from "./components/layout/Sidebar";
-export { TopBar } from "./components/layout/TopBar";
-export type { TopBarProps } from "./components/layout/TopBar";
-export { TenantChip, envTone } from "./components/layout/TenantChip";
-export type { TenantChipProps } from "./components/layout/TenantChip";
-export { TabStrip } from "./components/layout/TabStrip";
-export type { TabStripProps } from "./components/layout/TabStrip";
-export { ImpersonationBanner } from "./components/layout/ImpersonationBanner";
-export { ImpersonationFrame } from "./components/layout/ImpersonationFrame";
-export { ImpersonationStartModal } from "./components/layout/ImpersonationStartModal";
-export { useImpersonation } from "./hooks/useImpersonation";
-export { CommandPalette } from "./components/layout/CommandPalette";
-export type { CommandPaletteProps, CommandAction, CommandActionType, } from "./components/layout/CommandPalette";
-export { AgentChatPanel } from "./components/agents/AgentChatPanel";
-export type { AgentChatPanelProps } from "./components/agents/AgentChatPanel";
-export { AgentElicitForm } from "./components/agents/AgentElicitForm";
-export type { AgentElicitFormProps } from "./components/agents/AgentElicitForm";
-export { AgentPicker } from "./components/agents/AgentPicker";
-export type { AgentPickerProps } from "./components/agents/AgentPicker";
-export { AgentConversationDrawer } from "./components/agents/AgentConversationDrawer";
-export type { AgentConversationDrawerProps } from "./components/agents/AgentConversationDrawer";
-export { useAgentConversation } from "./hooks/useAgentConversation";
-export type { AgentTurnState } from "./hooks/useAgentConversation";
-export { listAvailableAgents, createConversation, sendMessage, answerQuestion, sendElicitResponse, approveInvocation, rejectInvocation, cancelInvocation, cancelConversation, listConversations, loadConversationTurns, loadConversationInvocations, loadHistory, } from "./api/agents";
-export type { AgentRole, AgentContentBlock, AgentMessage, AgentTurnStatus, AgentTurn, AgentInvocationStatus, AgentInvocationKind, AgentToolInvocation, AgentConversationStatus, AgentConversation, AvailableAgent, ApprovalScope, } from "./api/agents";
-export { Breadcrumbs } from "./components/chrome/Breadcrumbs";
-export type { BreadcrumbsProps, Crumb } from "./components/chrome/Breadcrumbs";
-export type { FilterNode, FilterOp } from "./lib/filters";
-export type { FilterURLState } from "./lib/filters";
-export type { FilterRecord, FilterRecordField, FilterRecordFields } from "./lib/filter-evaluator";
-export { parseFiltersFromURL, parseFilterURLState, setFiltersInURL, hasOrGroups, countActiveFilters, OP_LABELS, NO_VALUE_OPS, } from "./lib/filters";
-export { evaluateFilterTree } from "./lib/filter-evaluator";
-export { resolveEntityVariantCode } from "./lib/variants";
-export { variantActionCodesForRecord, commonVariantActionCodes } from "./lib/variants";
-export { resolveScreenVariantCode, effectiveScreenForRecord } from "./lib/variants";
-export { formatCount, formatExactCount, formatEstimatedCount } from "./lib/format-count";
-export type { MassEditTarget, MassEditTargetKind } from "./lib/mass-edit";
-export { buildMassEditTargets, parseTargetFilter } from "./lib/mass-edit";
-export { PropertyGridEditor, detectCommonValue, MULTIPLE_VALUES } from "./components/actions/PropertyGridEditor";
-export type { PatchMap } from "./components/actions/PropertyGridEditor";
-export { ClassifiedFieldLocked, } from "./components/primitives";
-export { isFieldReadable, isFieldWritable, fieldClassification, fieldRequiredPermission, classificationTier, isFieldSoDProtected, fieldAccessInfo, } from "./lib/field-classification";
-export type { ClassificationTierDef, FieldAccessInfo } from "./types/schema";
+import { i as DynamicIcon, n as IconName, r as IconProps, t as Icon } from "./Icons-Dzl-AkD_.js";
+import { i as setIconRegistry, n as getIcon, t as IconDef } from "./icon-registry-CUT4eF63.js";
+import { $ as EntityField, A as ListParams, At as pickLocalized, B as TenantEnv, Bt as hasOrGroups, C as CURSOR_LANGUAGE_CHANGED, Ct as pkValuesToDetailId, D as EnrichedRow, Dt as TextFn, E as DataResponse, Et as MANDATORY_LANGUAGE, F as PublicParam, Ft as FilterURLState, G as V2PropertyInstance, Gt as FileFieldDisplay, H as V2ListResponse, Ht as parseFiltersFromURL, I as PublicParamsResponse, It as FilterValueResolver, J as Action, Jt as HydratedFile, K as V2StatusInstance, Kt as FileFieldMode, L as Refs, Lt as NO_VALUE_OPS, M as LoginResponse, Mt as textWithNodes, N as ParamLookup, Nt as FilterNode, O as ImpersonationInfo, Ot as TextVars, P as PropertyValue, Pt as FilterOp, Q as Entity, R as StatusInfo, Rt as OP_LABELS, S as BrandingIdentity, St as pkValuesFromId, T as CheckSetupResponse, Tt as resolveDetailRoute, U as V2Meta, Ut as setFiltersInURL, V as V2ListParams, Vt as parseFilterURLState, W as V2ParamInstance, Wt as FileFieldDef, X as ChildRelation, Xt as UploadedFile, Y as AreaDef, Yt as UploadProgress, Z as ClassificationTierDef, Zt as OrderedMap, _ as executeAction$1, _t as buildRowDetailHref, a as ResponsiveMode, at as NavNode, b as ApiErrorBody, bt as getPrimaryKeyFields, c as resolveViewportCategory, ct as PropertyDef, d as ActionExecuteResponse, dt as Screen, et as EnumDef, f as ActionItemError, ft as StatusDef, g as deleteObject, gt as buildEntityDetailHref, h as buildActionBody, ht as buildDetailHrefFromId, i as ResponsiveBreakpoints, it as LocalizedString, j as ListResponse, jt as pluralText, k as ListMeta, kt as makeTextFn, l as ActionBatchError, lt as RefConfig, m as GetEntityOptions, mt as StructureDef, n as useResponsiveMode, nt as FilterSpecialValue, o as ResponsiveViewport, ot as ParameterDef, p as ActionItemSkip, pt as StatusGroupDef, q as isCursorStaleError, qt as FileFieldValue, r as DEFAULT_RESPONSIVE_BREAKPOINTS, rt as LanguageDef, s as ViewportCategory, st as PkValues, t as ResponsiveModeProvider, tt as FieldAccessInfo, u as ActionExecuteRequest, ut as Schema, v as restoreObject, vt as extractPkValues, w as CURSOR_SEMANTICS_MISMATCH, wt as pkValuesToId, x as AuthUser, xt as pkValuePartsToId, y as ApiError, yt as fieldDisplayName, z as Tenant, zt as countActiveFilters } from "./useResponsiveMode-DIR1bZfo.js";
+import { ButtonHTMLAttributes, CSSProperties, ComponentType, InputHTMLAttributes, MouseEvent, ReactNode, RefObject } from "react";
+import { QueryClient, QueryKey, UseQueryResult } from "@tanstack/react-query";
+import { useLocation, useNavigate, useParams, useSearchParams } from "react-router";
+//#region src/app.d.ts
+export declare function App(): import("react").JSX.Element;
+//#endregion
+//#region src/lib/display-value.d.ts
+export declare function coerceDisplayString(value: unknown): string;
+//#endregion
+//#region src/lib/timestamp.d.ts
+/**
+ * Format an offset-aware timestamp for display WITHOUT browser-local
+ * conversion.
+ *
+ * `DD-MM-YYYY HH:mm`, the same in every language. Deliberately NOT
+ * `dateStyle: "medium"`: that renders "Aug 15, 2026" for one reader and
+ * "15 авг. 2026 г." for another, so two people reading the same screen cannot
+ * quote the same date to each other.
+ */
+export declare function formatOffsetTimestamp(raw: string): string;
+//#endregion
+//#region src/api/entities.d.ts
+/** Helper methods injected onto enriched rows. */
+interface RowHelpers {
+  $status(groupCode: string): V2StatusInstance | undefined;
+  $property(propertyCode: string): V2PropertyInstance | undefined;
+}
+/** Normalized ref cache that merges $refs across multiple responses. */
+export declare class RefCache {
+  private cache;
+  /** Merge incoming refs into the cache. */
+  merge(refs: Refs | undefined): void;
+  /** Get a snapshot of all cached refs. */
+  all(): Refs;
+  /** Look up a single ref by entity code and id. */
+  get(entityCode: string, id: string): Record<string, unknown> | undefined;
+  /** Clear the cache. */
+  clear(): void;
+}
+/**
+ * Generic, type-safe client for a single entity's v2 API.
+ *
+ * Single-item methods wrap arrays and unwrap the first result.
+ * Bulk methods pass arrays through directly.
+ *
+ * All write responses return enriched rows with $refs, $statuses, etc.
+ */
+export declare class EntityClient<T extends Record<string, unknown> = Record<string, unknown>> {
+  readonly entity: string;
+  readonly refs: RefCache;
+  constructor(entity: string, refCache?: RefCache);
+  /** Get a single record through the query-PK detail contract.
+   *
+   * Pass a string to address by the `id` field (the common single-`id`-PK case,
+   * unchanged). Pass a PkValues object to address an entity whose primary key is
+   * a different single field (e.g. `{ code: "files.gc_sweep" }` for `schedule`)
+   * or a composite key (`{ region: "eu", code: "r1" }`) - each field becomes its
+   * own query param, which is how the detail contract resolves a row. A bare
+   * string with a non-`id` PK would send `?id=...` and 400. */
+  get(pk: string | Record<string, string>): Promise<T & EnrichedRow & RowHelpers>;
+  /** List records with cursor-based pagination, field selection, and expansion.
+   *
+   * Recovery on cursor-stale signals: when the server returns
+   * `cursor.semantics_mismatch` (sort grammar version bump),
+   * `cursor.language_changed` (the reader's language switched mid-pagination), or
+   * `cursor.archive_invalid` (an undecodable cross-store archive cursor), the
+   * `after` token is dropped and the request is retried once from the top.
+   *
+   * CRITICAL for accumulating callers (infinite scroll): the returned
+   * `reset` flag is `true` when this recovery fired. The refetched data is
+   * WINDOW 1, not the next page - an accumulating `useInfiniteQuery` MUST
+   * discard its prior pages and start from this one, never append it as the
+   * next page (which would duplicate the head and drop the middle). Callers
+   * that fetch a single window can ignore `reset`. See Decisions Log #14.
+   */
+  list(params?: V2ListParams): Promise<{
+    data: (T & RowHelpers)[];
+    meta: V2Meta;
+    $refs: Refs;
+    reset: boolean;
+  }>;
+  /** Create a single record. Wraps in array, returns unwrapped result. */
+  create(item: Partial<T> & Record<string, unknown>): Promise<T & EnrichedRow & RowHelpers>;
+  /**
+   * Create multiple records in one transactional batch.
+   *
+   * `data.create` is one row per dispatch; N independent
+   * inserts compose through the platform batch primitive (`system.batch`,
+   * atomic READ COMMITTED tx). Each child op targets `<entity>.__create`
+   * with a FLAT `{entity, fields}` body inside `BatchOp.params`.
+   *
+   * Returns rows in input order. The batch fails atomically: any per-op
+   * error surfaces as a thrown Error with the first failing op's code +
+   * message; `committed: false` (4xx/200-soft-fail) means no row was
+   * written. The HTTP transport itself failing (5xx, network) keeps
+   * propagating as ApiError unchanged.
+   */
+  createMany(items: (Partial<T> & Record<string, unknown>)[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
+  /** Update a single record. Wraps in array, returns unwrapped result. */
+  update(id: string, data: Partial<T> & Record<string, unknown>): Promise<T & EnrichedRow & RowHelpers>;
+  /**
+   * Update multiple records in one request. Each item must include its id.
+   *
+   * `data.update` is one fields map per dispatch
+   * ({object_ids, entity, fields}); per-row variation composes through
+   * `system.batch` (atomic READ COMMITTED tx) — one __update child op per
+   * input item, mirroring createMany / upsertMany. The batch is atomic:
+   * any per-op failure rolls back all rows. The first per-op error
+   * surfaces as a thrown Error.
+   *
+   * Returns rows in input order.
+   */
+  updateMany(items: (Partial<T> & Record<string, unknown> & {
+    id: string;
+  })[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
+  /** Delete a single record by ID. */
+  delete(id: string): Promise<void>;
+  /**
+   * Delete multiple records in one request. Returns the count of deleted
+   * records.
+   *
+   * Dispatches /api/actions/<entity>.__delete with a FLAT envelope
+   * ({object_ids, entity}); the server derives the rows from `object_ids`
+   * and the entity's PK fields.
+   */
+  deleteMany(ids: string[]): Promise<{
+    count: number;
+  }>;
+  /** Restore a single soft-deleted record by ID. */
+  restore(id: string): Promise<void>;
+  /**
+   * Restore multiple soft-deleted records. Returns the count of restored
+   * records.
+   *
+   * Routes through the platform-default `__restore` action. The legacy CRUD route
+   * POST /api/data/{entity}/restore is retired (returns 410). The FLAT
+   * envelope ({object_ids, entity}) lands directly in DataRestoreParams
+   * via JSON tags; no `params:` wrapper on the wire.
+   */
+  restoreMany(ids: string[]): Promise<{
+    count: number;
+  }>;
+  /** Upsert a single record. Wraps in array, returns unwrapped result. */
+  upsert(item: Partial<T> & Record<string, unknown>, uniqueFields: string[]): Promise<T & EnrichedRow & RowHelpers>;
+  /**
+   * Upsert multiple records. Existing matches (by uniqueFields) are
+   * updated; absent rows are inserted.
+   *
+   * `data.upsert` is one row per dispatch (per-row uniqueness matching), so N
+   * rows compose through `system.batch`. Each child op targets
+   * `<entity>.__upsert` with FLAT `{entity, fields, unique_by}` params.
+   * The handler returns `DataUpsertResult.rows[]` where each
+   * DataUpsertRowResult carries `{pk, action, row}`; the row payload is
+   * extracted to preserve the prior API shape (array of enriched rows).
+   *
+   * The batch is atomic: any per-op failure rolls back all rows. The
+   * first per-op error surfaces as a thrown Error.
+   */
+  upsertMany(items: (Partial<T> & Record<string, unknown>)[], uniqueFields: string[]): Promise<(T & EnrichedRow & RowHelpers)[]>;
+}
+/**
+ * Create an EntityClient for the given entity code.
+ * Optionally share a RefCache across multiple clients.
+ *
+ * NOTE(T5): Each call creates a new EntityClient (and a new RefCache if none is
+ * provided). For cross-page ref accumulation, callers should create a persistent
+ * RefCache instance and pass it to every entityClient() call, e.g. via React
+ * context or a module-level singleton.
+ */
+export declare function entityClient<T extends Record<string, unknown> = Record<string, unknown>>(entity: string, refCache?: RefCache): EntityClient<T>;
+//#endregion
+//#region src/api/batch.d.ts
+interface BatchOp {
+  action: string;
+  params?: Record<string, unknown> | null;
+}
+interface BatchOpResult {
+  index: number;
+  /** The dispatched action, so an entry says WHICH op it describes. */
+  action?: string;
+  ok: boolean;
+  result?: unknown;
+  /** The failure, in the one shape every carrier sends. */
+  error?: ApiErrorBody;
+}
+interface BatchResponse {
+  results: BatchOpResult[];
+  committed: boolean;
+}
+export declare class Batch {
+  private ops;
+  call(action: string, params?: unknown): this;
+  upsert(entity: string, records: Array<Record<string, unknown>>, mode?: "upsert" | "insert_if_missing", uniqueBy?: string[]): this;
+  execute(): Promise<BatchResponse>;
+  _ops(): readonly BatchOp[];
+}
+//#endregion
+//#region src/hooks/useSchema.d.ts
+export declare function useSchema(): import("@tanstack/react-query").UseQueryResult<Schema, Error>;
+//#endregion
+//#region src/hooks/useEntity.d.ts
+export declare function useEntity(entityCode: string | undefined): Entity | undefined;
+//#endregion
+//#region src/hooks/useScreen.d.ts
+export declare function useScreen(screenCode: string | undefined): Screen | undefined;
+//#endregion
+//#region src/hooks/useCurrentScreen.d.ts
+/**
+ * The screen a component is currently rendering inside.
+ *
+ * Standard pages have always been told which screen they are (`SmartListPage`,
+ * `SmartDetailPage` and `SmartRecordListPage` all take `screenCode`). A CUSTOM screen
+ * was told nothing - it was mounted as a bare `<Component />` - so it could not read
+ * its own declaration and had no choice but to hardcode what the schema already said.
+ * That is why a screen renamed or translated in YAML kept an English literal in its
+ * header while the sidebar followed the schema.
+ *
+ * This context closes that gap: every routed screen, custom included, is rendered
+ * inside it, so any component in the tree can ask what it is looking at without prop
+ * drilling. `PageHeader` uses it to default its title and description - which is what
+ * makes `<PageHeader />` with no props the correct, complete header for a custom screen.
+ */
+interface CurrentScreen {
+  /** The screen's code in the schema (e.g. `events_compare`). */
+  code: string;
+  /** Its full declaration, or undefined if the schema has not loaded yet. */
+  screen: Screen | undefined;
+}
+export declare function CurrentScreenProvider({ code, children }: {
+  code: string;
+  children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The screen this component is rendering inside, or undefined outside a routed screen.
+ *
+ * Use it to read anything the schema already declares - the localized name, the
+ * description, the entity, the route - instead of restating it in the component.
+ */
+export declare function useCurrentScreen(): CurrentScreen | undefined;
+//#endregion
+//#region src/hooks/useAuth.d.ts
+export declare function useAuth(): {
+  user: AuthUser | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  activeTenant: Tenant | null;
+  tenants: Tenant[];
+  login: import("@tanstack/react-query").UseMutateFunction<LoginResponse, Error, {
+    email: string;
+    password: string;
+    remember?: boolean;
+  }, unknown>;
+  signup: import("@tanstack/react-query").UseMutateFunction<LoginResponse, Error, {
+    email: string;
+    password: string;
+    displayName: string;
+  }, unknown>;
+  switchTenant: import("@tanstack/react-query").UseMutateFunction<LoginResponse, Error, string, unknown>;
+  logout: () => Promise<void>;
+  isLoginPending: boolean;
+  isSignupPending: boolean;
+  isSwitchingTenant: boolean;
+};
+//#endregion
+//#region src/hooks/useEntityData.d.ts
+/**
+ * The React Query key for an entity list-window read. The single source of
+ * truth for both `useEntityData` and a screen registering its PRIMARY read with
+ * its retained page (`useRegisterRetainedQuery`), so the registered key matches
+ * the live query exactly. See hooks/usePageStateRuntime.ts.
+ */
+export declare function entityDataQueryKey(entity: string | undefined, params: ListParams): QueryKey;
+/**
+ * useEntityData fetches one page-window of entity rows.
+ *
+ * Decoupled-count contract:
+ * this hook issues the WINDOW request only - `count: "window"`, so the
+ * server returns the page of rows and never blocks on a COUNT(*). The total
+ * is fetched separately by `useEntityCount`; the table renders rows the
+ * moment this query resolves, independent of count latency.
+ */
+export declare function useEntityData(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;
+/**
+ * useEntityCount fetches the total row count for a list view in a SEPARATE
+ * request from the window (`count: "only"` - the server skips the data
+ * query entirely and returns just `meta.total` + `meta.count_mode`).
+ *
+ * The count is page-independent: `page` and `sort` are stripped from the
+ * params so a page change or a re-sort does not refetch the count - only a
+ * filter / search / screen / include_deleted change invalidates it.
+ *
+ * The server picks exact vs estimated per the entity's declared `count`
+ * strategy; the resolved `meta.count_mode` tells the caller which precision
+ * to render. A count failure does NOT break the table: callers treat a
+ * failed/absent count as "unknown" and fall back to the loaded row count.
+ */
+export declare function useEntityCount(entity: string | undefined, params: ListParams, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;
+//#endregion
+//#region src/hooks/useCursorEntityData.d.ts
+/**
+ * The stable JSON segment of the cursor list's query key (the view-defining
+ * params, order-independent). Extracted so both the hook and the key builder
+ * compute it identically.
+ */
+export declare function cursorEntityStableKey(params: CursorEntityDataParams): string;
+/**
+ * The React Query key for the cursor (infinite) entity list. Single source of
+ * truth for both `useCursorEntityData` and a screen registering its PRIMARY
+ * cursor read with its retained page (`useRegisterRetainedQuery`).
+ */
+export declare function cursorEntityDataQueryKey(entity: string | undefined, params: CursorEntityDataParams): QueryKey;
+interface CursorEntityDataParams {
+  sort?: string;
+  filters?: FilterNode[];
+  search?: string;
+  select?: string[];
+  expand?: string[];
+  includeDeleted?: boolean;
+  screen?: string;
+  preview?: boolean;
+  limit: number;
+}
+/**
+ * useCursorEntityData drives the cursor-native admin list for an archive entity
+ * whose `list_pagination` is `cursor` (Postgres-hot + ClickHouse-cold). It
+ * accumulates windows with `useInfiniteQuery` over `EntityClient.list` (so the
+ * stale-cursor `reset` signal is available), requests the estimated count on
+ * the FIRST window only, and resets to window 1 when a stale cursor is hit
+ * mid-scroll. Realtime resets are driven centrally by the SSE handler via
+ * resetQueries on CURSOR_ENTITY_DATA_KEY.
+ *
+ * `enabled` gates the query so a NON-cursor entity (offset mode) pays nothing -
+ * the page calls both this and useEntityData and enables exactly one.
+ */
+export declare function useCursorEntityData(entity: string | undefined, params: CursorEntityDataParams, enabled: boolean): {
+  rows: (Record<string, unknown> & RowHelpers)[];
+  refs: Refs | undefined;
+  total: number | undefined;
+  countMode: string | undefined;
+  countUnknown: boolean;
+  hasMore: boolean;
+  fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+    data: (Record<string, unknown> & RowHelpers)[];
+    meta: V2Meta;
+    $refs: Refs;
+    reset: boolean;
+  }, unknown>, Error>>;
+  isFetchingNextPage: boolean;
+  isLoading: boolean;
+  isFetching: boolean;
+  isPlaceholderData: boolean;
+  isError: boolean;
+  error: Error | null;
+  refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+    data: (Record<string, unknown> & RowHelpers)[];
+    meta: V2Meta;
+    $refs: Refs;
+    reset: boolean;
+  }, unknown>, Error>>;
+};
+/**
+ * CursorEntityDataResult is the public return contract of useCursorEntityData -
+ * the digested infinite-list shape (accumulated `rows`, `hasMore` +
+ * `fetchNextPage` for scroll, the first-window `total`/`countUnknown`, and the
+ * react-query status flags). Named (not inferred) so SDK consumers have a stable
+ * type to annotate against. Derived from the hook so it never drifts.
+ */
+type CursorEntityDataResult = ReturnType<typeof useCursorEntityData>;
+//#endregion
+//#region src/hooks/useAllEntityData.d.ts
+/**
+ * Fetches every page of an entity list and concatenates the result into a
+ * single ListResponse whose `meta.total` is the true row count.
+ *
+ * For board / kanban screens that group the entire result set client-side
+ * and therefore cannot use one server-capped page. It fetches page 1 to
+ * learn `total_pages`, then fetches the remaining pages in parallel and
+ * merges their `$refs`.
+ *
+ * Prefer `useEntityData` for paginated list screens. This hook holds the
+ * full result set in memory and is only appropriate for bounded entities.
+ * The caller's `page` / `per_page` in `params` are ignored - this hook owns
+ * pagination - while `filters`, `search`, `sort`, and `expand` are honored.
+ */
+export declare function useAllEntityData(entity: string | undefined, params?: ListParams): import("@tanstack/react-query").UseQueryResult<ListResponse<Record<string, unknown>>, Error>;
+//#endregion
+//#region src/hooks/useObject.d.ts
+/**
+ * The React Query key for a single-record read. Single source of truth for both
+ * `useObject` and a detail screen registering its PRIMARY read with its
+ * retained page (`useRegisterRetainedQuery`). For a string PK uses it directly;
+ * for a composite PK sorts the parts so key order does not fork the cache.
+ */
+export declare function objectQueryKey(entity: string | undefined, pkValues: PkValues | string | undefined, options?: GetEntityOptions): QueryKey;
+export declare function useObject(entity: string | undefined, pkValues: PkValues | string | undefined, options?: GetEntityOptions): import("@tanstack/react-query").UseQueryResult<DataResponse<Record<string, unknown>>, Error>;
+//#endregion
+//#region src/hooks/useFileReferenceJSON.d.ts
+export declare function fileReferenceJSONQueryKey(entityCode: string | undefined, pkValues: PkValues | string | undefined, fieldCode: string | undefined, reference: string | null | undefined): QueryKey;
+export declare function useFileReferenceJSON(entityCode: string | undefined, pkValues: PkValues | string | undefined, fieldCode: string | undefined, reference: string | null | undefined): import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+//#endregion
+//#region src/components/fields/index.d.ts
+interface FieldRendererProps {
+  field: EntityField;
+  entityCode?: string;
+  fieldName: string;
+  value: unknown;
+  mode: "display" | "edit";
+  onChange?: (value: unknown) => void;
+  fieldId?: string;
+  labelId?: string;
+  record?: Record<string, unknown>;
+  refs?: Refs;
+  fill?: boolean;
+  compact?: boolean;
+  surface?: "list" | "detail";
+  entity?: Entity;
+  entities?: Record<string, Entity>;
+  screens?: Record<string, Screen>;
+  t: TextFn;
+  detailScreen?: string;
+}
+//#endregion
+//#region src/components/fields/StructureField.d.ts
+export declare function StructureField(props: FieldRendererProps & {
+  nested?: boolean;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/hooks/useLiveObject.d.ts
+type LiveObjectResult<T extends Record<string, unknown> = EnrichedRow> = UseQueryResult<DataResponse<T>, Error> & {
+  object: T | undefined;
+  isLive: boolean;
+  isNotFound: boolean;
+};
+export declare function useLiveObject<T extends Record<string, unknown> = EnrichedRow>(entity: string | undefined, pkValues: PkValues | string | undefined): LiveObjectResult<T>;
+//#endregion
+//#region src/hooks/useActionData.d.ts
+/** The canonical list-page envelope a paginated action returns in its `result` -
+ *  the same shape `data.list` (ListResponse) produces. */
+interface ActionListPage<T> {
+  data: T[];
+  meta?: {
+    cursor?: string;
+    has_more?: boolean;
+  };
+}
+/** Query-key root for a one-shot action read. Mirrors the entity root
+ *  `entity-data`. */
+export declare const ACTION_DATA_KEY = "action-data";
+/** Query-key root for a cursor (infinite) action read. Mirrors the entity cursor
+ *  root `entity-data-cursor`; distinct from the one-shot read so it is
+ *  reaped/registered independently. */
+export declare const ACTION_DATA_CURSOR_KEY = "action-data-cursor";
+/**
+ * The React Query key for a one-shot action read. Single source of truth for
+ * both `useActionData` and a screen registering it as its PRIMARY read with its
+ * retained page (`useRegisterRetainedQuery`). `params` is embedded directly;
+ * React Query hashes it stably (sorted keys).
+ */
+export declare function actionDataQueryKey(actionCode: string | undefined, params: Record<string, unknown>): QueryKey;
+/**
+ * Read an arbitrary action ONCE and cache its `result` - the action mirror of
+ * `useEntityData`. `T` is whatever the action returns (a summary object, or a
+ * plain array that is not cursor-paginated). Returns the raw React Query result;
+ * the caller registers the key via `actionDataQueryKey` +
+ * `useRegisterRetainedQuery` for retention.
+ */
+export declare function useActionData<T>(actionCode: string | undefined, params: Record<string, unknown>, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<T, Error>;
+/**
+ * The React Query key for a cursor (infinite) action read. Single source of
+ * truth for both `useCursorActionData` and its retained-page registration. The
+ * key excludes the cursor (the cursor is the page param, not part of identity).
+ */
+export declare function cursorActionDataQueryKey(actionCode: string | undefined, params: Record<string, unknown>): QueryKey;
+/** The accumulated, table-ready result of a cursor action read - mirrors the
+ *  shape `useCursorEntityData` feeds a list. */
+interface CursorActionDataResult<T> {
+  rows: T[];
+  hasMore: boolean;
+  fetchNextPage: () => void;
+  isFetchingNextPage: boolean;
+  isLoading: boolean;
+  isError: boolean;
+  error: Error | null;
+  refetch: () => void;
+  queryKey: QueryKey;
+}
+/**
+ * Drive a cursor-paginated table from an action that returns an `ActionListPage`
+ * in its `result`. The mirror of `useCursorEntityData`, differing only in the
+ * source (an action via `executeAction`, not `EntityClient.list`): it
+ * accumulates windows with `useInfiniteQuery`, advancing `meta.cursor` while
+ * `meta.has_more`, and exposes the flattened rows. Register the returned
+ * `queryKey` with `useRegisterRetainedQuery` so the pages survive a tab switch /
+ * Back within the retention window and die with the retained page.
+ */
+export declare function useCursorActionData<T>(actionCode: string | undefined, params: Record<string, unknown>, enabled?: boolean): CursorActionDataResult<T>;
+//#endregion
+//#region src/hooks/useMutations.d.ts
+export declare function useCreateObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<DataResponse<Record<string, unknown>>, Error, Record<string, unknown>, unknown>;
+export declare function useUpdateObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<DataResponse<Record<string, unknown>>, Error, {
+  pkValues: PkValues | string;
+  data: Record<string, unknown>;
+}, unknown>;
+export declare function useDeleteObject(entityCode: string): import("@tanstack/react-query").UseMutationResult<void, Error, string | PkValues, unknown>;
+//#endregion
+//#region src/hooks/useDebounce.d.ts
+export declare function useDebounce<T>(value: T, delay: number): T;
+//#endregion
+//#region src/hooks/useParams.d.ts
+export declare function usePublicParams(): import("@tanstack/react-query").UseQueryResult<PublicParamsResponse, Error>;
+export declare function useResolvedParam(code: string, options?: {
+  enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<ParamLookup, Error>;
+export declare function useEffectiveParam<T = unknown>(code: string): {
+  value: T | undefined;
+  found: boolean;
+  source: ParamLookup["source"] | "public" | undefined;
+  loading: boolean;
+  error: Error | null;
+};
+/** A failed read returns the default AND `error`; a gate on anything sensitive checks `error`. */
+export declare function useParam<T>(code: string, defaultValue: T): {
+  value: T;
+  found: boolean;
+  source: ParamLookup["source"] | undefined;
+  loading: boolean;
+  error: Error | null;
+};
+//#endregion
+//#region src/hooks/useObjectStatus.d.ts
+export declare function useSetStatus(entity: string | undefined, id: string | undefined): import("@tanstack/react-query").UseMutationResult<StatusInfo, Error, {
+  groupCode: string;
+  statusCode: string;
+  note?: string;
+}, unknown>;
+//#endregion
+//#region src/hooks/useProperties.d.ts
+export declare function useSetProperty(entity: string | undefined, id: string | undefined): import("@tanstack/react-query").UseMutationResult<PropertyValue, Error, {
+  propertyCode: string;
+  value: unknown;
+}, unknown>;
+export declare function useDeleteProperty(entity: string | undefined, id: string | undefined): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+//#endregion
+//#region src/hooks/useFilters.d.ts
+interface FiltersInput {
+  defaults?: FilterNode[];
+}
+/** `filters=[]` and an absent parameter are different states: the first says
+ *  the caller removed every condition, the second says `defaults` apply. */
+export declare function useFilters({ defaults }?: FiltersInput): {
+  filters: FilterNode[];
+  filterError: string | null;
+  activeCount: number;
+  setFilters: (newFilters: FilterNode[]) => void;
+  clearFilters: () => void;
+};
+//#endregion
+//#region src/hooks/useColumns.d.ts
+/**
+ * useColumns manages visible columns via URL `columns` param.
+ * Falls back to screen defaults when no URL param is set.
+ */
+export declare function useColumns(availableColumns: string[], defaultColumns: string[]): {
+  visibleColumns: string[];
+  availableColumns: string[];
+  setColumns: (cols: string[]) => void;
+  resetToDefaults: () => void;
+  showAll: () => void;
+  isColumnVisible: (col: string) => boolean;
+  toggleColumn: (col: string) => void;
+};
+//#endregion
+//#region src/components/list/ViewSwitcher.d.ts
+interface ViewItem {
+  id: string;
+  name: Record<string, string>;
+  icon?: string;
+  source: "system" | "personal" | "shared";
+  is_default?: boolean;
+  filters?: FilterNode[];
+  columns?: string[];
+  sort?: string;
+}
+interface ViewSwitcherProps {
+  views: ViewItem[];
+  activeViewId: string | null;
+  isDirty: boolean;
+  onSelect: (view: ViewItem) => void;
+  onSave?: () => void;
+  onSaveAs?: () => void;
+  onDiscard?: () => void;
+  onDelete?: (view: ViewItem) => void;
+  deletePending?: boolean;
+}
+export declare function ViewSwitcher({ views, activeViewId, isDirty, onSelect, onSave, onSaveAs, onDiscard, onDelete, deletePending }: ViewSwitcherProps): import("react").JSX.Element;
+//#endregion
+//#region src/hooks/useViews.d.ts
+/**
+ * useViews fetches DB views for a screen and merges with system views (presets) from DSL.
+ * Returns a unified list with source tagging.
+ */
+export declare function useViews(screenCode: string, userId?: string): ViewItem[];
+//#endregion
+//#region src/stores/screen-registry.d.ts
+/**
+ * What the platform hands a custom screen when it mounts it.
+ *
+ * `screenCode` is the same handle every standard page already receives, so a custom
+ * screen can read its own declaration (name, description, entity, route) instead of
+ * restating it in code. Prefer the `useCurrentScreen()` hook - it reaches any component
+ * in the tree, not just the top one - and take this prop only when the top-level
+ * component itself needs the code.
+ *
+ * It is optional: a screen registered before this existed keeps compiling and running.
+ */
+interface CustomScreenProps {
+  screenCode?: string;
+}
+export declare function registerScreen(code: string, component: ComponentType<CustomScreenProps>): void;
+//#endregion
+//#region src/components/detail-layout/LayoutRenderer.d.ts
+interface PendingChildRow {
+  _key: string;
+  _deleted?: boolean;
+  _dirty?: boolean;
+  [field: string]: unknown;
+}
+interface LayoutContext {
+  schema: Schema;
+  entity: Entity;
+  entityCode: string;
+  recordId: string;
+  record: Record<string, unknown>;
+  isNew: boolean;
+  mode: "display" | "edit";
+  onFieldChange?: (field: string, value: unknown) => void;
+  refs?: Refs;
+  columns?: number;
+  hideEmptyFields?: boolean;
+  objectProperties?: PropertyValue[];
+  onSetProperty?: (propertyCode: string, value: unknown) => void;
+  isPropertyPending?: boolean;
+  objectStatuses?: StatusInfo[];
+  onSetStatus?: (groupCode: string, statusCode: string) => void;
+  isStatusPending?: boolean;
+  pendingChildren?: Record<string, PendingChildRow[]>;
+  onChildrenChange?: (childCode: string, rows: PendingChildRow[]) => void;
+  childValidationErrors?: Record<string, Record<string, string[]>>;
+  fieldErrors?: Record<string, string>;
+  withinCard?: boolean;
+  detailTabsPresentation?: "sections" | "scroll";
+  relatedRecordsPresentation?: "cards" | "table";
+}
+//#endregion
+//#region src/components/detail-layout/widgets/registry.d.ts
+interface LayoutWidgetProps {
+  inputs: Record<string, string>;
+  values: Record<string, unknown>;
+  record: Record<string, unknown>;
+  options?: Record<string, unknown>;
+  ctx: LayoutContext;
+}
+type LayoutWidget = (props: LayoutWidgetProps) => ReactNode;
+export declare function registerLayoutWidget(code: string, widget: LayoutWidget): void;
+export declare function getLayoutWidget(code: string): LayoutWidget | undefined;
+export declare function hasLayoutWidget(code: string): boolean;
+//#endregion
+//#region src/hooks/useLanguage.d.ts
+export declare function useLanguage(): string;
+export declare function useDeploymentLanguage(): string;
+export declare function reresolveLanguage(queryClient: QueryClient): Promise<void>;
+//#endregion
+//#region src/hooks/useText.d.ts
+export declare function useText(catalog?: "messages" | "errors"): TextFn;
+//#endregion
+//#region src/lib/failure.d.ts
+export declare function failureTitle(errorTitle: TextFn, err: unknown): string;
+//#endregion
+//#region src/stores/tabs.d.ts
+type TabMode = "view" | "edit" | "create";
+type TabCloseScope = "current" | "others" | "right" | "all";
+/**
+ * Origin-aware Back return target. The CANONICAL stored shape: `pathname` is an
+ * in-app path (no origin, starts `/` not `//`), `search` is the query string
+ * WITHOUT a leading `?` (matches `TabItem.search`), `hash` carries its leading
+ * `#`. Converted to the `?`-prefixed router form only at the navigate boundary.
+ *
+ * `hash` lives here but NOT on `TabItem` (which has no `hash` field): a closed
+ * origin tab with a hash is reopened via pathname+search, and the hash is
+ * applied only in the `navigate()` call. `tabId`/`title`/`icon`/`screen` are
+ * hints for switching to (or reopening) the origin tab. Never stores secrets,
+ * external URLs, or row data.
+ */
+interface ReturnTarget {
+  pathname: string;
+  search?: string;
+  hash?: string;
+  tabId?: string;
+  title?: string;
+  icon?: string;
+  screen?: string;
+}
+interface TabItem {
+  id: string;
+  pathname: string;
+  search: string;
+  title: string;
+  derivedTitle?: boolean;
+  icon?: string;
+  closable: boolean;
+  area?: string;
+  screen?: string;
+  navId?: string;
+  entity?: string;
+  record?: Record<string, unknown>;
+  mode?: TabMode;
+  dirty?: boolean;
+  returnTo?: ReturnTarget | null;
+}
+interface OpenTabOptions {
+  activate?: boolean;
+}
+interface TabState {
+  tabs: TabItem[];
+  activeTabId: string | null;
+  openTab: (tab: Omit<TabItem, "id">, options?: OpenTabOptions) => string;
+  closeTab: (id: string) => void;
+  closeTabs: (ids: string[]) => TabItem | null;
+  switchTab: (id: string) => void;
+  findTabByPathname: (pathname: string) => TabItem | undefined;
+  updateTabTitle: (id: string, title: string, derived?: boolean) => void;
+  updateTabSearch: (id: string, search: string) => void;
+  setReturnTarget: (id: string, rt: ReturnTarget | null) => void;
+  commitTabNavigation: (id: string, patch: {
+    search: string;
+    returnTo?: ReturnTarget | null;
+  }) => void;
+  setDirty: (id: string, dirty: boolean) => void;
+  setMode: (id: string, mode: TabMode) => void;
+  updateTab: (id: string, patch: Partial<TabItem>) => void;
+  setScope: (tenantId: string | null, userId: string | null) => void;
+  hydrate: () => void;
+}
+export declare const useTabStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TabState>>;
+//#endregion
+//#region src/hooks/useTabNavigate.d.ts
+interface TabNavigateOptions {
+  title?: string;
+  icon?: string;
+  search?: string;
+  replace?: boolean;
+  /**
+   * Top-level (chrome) navigation: do NOT capture the current screen as the
+   * destination's Back origin; CLEAR the destination tab's origin to `null`
+   * (the menu-cleared sentinel) so a menu/sidebar/command-palette-opened
+   * screen shows no Back. Default `false` = capture by default, which is what
+   * makes every drill-in (content anchors, row clicks, association, action
+   * href, custom `tabNavigate`) origin-aware with no per-site change.
+   */
+  topLevel?: boolean;
+}
+export declare function useTabNavigate(): (to: string, opts?: TabNavigateOptions) => void;
+//#endregion
+//#region src/hooks/useScreenBack.d.ts
+interface UseScreenBackOptions {
+  /** Static/parent fallback invoked when there is no valid origin (e.g. a
+   *  detail's `backToList`, a custom screen's static `PageHeader.backTo`).
+   *  Callers make this embed-correct themselves; the hook never tab-ops it. */
+  fallback?: () => void;
+}
+interface ScreenBack {
+  /** True when `goBack` will navigate (an origin exists, or a fallback is
+   *  provided and permitted). Drives whether to render a Back affordance when a
+   *  surface has no other visibility rule. */
+  canGoBack: boolean;
+  /** True when the active screen has a captured origin to return to. */
+  hasOriginBack: boolean;
+  /** True when a static/parent fallback is permitted (false ONLY for a
+   *  menu-cleared origin). Surfaces combine it with their own rule. */
+  allowFallbackBack: boolean;
+  /** Navigate Back: switch to / reopen the origin tab, else invoke the
+   *  fallback. Never closes the current tab; never throws. */
+  goBack: () => void;
+}
+export declare function useScreenBack(opts?: UseScreenBackOptions): ScreenBack;
+//#endregion
+//#region src/hooks/usePageState.d.ts
+/** A `useState`-style setter accepting a value or an updater. */
+type PageStateSetter<T> = (next: T | ((prev: T) => T)) => void;
+/**
+ * How coarsely a value is keyed.
+ *   - `"url"` (default): keyed by the full canonical URL, so it FORKS when
+ *     filters/sort/sub-view change (per-view memory - e.g. scroll position,
+ *     expanded rows). A filter change is a new view with its own value.
+ *   - `"path"`: keyed by the screen pathname only, so it PERSISTS across
+ *     in-screen query changes (e.g. row selection, which survives a filter or
+ *     column change and is pruned to the visible rows, not reset).
+ */
+type PageStateScope = "url" | "path";
+interface PageStateOptions {
+  scope?: PageStateScope;
+}
+/**
+ * Bind a deep value to the current screen's retained page.
+ *
+ * Returns `[value, setValue]`:
+ *   - `value` is the stored value for the live canonical URL, or `defaultValue`
+ *     when absent / reaped / retention disabled. Re-renders only when THIS
+ *     pageKey's value for THIS key changes.
+ *   - `setValue` writes through to the store under the LIVE canonical URL
+ *     (tracked via a per-render ref, so the stable setter always targets the
+ *     currently-mounted view - never a key captured at mount, never the
+ *     destination's after a navigation). Accepts a value or an updater.
+ *
+ * Writes are immediate (write-through), so there is no deferred unmount flush to
+ * lose: a value set while mounted at a URL is already stored under that URL when
+ * the screen unmounts. The retained page is created lazily on first write.
+ */
+export declare function usePageState<T>(key: string, defaultValue: T, opts?: PageStateOptions): [T, PageStateSetter<T>];
+//#endregion
+//#region src/lib/canonical-url.d.ts
+/** The minimal location shape canonicalUrl needs (a router `Location` satisfies
+ *  it; tests can pass a bare object). */
+interface CanonicalLocation {
+  pathname: string;
+  search?: string;
+}
+/**
+ * Build the canonical URL key for a location: normalized pathname + the
+ * view-defining query, sorted by key, with the embed transport params removed.
+ *
+ * Sorting makes `?a=1&b=2` and `?b=2&a=1` one key. Removing `EMBED_PARAM_KEYS`
+ * makes the same screen one key whether or not the embed params ride along, so
+ * a retained page is shared between the embedded and non-embedded view of the
+ * same URL. Default query values are NOT collapsed (which params have a default
+ * is screen-specific and collapsing the wrong one would silently merge or fork
+ * pages); two URLs that differ only by an explicit-vs-implicit default are
+ * treated as distinct, which is safe (at worst slightly less sharing).
+ */
+export declare function canonicalUrl(location: CanonicalLocation): string;
+//#endregion
+//#region src/hooks/usePageStateRuntime.d.ts
+/**
+ * Register a screen's PRIMARY heavy read (its list or detail query key) with the
+ * current retained page, so a kill/sweep `removeQueries` releases the cached
+ * data alongside the deep state. Call from the standard pages (and custom
+ * screens) with the key from the matching key-builder (`entityDataQueryKey` /
+ * `cursorEntityDataQueryKey` / `objectQueryKey`).
+ *
+ * Pass ONLY primary heavy reads - never a shared ref/lookup query, or a
+ * sibling screen that shares its key would lose it on this page's eviction.
+ * `enabled` (default true) lets the cursor/offset pages register exactly the
+ * read they actually use.
+ */
+export declare function useRegisterRetainedQuery(queryKey: QueryKey | undefined, enabled?: boolean): void;
+//#endregion
+//#region src/hooks/usePageStateTtl.d.ts
+/** The platform parameter governing retained-page retention. Declared in
+ *  modules/declarion-core/schema/core_parameters.yaml (int, category `ui`,
+ *  `[tenant]`, env `DECLARION_UI_PAGE_STATE_TTL_MS`). */
+export declare const PAGE_STATE_TTL_PARAM = "ui_page_state_ttl_ms";
+/**
+ * Resolve the retention window in milliseconds. Returns the per-tenant value
+ * once the parameter loads, the YAML-mirrored default before then, and clamps a
+ * malformed value to the default (never NaN/negative). `0` is honored as
+ * "retention disabled".
+ */
+export declare function usePageStateTtl(): number;
+//#endregion
+//#region src/hooks/useScreenTab.d.ts
+interface UseScreenTabOptions {
+  /** The tab's route. Defaults to the live `location.pathname` - the right value
+   *  for a param-less custom screen, which is the common case. */
+  route?: string;
+  /** Tab title. Defaults to the route when omitted. */
+  title?: string;
+  /** Tab icon name (resolved by the icon registry). */
+  icon?: string;
+}
+export declare function useScreenTab(opts?: UseScreenTabOptions): void;
+//#endregion
+//#region src/hooks/useTabSearchMirror.d.ts
+export declare function useTabSearchMirror(route: string | undefined): void;
+//#endregion
+//#region src/lib/scroll-restoration.d.ts
+/** The default deep-state bag key under which a screen's scroll anchor is
+ *  stored. A screen with one scroll container uses this; a screen with several
+ *  passes distinct keys. */
+export declare const SCROLL_STATE_KEY = "scroll";
+/**
+ * A saved scroll position. `key` is the stable key of the row at the top of the
+ * viewport (empty when the container had no rows / is non-virtualized); `delta`
+ * is the sub-row pixel offset; `offset` is the raw scroll offset kept as a
+ * last-resort fallback when the anchor row is gone.
+ */
+interface ScrollAnchor {
+  key: string;
+  delta: number;
+  offset: number;
+}
+/** The minimal virtualizer surface the seam needs. A
+ *  `Virtualizer<HTMLElement, Element>` is structurally assignable; a test can
+ *  pass a fake. */
+interface ScrollableVirtualizer {
+  scrollOffset: number | null;
+  getVirtualItemForOffset: (offset: number) => {
+    index: number;
+    start: number;
+  } | undefined;
+  getOffsetForIndex: (index: number, align?: "start") => readonly [number, unknown] | undefined;
+  getTotalSize: () => number;
+  scrollToOffset: (offset: number, opts?: {
+    align?: "start";
+    behavior?: "auto";
+  }) => void;
+}
+/** Read the saved raw scroll offset for the current page ONCE, for seeding a
+ *  virtualizer's `initialOffset` (read-once at init). Returns 0 when none /
+ *  retention off. The full anchor re-restore happens after rows measure. */
+export declare function useSavedScrollOffset(stateKey?: string): number;
+/**
+ * Bind scroll save + anchor-row restore for a VIRTUALIZED list to the retained
+ * page keyed by the live canonical URL.
+ *
+ * - Restore: once per pageKey, after `rowKeys` first become non-empty, scrolls
+ *   to `resolveScrollOffset(...)` (anchor row -> clamped raw -> top).
+ * - Save: a throttled scroll listener captures the top-of-viewport anchor and
+ *   writes it imperatively (no re-render); the final position flushes on
+ *   unmount / pageKey change to the DEPARTING view's own URL (tracked via a
+ *   per-render ref).
+ *
+ * `enabled` (default true) lets a caller gate the seam; when false it is inert.
+ */
+export declare function useVirtualScrollRestoration(opts: {
+  virtualizer: ScrollableVirtualizer | null;
+  scrollElementRef: {
+    current: HTMLElement | null;
+  };
+  rowKeys: string[];
+  stateKey?: string;
+  enabled?: boolean;
+}): void;
+/**
+ * Scroll save + restore for a PLAIN (non-virtualized) scroll container - the
+ * detail page. Stores the raw `scrollTop` (no anchor rows to key by) under the
+ * live canonical URL; restores after first layout; saves throttled-on-scroll +
+ * on unmount flush.
+ */
+export declare function usePlainScrollRestoration(opts: {
+  scrollElementRef: {
+    current: HTMLElement | null;
+  };
+  stateKey?: string;
+  enabled?: boolean;
+}): void;
+//#endregion
+//#region src/components/pages/SmartListPage.impl.d.ts
+interface SmartListPageProps {
+  screenCode: string;
+}
+//#endregion
+//#region src/components/pages/SmartListPage.d.ts
+export declare function SmartListPage(props: SmartListPageProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/SmartDetailPage.impl.d.ts
+interface SmartDetailPageProps {
+  screenCode: string;
+}
+//#endregion
+//#region src/components/pages/SmartDetailPage.d.ts
+export declare function SmartDetailPage(props: SmartDetailPageProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/SmartRecordListPage.impl.d.ts
+interface SmartRecordListPageProps {
+  screenCode: string;
+}
+//#endregion
+//#region src/components/pages/SmartRecordListPage.d.ts
+export declare function SmartRecordListPage(props: SmartRecordListPageProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/chrome/PageHeader.d.ts
+interface PageHeaderProps {
+  /** Overrides the screen's declared name. Omit it: `<PageHeader />` renders the
+   *  screen's own `display.name` from the schema, already localized, so a rename or a
+   *  translation in YAML reaches the page instead of only the sidebar. Pass a string
+   *  only for a title the schema cannot know (a record's name, a wizard step). */
+  title?: string;
+  /** Overrides the screen's declared `display.description`. When either is present the
+   *  header shows the same small info affordance a list and a record already show;
+   *  when neither is, the header renders exactly as before. */
+  description?: string;
+  backTo?: string;
+  actions?: ReactNode;
+}
+export declare function PageHeader({ title, description, backTo, actions }: PageHeaderProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/shared/EmptyState.d.ts
+interface EmptyStateProps {
+  icon?: string;
+  title: string;
+  description?: ReactNode;
+  action?: ReactNode;
+}
+export declare function EmptyState({ icon, title, description, action }: EmptyStateProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/shared/ConfirmDialog.d.ts
+interface ConfirmDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description: string;
+  confirmLabel?: string;
+  onConfirm: () => void;
+  destructive?: boolean;
+}
+export declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel, onConfirm, destructive }: ConfirmDialogProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/filters/FilterDrawer.d.ts
+interface FilterFieldMeta {
+  code: string;
+  label: string;
+  type: "string" | "enum" | "int" | "float" | "date" | "timestamp" | "bool" | "ref" | "status" | "property" | (string & {});
+  operators: FilterOp[];
+  options?: {
+    value: string;
+    label: string;
+    color?: string;
+  }[];
+  ref?: RefConfig;
+  specialValues?: FilterSpecialValue[];
+}
+interface FilterDrawerProps {
+  open: boolean;
+  onClose: () => void;
+  filters: FilterNode[];
+  onApply: (filters: FilterNode[]) => void;
+  availableFields: FilterFieldMeta[];
+  allFields?: FilterFieldMeta[];
+  fieldLabel?: (field: string) => string;
+  resolveValue?: FilterValueResolver;
+  /** Screen `default_filters`: field codes pre-seeded as empty-valued rows when
+   *  the panel opens with no active filters. Never pre-applies a value. */
+  defaultFilters?: string[];
+  /** Shared resolved-ref map (from the list page's filter-value resolver),
+   *  passed to each ref editor's RefCombobox so it labels the selected value
+   *  from this cache instead of firing its own per-value hydration fetch. */
+  refs?: Refs;
+}
+export declare function FilterDrawer({ open, onClose, filters, onApply, availableFields, allFields, fieldLabel, resolveValue, defaultFilters, refs }: FilterDrawerProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/filters/FilterChips.d.ts
+interface FilterChipsProps {
+  filters: FilterNode[];
+  onRemove?: (field: string) => void;
+  onRemoveAtPath?: (path: number[]) => void;
+  onClearAll: () => void;
+  onChipClick?: () => void;
+  fieldLabel?: (field: string) => string;
+  /** Humanizes each chip VALUE (special -> label, enum/status -> label, ref ->
+   *  record label, with a skeleton while a ref label loads). Absent -> raw
+   *  values, so FilterChips stays usable standalone / in tests. */
+  resolveValue?: FilterValueResolver;
+}
+export declare function FilterChips({ filters, onRemove, onRemoveAtPath, onClearAll, onChipClick, fieldLabel, resolveValue }: FilterChipsProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/list/ColumnPicker.d.ts
+interface ColumnPickerProps {
+  /** Full column pool for the screen (data columns; never `_select`/`_actions`). */
+  availableColumns: string[];
+  /** Ordered visible columns (the `?columns` array). Order is meaningful. */
+  visibleColumns: string[];
+  onToggle: (col: string) => void;
+  /** Move a visible column one slot up/down in the order (the drag-free,
+   *  keyboard + touch reorder path - WCAG 2.2 SC 2.5.7). Optional: when
+   *  omitted, the reorder controls are not rendered (additive SDK evolution). */
+  onMove?: (col: string, dir: "up" | "down") => void;
+  onReset: () => void;
+  onShowAll: () => void;
+  /** Reset this device's column widths for the screen to the YAML defaults.
+   *  Widths are a separate, device-local lifecycle from order/visibility.
+   *  Optional: omitting it hides the width-reset item. */
+  onResetWidths?: () => void;
+  columnLabel?: (code: string) => string;
+}
+export declare function ColumnPicker({ availableColumns, visibleColumns, onToggle, onMove, onReset, onShowAll, onResetWidths, columnLabel }: ColumnPickerProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/actions/ActionRunner.d.ts
+interface RunActionOptions {
+  /** Full YAML action when available; drives destructive/long_running/resolved_params. */
+  action?: Action;
+  title?: string;
+  /** When `action` is absent, individual flags still steer dispatch. */
+  destructive?: boolean;
+  longRunning?: boolean;
+  /** Invoked after the user confirms / fills params. May return a promise
+   *  (awaited by the runner) or a sync value; `unknown` covers both. */
+  execute: (params: Record<string, unknown>) => unknown;
+  /**
+   * Caller-side hook fired after `execute` resolves with a `success`
+   * outcome. Reason: navigation and cache-invalidation decisions that
+   * follow an action depend on the caller's screen context, not on
+   * the action declaration. Detail pages use it to navigate back to
+   * the entity list after `__delete`; list pages can use it to clear
+   * row selection; SSE-driven pages may rely on the realtime stream
+   * instead and omit it entirely.
+   */
+  onSuccess?: (result: unknown) => void;
+  /**
+   * The current bulk selection (full row objects). Forwarded to
+   * ActionDialog so entity_patch params can pre-fill same-value
+   * editors from the selected rows. Omit for single-row or global
+   * action invocations.
+   */
+  bulkSelection?: ReadonlyArray<Record<string, unknown>>;
+  /**
+   * The record the action is bound to, for single-row invocations
+   * (detail header/toolbar, list row, quick peek). Forwarded to
+   * ActionDialog so `$row.*` param defaults resolve against it -
+   * without it every schema-declared prefill silently renders the
+   * param's empty state. Omit for global and bulk invocations.
+   */
+  row?: Record<string, unknown>;
+  /**
+   * Acted-entity override for the post-outcome query invalidation. Normally
+   * the runner reads `action.entity`; pass this when the dispatched action
+   * may lack its binding (e.g. a platform-default bulk action resolved from
+   * screen context).
+   */
+  entity?: string;
+}
+interface ActionRunnerContextValue {
+  /**
+   * Dispatch an action. Resolves when the action settles: for a direct-run
+   * action (no params, non-destructive) that is when `execute` finishes, so
+   * callers can await it to keep a trigger button disabled for the whole
+   * operation. For modal paths (params dialog / destructive confirm) it
+   * resolves immediately - the dialog owns its own pending UI.
+   */
+  run: (opts: RunActionOptions) => Promise<void>;
+  isRunning: boolean;
+}
+export declare function useActionRunner(): ActionRunnerContextValue;
+export declare function ActionRunnerProvider({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/lib/actions.d.ts
+/**
+ * Resolved leaf node. Kind discriminator "action".
+ * Enabled defaults true from server; client sets false when enabled_if fails.
+ * Reason carries the localized tooltip text when Enabled is false.
+ *
+ * Wire format: {"kind":"action","code":"approve","enabled":true,"reason":null}
+ */
+interface ResolvedActionLeaf {
+  kind: "action";
+  code: string;
+  enabled: boolean;
+  reason: string | null;
+}
+/**
+ * Resolved group node. Kind discriminator "group".
+ * Items is always non-empty after pruning (empty groups are dropped).
+ *
+ * Wire format: {"kind":"group","name":{...},"icon":"...","items":[...]}
+ */
+interface ResolvedActionGroup {
+  kind: "group";
+  name?: LocalizedString;
+  icon?: string;
+  items: ResolvedActionLayoutNode[];
+}
+/**
+ * Discriminated union for a resolved action layout node.
+ * Narrow via node.kind === "action" or node.kind === "group".
+ */
+type ResolvedActionLayoutNode = ResolvedActionLeaf | ResolvedActionGroup;
+//#endregion
+//#region src/components/actions/ResponsiveActionBar.d.ts
+/**
+ * Tab navigation options accepted by SDK tabNavigate. Kept loose here so the
+ * caller can pass through the full TabMeta from useTabNavigate without forcing
+ * a re-export.
+ *
+ * Reason: ResponsiveActionBar only forwards the value - tighter typing belongs
+ * with the navigation API, not with the dispatcher that hands the value off.
+ */
+interface TabMeta {
+  title?: string;
+  icon?: string;
+  search?: string;
+  replace?: boolean;
+}
+/**
+ * Minimal dispatch surface assembled by SmartListPage/DetailLayout and passed
+ * to ResponsiveActionBar. It carries what `href` dispatch needs plus the seat
+ * for a future widget registry mount.
+ *
+ * Reason: defining the full WidgetContext now would freeze a surface before
+ * the widget registry has a real consumer. It holds exactly the fields the
+ * href dispatch reads and extends without breaking callers.
+ */
+interface WidgetContext {
+  /** Resolved entity for the current page; widget code reads schema metadata. */
+  entity: Entity;
+  /** Wire-format entity code used to interpolate `${entity}` in href templates. */
+  entityCode: string;
+  /** Active screen, if any. Optional because some pages predate screens. */
+  screen?: Screen;
+  /** Pathname of the current screen, used by widgets that deep-link back. */
+  screenRoute: string;
+  /** Currently selected rows (full row objects). */
+  selectedRows: Record<string, unknown>[];
+  /** PK values of the currently selected rows, in selection order. */
+  selectedIds: string[];
+  /** Reads declared words in the reader's language; `t.language` formats values. */
+  t: TextFn;
+  /** Opens or switches to a tab in the SDK shell. */
+  tabNavigate: (url: string, meta?: TabMeta) => void;
+  /** Invokes a server action and returns its response envelope. */
+  runActionApi: (code: string, params: unknown) => Promise<unknown>;
+  /**
+   * Opens the Quick peek drawer for `row`. Present only where peek is available
+   * (list surfaces that pass it); the `__peek` platform default dispatches
+   * through here as a pure client verb - the mode-less counterpart of `__open`'s
+   * href navigation. Absent surfaces never receive a `__peek` leaf, so a missing
+   * callback is never invoked.
+   */
+  openPeek?: (row: Record<string, unknown> | undefined) => void;
+  /**
+   * The route this surface opens a record on: a list's own detail screen, a detail page's
+   * own route. `__open` and `__edit` follow it before the entity-wide href, so a screen
+   * outside the entity's primary area keeps its record in that area.
+   */
+  recordHref?: (rowId: string) => string | null;
+}
+//#endregion
+//#region src/components/actions/ObjectActionBar.d.ts
+type ObjectActionBarSlot = "detail" | "detail_toolbar" | "list_row" | "quick_peek";
+type ObjectActionSelection = {
+  include: string[];
+  exclude?: never;
+} | {
+  exclude: string[];
+  include?: never;
+};
+interface ObjectActionBarProps {
+  entity: string;
+  object: Record<string, unknown> | undefined;
+  slot: ObjectActionBarSlot;
+  screen?: string;
+  select?: ObjectActionSelection;
+  extraActions?: ReactNode;
+  onAfterRun?: (code: string, result: unknown) => void;
+}
+interface UseObjectActionsResult {
+  nodes: ResolvedActionLayoutNode[];
+  run: (code: string, action: Action) => void | Promise<void>;
+  isBusy: boolean;
+  widgetContext?: WidgetContext;
+}
+export declare function useObjectActions({ entity: entityCode, object, slot, screen: screenCode, select, onAfterRun }: Omit<ObjectActionBarProps, "extraActions">): UseObjectActionsResult;
+export declare function ObjectActionBar({ entity, object, slot, screen, select, extraActions, onAfterRun }: ObjectActionBarProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/shared/RefreshControl.d.ts
+/**
+ * What the control needs, which is less than any one caller happens to have.
+ *
+ * A detail page hands it a `useLiveObject` result; a list hands it a refresh
+ * that cancels in-flight queries first and returns nothing. Typing `refetch` as
+ * react-query's own signature would have made the second caller impossible and
+ * left the list with a copy of this component - which is how the two surfaces
+ * drifted in the first place.
+ */
+interface RefreshControlProps {
+  liveObject: {
+    /** Resolves when the refresh it starts has settled. See useOwnRefresh. */
+    refetch: () => unknown;
+    isLoading: boolean;
+    isLive: boolean;
+    /**
+     * @deprecated Ignored; the control reports only the refresh a person
+     * started. Passing it changes nothing. Declared so a consumer that builds
+     * this object literally still compiles.
+     */
+    isFetching?: boolean;
+  };
+  realtime?: boolean;
+}
+export declare function RefreshControl({ liveObject, realtime }: RefreshControlProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/fields/RefCombobox.d.ts
+interface RefComboboxProps {
+  ref: RefConfig | undefined;
+  /** Current stored ref target value (the `ref.field` value, or target PK). */
+  value: unknown;
+  onChange: (value: string | null) => void;
+  /**
+   * Server-embedded `$refs` enrichment map, keyed by the stored ref value.
+   * Used to label the current selection when it is outside the loaded page.
+   */
+  refs?: Refs;
+  /** FieldDisplay-level display override (`field.display.ref_display_field`). */
+  displayFieldOverride?: string;
+  id?: string;
+  labelId?: string;
+  ariaLabel?: string;
+  required?: boolean;
+  placeholder?: string;
+  /** Filter-only declared options (e.g. "Myself" -> $user.id) rendered as a
+   *  "Special values" group above the relation results. Selecting one stores its
+   *  `code` verbatim (a `$user.*` token is NOT resolved locally). Filter use only. */
+  specialValues?: FilterSpecialValue[];
+}
+/**
+ * RefCombobox is the ONE relation picker shared by every surface that selects a
+ * referenced record: SmartDetailPage create/edit ref fields, the list filter
+ * value editor, ActionDialog `type: ref` params, and inline-edit table ref
+ * cells. It loads a bounded page of accessible referenced rows through the
+ * normal data API (so RBAC/ABAC/tenant scoping all apply) and labels them via
+ * the canonical ref-label resolver.
+ *
+ * It stores the RESOLVED ref target value: `ref.field` when declared, otherwise
+ * the target entity's primary-key object id. (The legacy per-surface code stored
+ * the PK unconditionally and ignored `ref.field`.)
+ *
+ * Typed search hits the SERVER (debounced 300ms, via the `?search=` API over the
+ * entity's search fields), so a record past the bounded first page is findable;
+ * the `Select` primitive runs in server mode (`onSearchChange`) and renders the
+ * returned options without re-filtering them client-side. An empty search loads
+ * the default sorted page.
+ */
+export declare function RefCombobox({ ref: refConfig, value, onChange, refs, displayFieldOverride, id, labelId, ariaLabel, required, placeholder: placeholderOverride, specialValues }: RefComboboxProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/list/QuickPeek.d.ts
+interface QuickPeekRegularFieldSpec {
+  key: string;
+  label: string;
+  kind: "field";
+  field: EntityField;
+  readOnly?: boolean;
+}
+interface QuickPeekFileFieldSpec {
+  key: string;
+  label: string;
+  kind: "file";
+  readOnly?: boolean;
+}
+type QuickPeekFieldSpec = QuickPeekRegularFieldSpec | QuickPeekFileFieldSpec;
+interface QuickPeekProps<R extends Record<string, unknown> = Record<string, unknown>> {
+  entity: Pick<Entity, "fields" | "files" | "variants">;
+  entityCode?: string;
+  record: R;
+  title: string;
+  recordId?: string;
+  avatarName?: string;
+  fields: QuickPeekFieldSpec[];
+  /** $refs payload from the list/detail API; used by RefField-style renderers. */
+  refs?: Refs;
+  /** Full screen YAML — honors `screen.quick_peek.width`. */
+  screen?: Screen;
+  /** All actions available on this record. */
+  actions: Record<string, Action>;
+  /**
+   * Resolved action_layout (screen overrides entity). The peek footer renders
+   * the `quick_peek` slot through the SAME ResponsiveActionBar as the list
+   * toolbar and detail header: declared top-level actions are buttons, the rest
+   * collapse into the overflow menu. One mechanism everywhere.
+   */
+  screenActionLayout?: ResolvedActionLayoutNode[];
+  entityActionLayout?: ResolvedActionLayoutNode[];
+  executeAction: (code: string, action: Action, params: Record<string, unknown>) => Promise<unknown>;
+  /**
+   * Close the peek.
+   */
+  onClose: () => void;
+  /**
+   * Open full detail. Receives the draft when dirty, else null — caller seeds
+   * ShellDetailPage.initialDirty + initial values from this draft.
+   */
+  onOpen: (draft: R | null) => void;
+  /** Fires once per explicit user commit — never on keystroke. */
+  onSave?: (next: R) => void;
+}
+export declare function QuickPeek<R extends Record<string, unknown>>({ entity, entityCode, record, title, recordId, avatarName, fields, refs, screen, actions, screenActionLayout, entityActionLayout, executeAction, onClose, onOpen, onSave }: QuickPeekProps<R>): import("react").JSX.Element;
+interface QEFieldProps {
+  label: string;
+  children: ReactNode;
+}
+export declare function QEField({ label, children }: QEFieldProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Btn.d.ts
+type BtnKind = "primary" | "ghost" | "subtle" | "default";
+type BtnSize = "xs" | "sm" | "md" | "lg";
+type BtnProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+  kind?: BtnKind;
+  size?: BtnSize;
+  icon?: ReactNode;
+  iconRight?: ReactNode;
+  active?: boolean;
+  danger?: boolean;
+};
+export declare const Btn: import("react").ForwardRefExoticComponent<Omit<ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+  kind?: BtnKind;
+  size?: BtnSize;
+  icon?: ReactNode;
+  iconRight?: ReactNode;
+  active?: boolean;
+  danger?: boolean;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/primitives/IconBtn.d.ts
+type IconBtnProps = {
+  icon: ReactNode;
+  onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+  title?: string;
+  size?: number;
+  active?: boolean;
+  disabled?: boolean;
+  style?: CSSProperties;
+};
+export declare const IconBtn: import("react").ForwardRefExoticComponent<IconBtnProps & import("react").RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/primitives/Pill.d.ts
+type PillTone = "indigo" | "emerald" | "amber" | "rose" | "sky" | "violet" | "slate" | "teal";
+type PillSize = "xs" | "sm" | "md";
+type PillProps = {
+  tone?: PillTone;
+  size?: PillSize;
+  dot?: boolean;
+  style?: CSSProperties;
+  children?: ReactNode;
+};
+export declare function Pill({ tone, children, size, dot, style }: PillProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Kbd.d.ts
+export declare function Kbd({ children }: {
+  children?: ReactNode;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Avatar.d.ts
+type AvatarProps = {
+  name: string;
+  size?: number;
+  color?: string;
+};
+export declare function Avatar({ name, size, color }: AvatarProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/BrandGlyph.d.ts
+interface BrandGlyphProps {
+  /** Pixel edge of the rendered SVG. Defaults to 24. */
+  size?: number;
+  className?: string;
+  /** ARIA label; omit for purely decorative usages. */
+  title?: string;
+}
+export declare function BrandGlyph({ size, className, title }: BrandGlyphProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Dropdown.d.ts
+type DropdownProps = {
+  open: boolean;
+  onClose?: () => void;
+  anchor: HTMLElement | null;
+  /**
+   * Cursor-point anchoring for context menus: when set (and `anchor` is null),
+   * the menu opens at the point and gets the same viewport clamping / above-
+   * flip as element anchoring. One positioning engine for every popover.
+   */
+  anchorPoint?: {
+    x: number;
+    y: number;
+  };
+  align?: "start" | "end";
+  width?: number;
+  style?: CSSProperties;
+  children?: ReactNode;
+};
+export declare function Dropdown({ open, onClose, anchor, anchorPoint, children, align, width, style }: DropdownProps): import("react").ReactPortal | null;
+//#endregion
+//#region src/components/primitives/HoverCard.d.ts
+type HoverCardAlign = "start" | "center" | "end";
+type HoverCardProps = {
+  /** The card body shown on hover. Caller controls the rendered content. */
+  content: ReactNode;
+  /** The trigger node. Wrapped in an inline span. */
+  children: ReactNode;
+  /** Card width in pixels. Default 320. */
+  width?: number;
+  /** Horizontal alignment relative to the anchor. Default `center`. */
+  align?: HoverCardAlign;
+  /** Optional inline style overrides on the card body. */
+  style?: CSSProperties;
+};
+export declare function HoverCard({ content, children, width, align, style }: HoverCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Tooltip.d.ts
+interface TooltipProps {
+  /** Tooltip text. Empty/absent renders the trigger with no tooltip. */
+  content?: string;
+  children: ReactNode;
+  /** Extra props forwarded to the trigger wrapper (e.g. data-testid). */
+  triggerProps?: React.HTMLAttributes<HTMLSpanElement>;
+}
+export declare function Tooltip({ content, children, triggerProps }: TooltipProps): import("react").JSX.Element;
+interface InfoTooltipProps {
+  label: string;
+  size?: number;
+  "data-testid"?: string;
+}
+export declare function InfoTooltip({ label, size, ...rest }: InfoTooltipProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Chip.d.ts
+type ChipProps = {
+  tone?: string;
+  icon?: ReactNode;
+  children?: ReactNode;
+  onRemove?: () => void;
+  removeLabel?: string;
+  onClick?: () => void;
+};
+export declare function Chip({ icon, children, onRemove, removeLabel, onClick }: ChipProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/SectionCard.d.ts
+type SectionBadge = {
+  text: string;
+  tone?: PillTone;
+  dot?: boolean;
+};
+type SectionEmphasis = "primary" | "secondary";
+type SectionCardProps = {
+  title: ReactNode;
+  subtitle?: ReactNode;
+  right?: ReactNode;
+  badge?: SectionBadge;
+  count?: number;
+  children?: ReactNode;
+  footer?: ReactNode;
+  collapsible?: boolean;
+  defaultOpen?: boolean;
+  icon?: ReactNode;
+  emphasis?: SectionEmphasis;
+  headingLevel?: number;
+  padding?: string;
+};
+export declare function SectionCard({ title, subtitle, right, badge, count, children, footer, collapsible, defaultOpen, icon, emphasis, headingLevel, padding }: SectionCardProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/RecordIdBadge.d.ts
+type RecordIdBadgeProps = {
+  value: string;
+};
+/**
+ * Compact record-ID badge. Truncates UUIDs to their first segment for readability
+ * and copies the full value on click. Non-UUID ids render in full.
+ */
+export declare function RecordIdBadge({ value }: RecordIdBadgeProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/RowField.d.ts
+type RowFieldProps = {
+  label: ReactNode;
+  children?: ReactNode;
+  wide?: boolean;
+  editing?: boolean;
+  required?: boolean;
+  hint?: string;
+};
+export declare function RowField({ label, children, wide, editing, required }: RowFieldProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/BoolToggle.d.ts
+type BoolToggleProps = {
+  value?: boolean;
+  onChange?: (v: boolean) => void;
+  id?: string;
+  ariaLabelledby?: string;
+};
+export declare function BoolToggle({ value, onChange, id, ariaLabelledby }: BoolToggleProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/MenuItem.d.ts
+type MenuItemProps = {
+  icon?: ReactNode;
+  children?: ReactNode;
+  onClick?: () => void;
+  danger?: boolean;
+  kbd?: ReactNode;
+  active?: boolean;
+  divider?: boolean;
+  disabled?: boolean;
+  title?: string;
+  "data-testid"?: string;
+};
+export declare function MenuItem({ icon, children, onClick, danger, kbd, active, divider, disabled, title, "data-testid": dataTestId }: MenuItemProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Check.d.ts
+type CheckProps = {
+  checked?: boolean;
+  onChange?: (v: boolean) => void;
+  indeterminate?: boolean;
+  size?: number;
+};
+export declare function Check({ checked, onChange, indeterminate, size }: CheckProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Spinner.d.ts
+export declare function Spinner({ size }: {
+  size?: number;
+}): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/ClassifiedFieldLocked.d.ts
+interface ClassifiedFieldLockedProps {
+  tier: string;
+  tierDef?: ClassificationTierDef;
+  requiredPermission?: string;
+  variant?: "value" | "input";
+}
+export declare function ClassifiedFieldLocked({ tier, tierDef, requiredPermission, variant }: ClassifiedFieldLockedProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/primitives/Fields.d.ts
+type FieldLabelProps = {
+  children?: ReactNode;
+  required?: boolean;
+  hint?: string;
+  htmlFor?: string;
+  id?: string;
+};
+export declare const FieldLabel: ({ children, required, hint, htmlFor, id }: FieldLabelProps) => import("react").JSX.Element;
+type TextInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "prefix"> & {
+  value?: string | null;
+  onChange?: (v: string) => void;
+  prefix?: ReactNode;
+  suffix?: ReactNode;
+  style?: CSSProperties;
+};
+export declare function TextInput({ value, onChange, placeholder, prefix, suffix, style, ...rest }: TextInputProps): import("react").JSX.Element;
+type TextAreaProps = {
+  value?: string | null;
+  onChange?: (v: string) => void;
+  placeholder?: string;
+  rows?: number;
+  fill?: boolean;
+  id?: string;
+  name?: string;
+  ariaRequired?: boolean;
+};
+export declare function TextArea({ value, onChange, placeholder, rows, fill, id, name, ariaRequired }: TextAreaProps): import("react").JSX.Element;
+type SelectOption = {
+  value: string;
+  label: ReactNode;
+  heading?: boolean;
+  divider?: boolean;
+};
+type SelectProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "onChange"> & {
+  value?: string;
+  options: SelectOption[];
+  onChange: (v: string) => void;
+  placeholder?: string;
+  /**
+   * Server-search mode. When set, the typed query is reported here (instead of
+   * filtering the options client-side) so the parent can fetch matching
+   * options from the server; the dropdown renders the given `options` as-is.
+   * The search input is always shown in this mode. Absent -> client-side
+   * filtering over `options`, as before.
+   */
+  onSearchChange?: (query: string) => void;
+};
+export declare function Select({ value, options, onChange, placeholder, onSearchChange, ...rest }: SelectProps): import("react").JSX.Element;
+type MultiSelectProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "onChange"> & {
+  value?: string[];
+  options: SelectOption[];
+  onChange: (v: string[]) => void;
+  placeholder?: string;
+};
+export declare function MultiSelect({ value, options, onChange, placeholder, ...rest }: MultiSelectProps): import("react").JSX.Element;
+type DateInputProps = {
+  value?: string | null;
+  onChange?: (v: string) => void;
+};
+export declare function DateInput({ value, onChange }: DateInputProps): import("react").JSX.Element;
+type PasswordInputProps = {
+  value?: string | null;
+  onChange?: (v: string) => void;
+  placeholder?: string;
+  showStrength?: boolean;
+  id?: string;
+  name?: string;
+  ariaRequired?: boolean;
+};
+export declare function PasswordInput({ value, onChange, placeholder, showStrength, id, name, ariaRequired }: PasswordInputProps): import("react").JSX.Element;
+type TagsInputProps = {
+  value?: string[];
+  onChange: (v: string[]) => void;
+};
+export declare function TagsInput({ value, onChange }: TagsInputProps): import("react").JSX.Element;
+type JsonFieldProps = {
+  value?: string;
+  onChange?: (v: string) => void;
+};
+export declare function JsonField({ value, onChange }: JsonFieldProps): import("react").JSX.Element;
+type RefFieldItem = {
+  id: string;
+  name: string;
+};
+type RefFieldProps = {
+  value?: string;
+  entity?: string;
+  onChange?: (v: string) => void;
+  items?: RefFieldItem[];
+  id?: string;
+  ariaLabelledby?: string;
+  ariaRequired?: boolean;
+};
+export declare function RefField({ value, entity, onChange, items, id, ariaLabelledby, ariaRequired }: RefFieldProps): import("react").JSX.Element;
+type ViewFieldProps = {
+  label: ReactNode;
+  children?: ReactNode;
+  mono?: boolean;
+  wide?: boolean;
+  empty?: boolean;
+};
+export declare function ViewField({ label, children, mono, wide, empty }: ViewFieldProps): import("react").JSX.Element;
+type QuickEditCellProps = {
+  value?: string;
+  onChange?: (v: string) => void;
+  type?: "text" | "select" | "bool";
+  options?: SelectOption[];
+  tone?: string;
+};
+export declare function QuickEditCell({ value, onChange, type, options }: QuickEditCellProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/list/InlineEditCell.d.ts
+type InlineEditTrigger = "dblclick" | "enter" | "always";
+type InlineEditKind = "text" | "select" | "bool";
+interface InlineEditCellProps {
+  value?: string;
+  onSave: (v: string) => Promise<void> | void;
+  type?: InlineEditKind;
+  options?: SelectOption[];
+  /** Drives when a display cell flips to edit. Default `always` (matches QuickEditCell). */
+  trigger?: InlineEditTrigger;
+  /** Field label — surfaces in the error toast so the user knows which cell rolled back. */
+  label?: string;
+  placeholder?: string;
+}
+export declare function InlineEditCell({ value, onSave, type, options, trigger, label, placeholder }: InlineEditCellProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/SignIn.d.ts
+export declare function SignIn(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/SignUp.d.ts
+export declare function SignUp(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/Forgot.d.ts
+export declare function Forgot(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/Reset.d.ts
+export declare function Reset(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/TwoFA.d.ts
+export declare function TwoFA(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/auth/AuthShell.d.ts
+type AuthShellProps = {
+  children: ReactNode;
+  /** With `branding.identity.workspace_domain`, shows the `<tenantSlug>.<domain>` pill. No SDK caller
+   *  passes it until tenant-from-host resolution exists. */
+  tenantSlug?: string;
+  tagline?: string;
+  subTagline?: string;
+  version?: string;
+  badges?: Array<[string, keyof typeof Icon]>;
+  /** Optional override for the wordmark / app name shown in topbar + brand panel. */
+  brandName?: string;
+};
+export declare function AuthShell({ children, tenantSlug, tagline, subTagline, version, badges, brandName }: AuthShellProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/profile/Profile.d.ts
+export declare function Profile(): import("react").JSX.Element;
+//#endregion
+//#region src/components/pages/profile/Preferences.d.ts
+export declare function Preferences(): import("react").JSX.Element;
+//#endregion
+//#region src/components/shared/ChangePasswordDialog.impl.d.ts
+type ChangePasswordDialogProps = {
+  open: boolean;
+  onClose: () => void;
+  onSubmit: (input: {
+    current: string;
+    next: string;
+  }) => Promise<void> | void;
+};
+//#endregion
+//#region src/components/shared/ChangePasswordDialog.d.ts
+export declare function ChangePasswordDialog(props: ChangePasswordDialogProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/file-widgets/types.d.ts
+interface FileWidgetProps {
+  field: FileFieldDef;
+  fieldName: string;
+  entityCode?: string;
+  value: FileFieldValue;
+  mode: "display" | "edit";
+  onChange?: (next: FileFieldValue) => void;
+  disabled?: boolean;
+  alt?: string;
+  recordTitle?: string;
+  uploadFieldCode?: string;
+  uploadSlotCode?: string;
+  fieldId?: string;
+}
+type FileWidget = React.ComponentType<FileWidgetProps>;
+//#endregion
+//#region src/components/file-widgets/SquareImage.d.ts
+export declare function SquareImage(props: FileWidgetProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/file-widgets/CircleImage.d.ts
+export declare function CircleImage(props: FileWidgetProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/file-widgets/WideBanner.d.ts
+export declare function WideBanner(props: FileWidgetProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/file-widgets/registry.d.ts
+export declare function registerFileWidget(code: string, widget: FileWidget): void;
+export declare function getFileWidget(code: string): FileWidget | undefined;
+export declare function hasFileWidget(code: string): boolean;
+//#endregion
+//#region src/components/file-widgets/upload.d.ts
+interface UploadOptions {
+  file: File;
+  entityCode?: string;
+  fieldCode?: string;
+  slotCode?: string;
+  onProgress?: (p: UploadProgress) => void;
+  signal?: AbortSignal;
+}
+export declare class UploadError extends Error {
+  /** The declared type's identifier, e.g. `file.too_large`. */
+  code: string;
+  status: number;
+  /** The untouched body, so a declared member reaches a caller through ext(). */
+  raw?: unknown;
+  constructor(status: number, code: string, message: string, raw?: unknown);
+  /** A declared member of this error's type, read the one way. */
+  ext<T = unknown>(member: string): T | undefined;
+}
+export declare function uploadFile(opts: UploadOptions): Promise<UploadedFile>;
+export declare function discardFile(fileId: string): Promise<void>;
+type UploadCheck = {
+  code: "file.too_large";
+  message: string;
+  size: number;
+  max: number;
+} | {
+  code: "file.field_violation";
+  message: string;
+  type: string;
+};
+export declare function validateClientSide(file: File, accepts: string[] | undefined, maxBytes: number | undefined): UploadCheck | null;
+export declare function formatBytes(n: number): string;
+//#endregion
+//#region src/components/file-widgets/cropper.d.ts
+interface CropperOptions {
+  aspectRatio?: number;
+  file: File;
+}
+interface CropperResult {
+  blob: Blob;
+  filename: string;
+}
+type ImageCropper = (opts: CropperOptions) => Promise<CropperResult>;
+export declare function setImageCropper(c: ImageCropper | null): void;
+export declare function getImageCropper(): ImageCropper;
+//#endregion
+//#region src/components/file-widgets/draft-scope.d.ts
+interface DraftEntry {
+  fileId: string;
+  discard: () => Promise<void> | void;
+}
+interface FileDraftScopeApi {
+  registerDraft(entry: DraftEntry): void;
+  unregisterDraft(fileId: string): void;
+  hasDraft(fileId: string): boolean;
+  flushAllDrafts(): Promise<void>;
+  markCommitted(fileId: string): void;
+}
+export declare function FileDraftScope({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useFileDraftScope(): FileDraftScopeApi;
+export declare function useDraftRegistration(): {
+  register: (fileId: string, discard: () => Promise<void> | void) => void;
+  unregister: (fileId: string) => void;
+  markCommitted: (fileId: string) => void;
+  isDraft: (fileId: string) => boolean;
+};
+//#endregion
+//#region src/components/layout/Rail.d.ts
+interface RailAreaItem {
+  id: string;
+  icon: string | undefined;
+  label: string;
+}
+interface RailProps {
+  activeArea: string;
+  onPick: (id: string) => void;
+  onToggleAI: () => void;
+  aiOpen: boolean;
+  onCmdK: () => void;
+  areas?: AreaDef[];
+  /**
+   * Consumer branding identity. When `app_logo` is present
+   * the rail's brand tile renders the consumer image. Otherwise `app_name`
+   * supplies an initial and tooltip; with neither value the tile is empty.
+   */
+  branding?: BrandingIdentity;
+}
+export declare function Rail({ activeArea, onPick, onToggleAI, aiOpen, onCmdK, areas, branding }: RailProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/layout/Sidebar.d.ts
+interface SidebarProps {
+  activeArea: string;
+}
+export declare function Sidebar({ activeArea }: SidebarProps): import("react").JSX.Element;
+interface SidebarSection {
+  title: string;
+  items: NavNode[];
+}
+export declare function buildSections(t: TextFn, nodes: NavNode[], activeArea: string): SidebarSection[];
+//#endregion
+//#region src/components/chrome/Breadcrumbs.d.ts
+interface Crumb {
+  label: string;
+  icon?: IconName | (string & {});
+  onClick?: () => void;
+  target?: unknown;
+  /** True for the final segment (rendered bold per design spec). */
+  isLast?: boolean;
+}
+interface BreadcrumbsProps {
+  items: Crumb[];
+  onCrumbClick?: (crumb: Crumb) => void;
+}
+export declare function Breadcrumbs({ items, onCrumbClick }: BreadcrumbsProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/layout/TopBar.d.ts
+interface TopBarProps {
+  breadcrumbs?: Crumb[];
+  onCrumbClick?: (c: Crumb) => void;
+  onOpenNav?: () => void;
+  navButtonRef?: RefObject<HTMLButtonElement | null>;
+  showNavButton?: boolean;
+  onOpenTabs?: () => void;
+  tabsButtonRef?: RefObject<HTMLButtonElement | null>;
+  showTabsButton?: boolean;
+  mobileTabCount?: number;
+  onCmdK?: () => void;
+  onToggleAI?: () => void;
+  aiOpen?: boolean;
+  onOpenProfile?: () => void;
+  onOpenPrefs?: () => void;
+  showTenantSwitcher?: boolean;
+  showBreadcrumbs?: boolean;
+  showThemeToggle?: boolean;
+}
+export declare function TopBar({ breadcrumbs, onCrumbClick, onOpenNav, navButtonRef, showNavButton, onOpenTabs, tabsButtonRef, showTabsButton, mobileTabCount, onCmdK, onToggleAI, aiOpen, onOpenProfile, onOpenPrefs, showTenantSwitcher, showBreadcrumbs, showThemeToggle }?: TopBarProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/layout/TenantChip.d.ts
+interface TenantChipProps {
+  tenant: Tenant | null;
+  tenants: Tenant[];
+  onSwitch: (tenant: Tenant) => void;
+  busy?: boolean;
+  compact?: boolean;
+  /**
+   * When true, the chip is disabled with a tooltip explaining why.
+   * Used during impersonation: cross-tenant targeting at start is
+   * supported, but mid-session tenant switching is undefined and
+   * locked.
+   */
+  locked?: boolean;
+  lockedReason?: string;
+}
+interface EnvTone {
+  fg: string;
+  bg: string;
+  border?: string;
+  darkFg?: string;
+  darkBg?: string;
+}
+export declare function envTone(env?: TenantEnv): EnvTone;
+export declare function TenantChip({ tenant, tenants, onSwitch, busy, compact, locked, lockedReason }: TenantChipProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/layout/TabStrip.d.ts
+interface TabStripProps {
+  onNew?: () => void;
+  onCloseRequest?: (scope: TabCloseScope, targetId?: string) => void;
+}
+export declare function TabStrip({ onNew: onNewProp, onCloseRequest }?: TabStripProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/layout/ImpersonationBanner.d.ts
+export declare function ImpersonationBanner(): import("react").JSX.Element;
+//#endregion
+//#region src/components/layout/ImpersonationFrame.d.ts
+/**
+ * Fixed 4px viewport overlay frame that surrounds every route. Visible
+ * for the duration of an impersonation session. The
+ * pointer-events:none guarantees the frame never blocks clicks.
+ *
+ * Color comes from --impersonation-accent (amber by default). When
+ * impersonation.allow_destructive=true, this component sets a body
+ * attribute that flips the variable to red across the banner, chip,
+ * and frame in lockstep (one CSS variable, no parallel state).
+ */
+export declare function ImpersonationFrame(): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/layout/ImpersonationStartModal.impl.d.ts
+interface ImpersonationStartModalProps {
+  /** Open state controlled by the caller. */
+  open: boolean;
+  /** Target user the admin is about to impersonate. */
+  targetUserId: string;
+  targetUserLabel?: string;
+  /** Closes the modal without dispatching. Caller resets state. */
+  onClose: () => void;
+  /**
+   * Called after the start mutation succeeds. Useful for closing the
+   * modal and navigating; auth state is rehydrated by the hook itself.
+   */
+  onStarted?: () => void;
+}
+//#endregion
+//#region src/components/layout/ImpersonationStartModal.d.ts
+/**
+ * Reason modal for impersonation.start. Enforces a minimum reason
+ * length (server-side param impersonation.require_reason_min_length,
+ * default 10) before submitting. The "Duration" input is optional and
+ * is capped server-side by impersonation.max_duration.
+ */
+export declare function ImpersonationStartModal(props: ImpersonationStartModalProps): import("react").JSX.Element;
+//#endregion
+//#region src/api/auth.d.ts
+/**
+ * Impersonation client surface. Each call dispatches through
+ * POST /api/actions/{code} like every other auth handler. The server
+ * sets / clears the impersonation cookies via the LoginResult
+ * HTTPCustomizer; the client receives the public response shape
+ * (user / tenant / expires_at) and reloads the auth context.
+ */
+interface ImpersonationStartResponse extends LoginResponse {
+  impersonation_session_id: string;
+  session_expires_at: string;
+}
+//#endregion
+//#region src/hooks/useImpersonation.d.ts
+/**
+ * useImpersonation centralizes the three lifecycle calls (start, stop,
+ * revoke) and re-hydrates auth state on success so the topbar / banner /
+ * viewport frame react in lockstep.
+ *
+ * isImpersonating is derived from auth.me's impersonation field which the
+ * server populates only when the request was issued under an active
+ * impersonation session. Direct human action and agent flows (without an
+ * impersonation channel) leave it null.
+ */
+export declare function useImpersonation(): {
+  info: ImpersonationInfo | null;
+  isImpersonating: boolean;
+  start: import("@tanstack/react-query").UseMutateFunction<ImpersonationStartResponse, Error, {
+    targetUserId: string;
+    reason: string;
+    durationMinutes?: number;
+  }, unknown>;
+  stop: import("@tanstack/react-query").UseMutateFunction<LoginResponse, Error, void, unknown>;
+  revoke: import("@tanstack/react-query").UseMutateFunction<void, Error, string, unknown>;
+  isStarting: boolean;
+  isStopping: boolean;
+};
+//#endregion
+//#region src/components/layout/CommandPalette.impl.d.ts
+type CommandActionType = "nav" | "new" | "open" | "ai" | "ai-panel" | "theme" | "tab-close";
+interface CommandAction {
+  type: CommandActionType;
+  id?: string;
+  route?: string;
+  q?: string;
+  tabCloseScope?: TabCloseScope;
+}
+interface CommandPaletteProps {
+  open: boolean;
+  onClose: () => void;
+  onAction: (a: CommandAction) => void;
+  mode?: "default" | "new";
+  navigation?: NavNode[];
+  screens?: Record<string, Screen>;
+  includeAI?: boolean;
+  aiName?: string;
+}
+//#endregion
+//#region src/components/layout/CommandPalette.d.ts
+export declare function CommandPalette(props: CommandPaletteProps): import("react").JSX.Element;
+//#endregion
+//#region src/api/agents.d.ts
+type AgentRole = "user" | "assistant" | "tool" | "system";
+type AgentContentBlock = {
+  type: "text";
+  text: string;
+} | {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+} | {
+  type: "tool_result";
+  id: string;
+  name?: string;
+  output: unknown;
+  is_error?: boolean;
+} | {
+  type: "elicit";
+  id: string;
+  schema: Record<string, unknown>;
+  message: string;
+} | {
+  type: "elicit_response";
+  id: string;
+  data: Record<string, unknown>;
+} | {
+  type: "attachment";
+  kind: string;
+  content: string;
+} | {
+  type: "summary";
+  covers: string[];
+  text: string;
+} | {
+  type: "system";
+  reason: string;
+} | {
+  type: "location";
+  screen: string;
+  record?: string;
+} | {
+  type: "decision";
+  tool_use_id?: string;
+  tool_code: string;
+  decision: "approved" | "rejected";
+  decided_by?: string;
+  decided_at?: string;
+  note?: string;
+};
+interface AgentMessage {
+  id: string;
+  conversation_id: string;
+  seq: number;
+  role: AgentRole;
+  content: AgentContentBlock[];
+  created_at: string;
+  streaming?: boolean;
+}
+type AgentTurnStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "canceled";
+interface AgentTurn {
+  id: string;
+  conversation_id: string;
+  trigger_message_id: string;
+  runnable_message_seq: number;
+  status: AgentTurnStatus;
+  model_step: number;
+  reserved_assistant_message_id?: string | null;
+  error_code?: string | null;
+  error_details?: unknown;
+}
+type AgentInvocationStatus = "proposed" | "pending_input" | "pending_approval" | "approved" | "rejected" | "running" | "succeeded" | "failed" | "canceled" | "interrupted" | "outcome_unknown";
+type AgentInvocationKind = "action" | "input_request" | "tool";
+interface AgentToolInvocation {
+  id: string;
+  updated_at?: string;
+  conversation_id: string | null;
+  message_id: string | null;
+  kind: AgentInvocationKind;
+  turn_id: string | null;
+  assistant_message_id: string | null;
+  response_message_id: string | null;
+  provider_call_id: string | null;
+  call_ordinal: number | null;
+  server_code: string;
+  tool_code: string;
+  params: Record<string, unknown>;
+  requester_user_id: string;
+  real_user_id: string | null;
+  question?: {
+    key?: string;
+    message?: string;
+    schema?: Record<string, unknown>;
+  };
+  status: AgentInvocationStatus;
+  approval?: {
+    decided_by?: string;
+    decided_at?: string;
+    reason?: string;
+    edits?: Record<string, unknown>;
+  };
+  confirmation_mode?: "never" | "once_per_conversation" | "always";
+  result?: unknown;
+  audit_operation_id?: string;
+  reason?: string;
+  confidence?: number;
+}
+type AgentConversationStatus = "active" | "canceling" | "interrupted" | "closed";
+interface AgentConversation {
+  id: string;
+  tenant_id: string;
+  created_by?: string;
+  agent_id?: string;
+  agent?: string;
+  title?: string;
+  model?: string;
+  status: AgentConversationStatus;
+  token_usage?: {
+    in?: number;
+    out?: number;
+    cached_in?: number;
+  };
+}
+interface AvailableAgent {
+  id: string;
+  code: string;
+  name?: Record<string, string>;
+  description?: Record<string, string>;
+  is_default: boolean;
+}
+export declare function listAvailableAgents(): Promise<AvailableAgent[]>;
+export declare function createConversation(input: {
+  agent_id?: string;
+}): Promise<AgentConversation>;
+interface AgentMessageContext {
+  screen: string;
+  record?: string;
+}
+export declare function sendMessage(text: string, conversationId: string, context?: AgentMessageContext): Promise<AgentMessage>;
+export declare function answerQuestion(invocationId: string, answer: Record<string, unknown>): Promise<void>;
+export declare function sendElicitResponse(_conversationId: string, invocationId: string, data: Record<string, unknown>): Promise<void>;
+/** What a person permitted: this call alone, or the action for the rest of
+ *  the conversation. Absent means this call alone - the safe reading, and
+ *  what every row written before the choice existed means. */
+type ApprovalScope = "call" | "conversation";
+export declare function approveInvocation(id: string, scope?: ApprovalScope): Promise<void>;
+export declare function rejectInvocation(id: string, note?: string): Promise<void>;
+export declare function cancelInvocation(id: string): Promise<void>;
+export declare function cancelConversation(id: string): Promise<void>;
+export declare function listConversations(): Promise<AgentConversation[]>;
+export declare function loadConversationTurns(conversationId: string): Promise<AgentTurn[]>;
+export declare function loadConversationInvocations(conversationId: string): Promise<AgentToolInvocation[]>;
+export declare function loadHistory(conversationId: string): Promise<AgentMessage[]>;
+//#endregion
+//#region src/components/agents/AgentChatPanel.impl.d.ts
+interface AgentChatPanelProps {
+  open: boolean;
+  onClose: () => void;
+  /** The screen the person is on, sent with each message. */
+  context?: AgentMessageContext;
+  title?: string;
+  /** A question typed somewhere else - the command palette - to send once
+   *  the panel opens. The palette promises "Press Enter to ask"; without
+   *  this it opened the panel and threw the question away. */
+  askOnOpen?: string;
+  docked?: boolean;
+}
+//#endregion
+//#region src/components/agents/AgentChatPanel.d.ts
+export declare function AgentChatPanel(props: AgentChatPanelProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/agents/AgentElicitForm.d.ts
+type JSONSchemaProp = {
+  type?: string | string[];
+  enum?: unknown[];
+  format?: string;
+  minimum?: number;
+  maximum?: number;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  items?: {
+    enum?: unknown[];
+    type?: string;
+  };
+};
+interface JSONSchema {
+  type?: string;
+  properties?: Record<string, JSONSchemaProp>;
+  required?: string[];
+}
+interface AgentElicitFormProps {
+  message: string;
+  schema: JSONSchema;
+  onSubmit: (data: Record<string, unknown>) => void;
+  onCancel?: () => void;
+}
+export declare function AgentElicitForm({ message, schema, onSubmit, onCancel }: AgentElicitFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/agents/AgentPicker.d.ts
+interface AgentPickerProps {
+  agents: AvailableAgent[];
+  selectedId?: string;
+  onSelect: (id: string) => void;
+  label: string;
+}
+export declare function AgentPicker({ agents, selectedId, onSelect, label }: AgentPickerProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/agents/AgentConversationDrawer.d.ts
+interface AgentConversationDrawerProps {
+  open: boolean;
+  onClose: () => void;
+  conversations: AgentConversation[];
+  activeId?: string;
+  onSelect: (id: string) => void;
+  onNew: () => void;
+  onRefresh: () => Promise<void>;
+}
+export declare function AgentConversationDrawer({ open, onClose, conversations, activeId, onSelect, onNew, onRefresh }: AgentConversationDrawerProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/hooks/useAgentConversation.d.ts
+interface AgentTurnState {
+  streaming: boolean;
+}
+export declare function useAgentConversation(initialConversationId?: string): {
+  conversationId: string | undefined;
+  messages: AgentMessage[];
+  turn: AgentTurnState;
+  turns: AgentTurn[];
+  invocations: AgentToolInvocation[];
+  conversations: AgentConversation[];
+  send: (text: string, context?: AgentMessageContext) => Promise<void>;
+  approve: (invocationId: string, scope?: ApprovalScope) => Promise<void>;
+  reject: (invocationId: string, note?: string) => Promise<void>;
+  submitInput: (invocationId: string, data: Record<string, unknown>) => Promise<void>;
+  cancelInput: (invocationId: string) => Promise<void>;
+  cancel: () => Promise<void>;
+  refreshConversations: () => Promise<void>;
+  startNew: () => void;
+  agents: AvailableAgent[];
+  selectedAgentId: string | undefined;
+  selectAgent: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+  setConversationId: (id: string | undefined) => void;
+};
+//#endregion
+//#region src/lib/filter-evaluator.d.ts
+/** Metadata needed to evaluate a record-only filter condition. */
+interface FilterRecordField {
+  type: "string" | "text" | "rich_text" | "email" | "url" | "phone" | "enum" | "int" | "float" | "decimal" | "date" | "timestamp" | "time" | "bool" | "ref" | "uuid" | (string & {});
+}
+type FilterRecordFields = Readonly<Record<string, FilterRecordField>>;
+type FilterRecord = Readonly<Record<string, unknown>>;
+/**
+ * Evaluate a loader-validated filter tree against one already-loaded record.
+ *
+ * This deliberately accepts only the deterministic record subset: it has no
+ * caller, clock, relation lookup, or value coercion input. A missing field is
+ * the same as null for `is_empty`; every other operator returns false for a
+ * missing, null, or empty value.
+ */
+export declare function evaluateFilterTree(nodes: FilterNode[], fields: FilterRecordFields, record: FilterRecord): boolean;
+//#endregion
+//#region src/lib/variants.d.ts
+export declare function resolveEntityVariantCode(entity: Entity, record: FilterRecord): string | undefined;
+export declare function variantActionCodesForRecord(entity: Entity | undefined, record: FilterRecord): ReadonlySet<string> | undefined;
+export declare function commonVariantActionCodes(entity: Entity | undefined, records: readonly FilterRecord[]): ReadonlySet<string> | undefined;
+export declare function resolveScreenVariantCode(entity: Entity, screen: Screen, record: FilterRecord): string | undefined;
+export declare function effectiveScreenForRecord(entity: Entity | undefined, screen: Screen | undefined, record: FilterRecord): Screen | undefined;
+//#endregion
+//#region src/lib/format-count.d.ts
+/**
+ * Row-count formatting for list views. Display precision MUST match data
+ * accuracy:
+ *
+ *   - an exact count renders to the unit with thousands separators
+ *     (3,613,711) - it is known precisely;
+ *   - an estimate renders coarse (~3.6M) - showing an estimate to the unit
+ *     is false precision and is wrong.
+ *
+ * This is the single shared count formatter; the SDK has no other. Field
+ * cell factories that call `toLocaleString` for per-cell numbers are a
+ * separate concern and are not routed through here.
+ */
+/**
+ * formatEstimatedCount renders a coarse estimate: a `~` prefix, ~2
+ * significant figures, and the magnitude suffix of Intl compact notation in
+ * `language` (K/M/B in English, "mil"/"M" in Spanish, "тыс."/"млн" in Russian).
+ *
+ *   3_613_711 -> "~3.6M"
+ *     850_000 -> "~850K"
+ *      12_000 -> "~12K"
+ *         940 -> "~940"   (below 1000: no suffix, the ~ still signals an estimate)
+ *
+ * Two significant figures: a value's first 2 digits are kept and the rest
+ * collapse to the magnitude suffix. 3_613_711 -> 3.6M (one decimal because
+ * the leading digit is single); 12_000 -> 12K (no decimal because 2 leading
+ * digits already give 2 sig figs).
+ */
+export declare function formatEstimatedCount(total: number, language?: string): string;
+/**
+ * formatExactCount renders an exact count to the unit with the thousands
+ * separators of `language`: 3613711 -> "3,613,711" in English.
+ */
+export declare function formatExactCount(total: number, language?: string): string;
+/**
+ * formatCount picks the rendering by the count strategy actually used to
+ * produce `total` (the server's `meta.count_mode`), NOT the entity schema:
+ * a forced exact count must render exact even on a `count: estimated`
+ * entity.
+ */
+export declare function formatCount(total: number, mode: "exact" | "estimated", language?: string): string;
+//#endregion
+//#region src/lib/mass-edit.d.ts
+/** Target kinds mirror engine.MassEditTargetKind in Go. */
+type MassEditTargetKind = "field" | "status" | "property";
+/** Metadata a property-grid row needs to render a target + editable value cell. */
+interface MassEditTarget {
+  /** Picker key — bare field code, or `$status.<group>` / `$property.<code>`. */
+  code: string;
+  /** Bare identifier (without prefix) — "priority", "approval", "color". */
+  bare: string;
+  kind: MassEditTargetKind;
+  label: string;
+  /** For field targets, the underlying EntityField drives the value renderer. */
+  field?: EntityField;
+  /** For status targets, the group definition drives the status-picker options. */
+  statusGroup?: StatusGroupDef;
+  /** For property targets, the property definition drives type/widget/ref. */
+  property?: PropertyDef;
+}
+/** Parse `HandlerParam.Filter["targets"]` into a list of allowed keys. */
+export declare function parseTargetFilter(raw: string | undefined): string[];
+/**
+ * Build the list of writable mass-edit targets for an entity.
+ * - When `whitelist` is set, narrows to those keys only (preserves the
+ *   order in the whitelist so action authors can curate a picker order).
+ * - Without a whitelist, emits every non-PK, non-auto field plus all
+ *   status groups and properties (when not composite PK). Matches the
+ *   engine-side BuildMassEditTargets contract.
+ * - entities without generic update globally hide every target (UI mirrors
+ *   the server gate; the dispatcher still enforces permissions).
+ */
+export declare function buildMassEditTargets(t: TextFn, entity: Entity | undefined, whitelistRaw?: string | string[]): MassEditTarget[];
+//#endregion
+//#region src/components/actions/PropertyGridEditor.d.ts
+/** Raw patch shape: field codes + optional $statuses / $properties subresource arrays. */
+type PatchMap = Record<string, unknown>;
+interface PropertyGridEditorProps {
+  entity: Entity | undefined;
+  /** Optional YAML-declared target whitelist (HandlerParam.Filter["targets"]). */
+  filterTargets?: string;
+  /** The current bulk selection. Used for same-value pre-fill per target. */
+  selectedRows?: ReadonlyArray<Record<string, unknown>>;
+  /** Current patch value (controlled). */
+  value: PatchMap;
+  /** Emitted whenever the user adds, changes, or removes a target. */
+  onChange: (next: PatchMap) => void;
+}
+/** UI-only marker for cells whose selected rows disagree on the current value. */
+declare const MULTIPLE_VALUES: unique symbol;
+export declare function PropertyGridEditor({ entity, filterTargets, selectedRows, value, onChange }: PropertyGridEditorProps): import("react").JSX.Element;
+export declare function detectCommonValue(target: MassEditTarget, selectedRows: ReadonlyArray<Record<string, unknown>> | undefined): unknown;
+//#endregion
+//#region src/lib/field-classification.d.ts
+/**
+ * isFieldReadable returns true when the caller can see the field's
+ * value. Non-classified fields are always readable (no entry in
+ * field_access). Classified fields are readable when field_access
+ * marks read="granted".
+ */
+export declare function isFieldReadable(entity: Pick<Entity, "field_access"> | undefined, fieldName: string): boolean;
+/**
+ * isFieldWritable returns true when the caller can submit a new value
+ * for the field. Form components disable input + show a lock badge
+ * when this returns false. Non-classified fields are always writable
+ * (gating happens via entity-level RBAC at the HTTP layer).
+ */
+export declare function isFieldWritable(entity: Entity | undefined, fieldName: string): boolean;
+/**
+ * fieldClassification returns the classification tier code gating
+ * the field, or undefined when the field is non-classified. Lets
+ * UI code render a tier badge without re-implementing the field_access
+ * lookup.
+ */
+export declare function fieldClassification(entity: Entity | undefined, fieldName: string): string | undefined;
+/**
+ * fieldRequiredPermission returns the exact grant string an
+ * administrator must add to a role to unlock the field for the
+ * current caller. Returns undefined when the field is readable +
+ * writable (no hint needed).
+ */
+export declare function fieldRequiredPermission(entity: Entity | undefined, fieldName: string): string | undefined;
+/**
+ * classificationTier returns the localized tier metadata for a field
+ * (display name, description, audit_on_read flag, icon). Resolves
+ * via the top-level schema.classifications map. Returns undefined when
+ * the field is non-classified or the tier code is unknown in the
+ * catalog (defense — points at a misconfigured registry).
+ */
+export declare function classificationTier(schema: Schema | undefined, entity: Entity | undefined, fieldName: string): ClassificationTierDef | undefined;
+/**
+ * isFieldSoDProtected reports whether the field's tier carries
+ * sod_protected:true in the catalog. Used by UI to surface a stronger
+ * visual treatment (e.g. red lock vs. grey lock) for tiers that
+ * trigger the stricter SoD controls (superadmin-bypass-disabled
+ * tenants, role self-assignment refusal, etc).
+ */
+export declare function isFieldSoDProtected(schema: Schema | undefined, entity: Entity | undefined, fieldName: string): boolean;
+/**
+ * fieldAccessInfo returns the raw FieldAccessInfo entry for a field,
+ * or undefined when the field is non-classified. Convenience for
+ * components that need the full structure (e.g. a tooltip rendering
+ * both classification name + required_permission hint).
+ */
+export declare function fieldAccessInfo(entity: Entity | undefined, fieldName: string): FieldAccessInfo | undefined;
+//#endregion
+export { type Action, ActionBatchError, type ActionExecuteRequest, type ActionExecuteResponse, type ActionItemError, type ActionItemSkip, type ActionListPage, type AgentChatPanelProps, type AgentContentBlock, type AgentConversation, type AgentConversationDrawerProps, type AgentConversationStatus, type AgentElicitFormProps, type AgentInvocationKind, type AgentInvocationStatus, type AgentMessage, type AgentPickerProps, type AgentRole, type AgentToolInvocation, type AgentTurn, type AgentTurnState, type AgentTurnStatus, type ApiError, App as Declarion, type ApprovalScope, type AuthShellProps, type AuthUser, type AvailableAgent, type AvatarProps, type BatchOp, type BatchOpResult, type BatchResponse, type BoolToggleProps, type BrandGlyphProps, type BreadcrumbsProps, type BtnKind, type BtnProps, type BtnSize, CURSOR_LANGUAGE_CHANGED, CURSOR_SEMANTICS_MISMATCH, type CanonicalLocation, type ChangePasswordDialogProps, type CheckProps, type CheckSetupResponse, type ChildRelation, type ChipProps, type ClassificationTierDef, type CommandAction, type CommandActionType, type CommandPaletteProps, type CropperOptions, type CropperResult, type Crumb, type CurrentScreen, type CursorActionDataResult, type CursorEntityDataParams, type CursorEntityDataResult, type CustomScreenProps, DEFAULT_RESPONSIVE_BREAKPOINTS, type DataResponse, type DateInputProps, type DraftEntry, type DropdownProps, DynamicIcon, type EnrichedRow, type Entity, type EntityField, type EnumDef, type FieldAccessInfo, type FieldLabelProps, type FileDraftScopeApi, type FileFieldDef, type FileFieldDisplay, type FileFieldMode, type FileWidget, type FileWidgetProps, type FilterNode, type FilterOp, type FilterRecord, type FilterRecordField, type FilterRecordFields, type FilterURLState, type HoverCardAlign, type HoverCardProps, type HydratedFile, Icon, type IconBtnProps, type IconDef, type IconName, type IconProps, type ImageCropper, type InfoTooltipProps, type InlineEditCellProps, type InlineEditKind, type InlineEditTrigger, type JsonFieldProps, type LanguageDef, type LayoutWidget, type LayoutWidgetProps, type ListMeta, type ListParams, type ListResponse, type LiveObjectResult, type LocalizedString, type LoginResponse, MANDATORY_LANGUAGE, MULTIPLE_VALUES, type MassEditTarget, type MassEditTargetKind, type MenuItemProps, type MultiSelectProps, NO_VALUE_OPS, type NavNode, OP_LABELS, type ObjectActionBarProps, type ObjectActionBarSlot, type ObjectActionSelection, OrderedMap, type PageStateSetter, type ParameterDef, type PasswordInputProps, type PatchMap, type PillProps, type PillSize, type PillTone, type PkValues, type PropertyDef, type PropertyValue, type PublicParam, type QEFieldProps, type QuickEditCellProps, type QuickPeekFieldSpec, type QuickPeekProps, type RailAreaItem, type RailProps, type RecordIdBadgeProps, type RefComboboxProps, type RefFieldItem, type RefFieldProps, type RefreshControlProps, type Refs, type ResponsiveBreakpoints, type ResponsiveMode, ResponsiveModeProvider, type ResponsiveViewport, type ReturnTarget, type RowFieldProps, type RowHelpers, type RunActionOptions, type Schema, type Screen, type ScreenBack, type ScrollAnchor, type ScrollableVirtualizer, type SectionBadge, type SectionCardProps, type SectionEmphasis, type SelectOption, type SelectProps, type SidebarProps, type StatusDef, type StatusGroupDef, type StatusInfo, type StructureDef, type TabItem, type TabStripProps, type TagsInputProps, type Tenant, type TenantChipProps, type TextAreaProps, type TextFn, type TextInputProps, type TextVars, type TooltipProps, type TopBarProps, type UploadCheck, type UploadProgress, type UploadedFile, type UseObjectActionsResult, type UseScreenBackOptions, type UseScreenTabOptions, type V2ListParams, type V2ListResponse, type V2Meta, type V2ParamInstance, type V2PropertyInstance, type V2StatusInstance, type ViewFieldProps, type ViewportCategory, buildActionBody, buildDetailHrefFromId, buildEntityDetailHref, buildRowDetailHref, countActiveFilters, deleteObject, executeAction$1 as executeAction, extractPkValues, fieldDisplayName, getIcon, getPrimaryKeyFields, hasOrGroups, isCursorStaleError, makeTextFn, parseFilterURLState, parseFiltersFromURL, pickLocalized, pkValuePartsToId, pkValuesFromId, pkValuesToDetailId, pkValuesToId, pluralText, resolveDetailRoute, resolveViewportCategory, restoreObject, setFiltersInURL, setIconRegistry, textWithNodes, useLocation, useNavigate, useParams, useResponsiveMode, useSearchParams };