@ai-matrx/records-ui 0.3.1

package/dist/index.d.cts

@@ -0,0 +1,1117 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Uuid as Uuid$1, Table, RecordsError, Field as Field$1, RecordDocument, ValueEnvelope, ParityFieldType, ReadRow as ReadRow$1, RuleExpression, AggregateBucket, AggregateMeasure, DocTemplateRow, DocRenderRow, AnonTokenBinding, RecordsConfig, RecordsActor, RecordsDataSource } from '@ai-matrx/records';
+import { Uuid, Field, ReadRow } from '@ai-matrx/records/react';
+import { MatrxColumnDef } from '@ai-matrx/design-system/data-table/types';
+import { RecordsClient } from '@ai-matrx/records/core';
+
+/** One named piece of grounding, shaped the way the platform's context slice takes them. */
+interface RecordChatEntry {
+    key: string;
+    value: unknown;
+    label: string;
+    /** `text` for a scalar, `json` for a structure. The host maps this to its own vocabulary. */
+    type: "text" | "json";
+}
+/** A Field the STORE masked for this reader, named rather than silently dropped. */
+interface RecordChatWithheld {
+    key: string;
+    label: string;
+    /** The store's own reason. */
+    reason: string;
+}
+/** Everything the host's chat surface needs, and nothing about how it should look. */
+interface RecordChatContext {
+    /**
+     * A unique key per mounted conversation. Two record panels open at once must
+     * not fight over focus, so this is derived from the record and never a
+     * constant.
+     */
+    surfaceKey: string;
+    tableId: Uuid;
+    recordId: Uuid;
+    tableName: string;
+    /** The record's own title, for the panel's one-row header and the chip. */
+    title: string;
+    /** The grounding, already read through the read door. */
+    entries: RecordChatEntry[];
+    /** What this reader is NOT being given, with the store's reason for each. */
+    withheld: RecordChatWithheld[];
+}
+declare const NO_CHAT_REASON: string;
+interface RecordChatProps {
+    tableId: Uuid;
+    recordId: Uuid;
+    className?: string | undefined;
+}
+declare function RecordChat({ tableId, recordId, className }: RecordChatProps): react.JSX.Element;
+
+/** What the host is asked to have the server's `records` tool do. */
+interface EnrichAsk {
+    tableId: Uuid;
+    recordId: Uuid;
+    /** The agent Fields to refill, each with why this panel thinks it is due. */
+    fields: Array<{
+        key: string;
+        label: string;
+        because: string;
+    }>;
+}
+interface EnrichOutcome {
+    ok: boolean;
+    /** What happened, in a sentence — the server's own words when it has some. */
+    message: string;
+}
+declare const NO_ENRICH_REASON: string;
+interface EnrichPanelProps {
+    tableId: Uuid;
+    recordId: Uuid;
+    className?: string | undefined;
+}
+declare function EnrichPanel({ tableId, recordId, className }: EnrichPanelProps): react.JSX.Element;
+
+/** What a person may do to one table. The words are the store's, not ours. */
+interface TableRights {
+    /** SCR-2: holders of `admin` on the table see the "+" and the settings panel. */
+    admin: boolean;
+    /** SCR-18: `commenter` and no higher right. */
+    comment: boolean;
+    /** May write records at all. */
+    write: boolean;
+    /**
+     * Why this answer, in a sentence a person can read. Never empty: a right that
+     * is false without a reason is the silent failure this package refuses.
+     */
+    reason: string;
+}
+declare const NO_RIGHTS: TableRights;
+interface RecordsUiHost {
+    /** Answer the rights question for one table. Synchronous: a screen renders now. */
+    rights?: (table: Table) => TableRights;
+    /** Where a record's own page lives, when the host has one. A peek is used when it does not. */
+    hrefForRecord?: (args: {
+        table: Table;
+        recordId: Uuid$1;
+    }) => string | undefined;
+    /** The host's own link element, so routing stays the host's business. */
+    Link?: (props: {
+        href: string;
+        children: ReactNode;
+        className?: string;
+    }) => ReactNode;
+    /** Toasts. Absent means the screen shows the sentence inline instead — never silence. */
+    notify?: {
+        success: (message: string) => void;
+        error: (message: string) => void;
+    };
+    /** Density for every table this package renders. */
+    density?: "condensed" | "normal" | "spacious";
+    /**
+     * OPTIONAL. Where a file a person attached actually goes. A File is a record
+     * in the kernel File Table (REC-31), but the BYTES are the host's file
+     * service, not this package's business — so this is a port.
+     *
+     * Unbound, an attachment question does NOT draw a file chooser that quietly
+     * loses the file: it says, in one sentence, that no file store is bound and
+     * names this port. Absent or honest, never dead.
+     */
+    upload?: (file: File) => Promise<{
+        ok: true;
+        fileId: Uuid$1;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    /**
+     * OPTIONAL. The organization's saved views as `platform.saved_view` holds
+     * them — which is what a subscription points at (DOOR-18). The record store
+     * has NO door onto that table, because it is the platform's and not the
+     * store's, so this is a port rather than a read this package invents.
+     *
+     * Unbound, `NotifyRuleEditor` shows the subscriptions that exist and says, in
+     * one sentence, that it cannot offer a view to subscribe to. It never renders
+     * an empty picker that looks like "you have no views".
+     */
+    savedViews?: () => Promise<Array<{
+        id: Uuid$1;
+        name: string;
+    }>>;
+    /**
+     * OPTIONAL. THE HOST'S OWN CHAT SURFACE (SCR-26).
+     *
+     * This package ships no chat UI, on purpose: AI Matrx has exactly one, it
+     * lives in matrx-frontend (`AgentConversationColumn`), and it reads that app's
+     * Redux store — so a second one here would drift within a month and a package
+     * that imported the first would stop being a package. `RecordChat` therefore
+     * builds the CONTEXT (the record, through the read door, with the masked
+     * fields named) and hands it to this port.
+     *
+     * Unbound, the panel is ABSENT with that reason, never a composer that goes
+     * nowhere.
+     */
+    chat?: (context: RecordChatContext) => ReactNode;
+    /**
+     * OPTIONAL. THE SERVER'S `records` TOOL (SCR-27).
+     *
+     * An AI fill must be written with actor `agent` on behalf of the person, and
+     * only the server can honestly say that — a browser stamping itself `agent`
+     * is a browser claiming to be one. So `EnrichPanel` asks here, and the host
+     * calls the server's own `records` tool (`action: "record_write"`), which
+     * stamps `_actor` and `_on_behalf_of` itself.
+     *
+     * Unbound, no Fill control is drawn at all and the reason names this port.
+     */
+    enrich?: (ask: EnrichAsk) => Promise<EnrichOutcome>;
+    /**
+     * OPTIONAL. WHERE AN OFFLINE CAPTURE WAITS (SCR-30).
+     *
+     * `CaptureSheet` mints the id for a capture BEFORE it tries to send it, so a
+     * phone with no signal has already decided what the write will be called.
+     * Where that queue physically lives is the host's business — IndexedDB in a
+     * browser, a file in a desktop app — so it is a port. Unbound, the sheet
+     * keeps its queue in memory for the life of the page AND SAYS SO, because a
+     * queue that silently died with the tab is the failure this exists to avoid.
+     */
+    captureQueue?: CaptureQueuePort;
+}
+/** The durable half of offline capture: read the queue, write it, that is all. */
+interface CaptureQueuePort {
+    load: () => Promise<PendingCapture[]>;
+    save: (pending: PendingCapture[]) => Promise<void>;
+}
+/** One capture waiting to be written, with the id the CLIENT minted for it. */
+interface PendingCapture {
+    /**
+     * The client key. Minted offline, before the first attempt, and never
+     * re-minted on retry — that is exactly what lets the store's replay ledger
+     * tell a retry from a second capture.
+     */
+    clientKey: string;
+    tableId: Uuid$1;
+    payload: Record<string, unknown>;
+    capturedAt: string;
+    device: string;
+    /** How many times sending has been tried, and what the store last said. */
+    attempts: number;
+    lastRefusal?: string | null;
+}
+/** The sentence the notify editor shows when no saved-view port is bound. */
+declare const NO_SAVED_VIEWS_REASON: string;
+/** The sentence an attachment question shows when no file store is bound. */
+declare const NO_UPLOAD_REASON: string;
+declare function RecordsUiProvider({ value, children }: {
+    value: RecordsUiHost;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useRecordsUi(): RecordsUiHost;
+/** The rights for one table — `NO_RIGHTS`, with its reason, when nothing is bound. */
+declare function useTableRights(table: Table | null | undefined): TableRights;
+
+declare function RefusalNotice({ error, className, actions, }: {
+    error: RecordsError;
+    className?: string | undefined;
+    actions?: ReactNode | undefined;
+}): react.JSX.Element;
+/** A small inline one, for a cell or a field where a block would break the layout. */
+declare function RefusalLine({ error, className }: {
+    error: RecordsError;
+    className?: string | undefined;
+}): react.JSX.Element;
+
+interface GridProps {
+    tableId: Uuid;
+    /** Rows per page. The table's own pagination handles the rest. */
+    pageSize?: number | undefined;
+    /** Opened when a row is clicked. A host that has a record page passes its own. */
+    onOpenRecord?: ((recordId: Uuid) => void) | undefined;
+    /** SCR-2. Called when an admin clicks the "+" at the end of the headers. */
+    onAddField?: (() => void) | undefined;
+    /** Extra toolbar content — the view switcher, the export menu, the view bar. */
+    toolbarActions?: ReactNode | undefined;
+    className?: string | undefined;
+}
+declare function Grid({ tableId, pageSize, onOpenRecord, onAddField, toolbarActions, className, }: GridProps): react.JSX.Element;
+/** One Field becomes one column. The header is the Field's label; the cell is the value, rendered by its parity type. */
+declare function columnForField(field: Field): MatrxColumnDef<ReadRow>;
+
+interface ExportMenuProps {
+    tableId: Uuid;
+    /** The rows on screen. Absent means "this table's first page", read the same way. */
+    rows?: ReadRow[] | undefined;
+    /** What the file is called. The table's name by default. */
+    label?: string | undefined;
+    className?: string | undefined;
+}
+declare function ExportMenu({ tableId, rows, label, className }: ExportMenuProps): react.JSX.Element;
+
+interface ImportWizardProps {
+    tableId: Uuid;
+    /** SCR-N-7: what "add this as a field" does. Absent means the offer is not made. */
+    onProposeField?: ((header: string) => void) | undefined;
+    onDone?: ((written: number) => void) | undefined;
+    className?: string | undefined;
+}
+declare function ImportWizard({ tableId, onProposeField, onDone, className }: ImportWizardProps): react.JSX.Element;
+
+interface CustomFieldsSectionProps {
+    /**
+     * The Table the Fields extend. For a standard entity this is the Table record
+     * that stands for that entity — the host passes it, because which entity a
+     * page is showing is the page's own fact.
+     *
+     * A page that knows the entity's TOKEN rather than its id passes `entityToken`
+     * instead, and this section resolves it: an entity page must not have to run
+     * a lookup of its own to add one line.
+     */
+    tableId?: Uuid | undefined;
+    /** The entity's registered token (REC-33), e.g. `party`. Resolved to its Table. */
+    entityToken?: string | undefined;
+    recordId: Uuid;
+    /** The heading. One row, no subtitle restating it. */
+    title?: string | undefined;
+    className?: string | undefined;
+}
+declare function CustomFieldsSection({ tableId, entityToken, recordId, title, className, }: CustomFieldsSectionProps): react.JSX.Element | null;
+
+interface FieldEditorProps {
+    tableId: Uuid$1;
+    /** The Field being edited. Absent means a new one. */
+    field?: Field$1 | undefined;
+    onSaved?: (() => void) | undefined;
+    onCancel?: (() => void) | undefined;
+    className?: string | undefined;
+}
+declare function FieldEditor({ tableId, field, onSaved, onCancel, className }: FieldEditorProps): react.JSX.Element;
+
+interface FieldProposalRow {
+    id: string;
+    /** What the agent proposed, in the Field shape the store would store. */
+    field: Partial<Field> & {
+        key: string;
+        label?: string;
+    };
+    why: string;
+    proposed_by: string;
+}
+interface TableSettingsProps {
+    tableId: Uuid;
+    /**
+     * SCR-5. Pending field proposals. The door that lists them
+     * (`custom.field_propose`) does not exist yet — `@ai-matrx/records` answers
+     * `door_absent` by name for it — so a host passes what it has, and when it
+     * has nothing the section says so rather than pretending there is nothing to
+     * approve.
+     */
+    proposals?: FieldProposalRow[] | undefined;
+    onAcceptProposal?: ((proposal: FieldProposalRow) => void) | undefined;
+    onRejectProposal?: ((proposal: FieldProposalRow) => void) | undefined;
+    className?: string | undefined;
+}
+declare function TableSettings({ tableId, proposals, onAcceptProposal, onRejectProposal, className, }: TableSettingsProps): react.JSX.Element;
+
+interface PeekProps {
+    tableId: Uuid;
+    recordId: Uuid;
+    onClose?: (() => void) | undefined;
+    className?: string | undefined;
+}
+declare function Peek({ tableId, recordId, onClose, className }: PeekProps): react.JSX.Element;
+
+interface RecordFormProps {
+    tableId: Uuid;
+    /** Absent means "create". Present means "edit that record". */
+    recordId?: Uuid | undefined;
+    /** FLD-10: which Fields apply is the store's decision, and it takes the record type. */
+    recordType?: string | undefined;
+    onSaved?: ((recordId: Uuid) => void) | undefined;
+    onCancel?: (() => void) | undefined;
+    className?: string | undefined;
+}
+declare function RecordForm({ tableId, recordId, recordType, onSaved, onCancel, className, }: RecordFormProps): react.JSX.Element;
+
+interface RelationPickerProps {
+    field: Field$1;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    disabled?: boolean | undefined;
+    id?: string | undefined;
+    className?: string | undefined;
+}
+declare function RelationPicker({ field, value, onChange, disabled, id, className }: RelationPickerProps): react.JSX.Element;
+
+interface FieldEditorControlProps {
+    field: Field$1;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    disabled?: boolean | undefined;
+    id?: string | undefined;
+}
+/** The label row every editor shares: one line, the label, the unit, the required mark. */
+declare function FieldLabel({ field, htmlFor, children }: {
+    field: Field$1;
+    htmlFor: string;
+    children?: ReactNode;
+}): react.JSX.Element;
+declare function FieldControl({ field, value, onChange, disabled, id }: FieldEditorControlProps): react.JSX.Element;
+/** The chip a picked record shows as — REC-2's "a record is a chip" in one place. */
+declare function RecordChip({ title, onRemove, className, }: {
+    title: string;
+    onRemove?: (() => void) | undefined;
+    className?: string | undefined;
+}): react.JSX.Element;
+
+/** The envelope for one key, when the document carries one. */
+declare function envelopeFor(document: RecordDocument | undefined, key: string): ValueEnvelope | undefined;
+declare function renderValue(field: Field$1, value: unknown, document?: RecordDocument): react.JSX.Element;
+/** The text of one scalar, with the Field's UNIT and FORMAT applied — FLD-N-1 says both change the MEANING. */
+declare function scalarText(field: Field$1, value: unknown): string;
+/** The provenance badge a value carries when the store interned a source for it (SCR-27). */
+declare function ProvenanceBadge({ document, fieldKey }: {
+    document: RecordDocument | undefined;
+    fieldKey: string;
+}): react.JSX.Element | null;
+
+declare const PARITY_LABEL: Record<ParityFieldType, string>;
+/** The "made of" sentence the store itself publishes, for the field editor's help text. */
+declare const PARITY_MADE_OF: Record<string, string>;
+/** Plain text and plain number are behaviours with no parity type of their own. */
+type EditorKind = ParityFieldType | "relation" | "text" | "number" | "boolean" | "date" | "long_text";
+/**
+ * Which editor one Field wants. Reads the Field's own declaration only — the
+ * behaviour, the modifiers, the format, the relation target and the config —
+ * because those are what the store stores, and a screen that guessed from a
+ * value would draw a different editor for an empty record.
+ */
+declare function editorKindFor(field: Field$1): EditorKind;
+/** The type word a person sees in a header or a settings row. */
+declare function fieldTypeLabel(field: Field$1): string;
+
+/** One Field of a package-owned Table, in the store's own words. */
+interface SystemFieldSpec {
+    key: string;
+    label: string;
+    /** FLD-1: one of the five behaviours. `text` covers the json-ish ones too. */
+    type: "text" | "range" | "list" | "relation" | "formula";
+    sort: number;
+    required?: boolean;
+    multi?: boolean;
+    config?: Record<string, unknown>;
+}
+interface SystemTableSpec {
+    /** The token this Table is addressed by. Every package table starts `records_ui_`. */
+    slug: string;
+    name: string;
+    labelSingular: string;
+    labelPlural: string;
+    titleField: string;
+    fields: SystemFieldSpec[];
+}
+/** Find this organization's copy of a package-owned Table, declaring it the first time. */
+declare function ensureSystemTable(client: RecordsClient, spec: SystemTableSpec): Promise<{
+    ok: true;
+    data: Uuid$1;
+} | {
+    ok: false;
+    error: RecordsError;
+}>;
+interface UseSystemTableState {
+    tableId: Uuid$1 | null;
+    loading: boolean;
+    error: RecordsError | null;
+}
+/** The hook every package-owned component opens with. */
+declare function useSystemTable(spec: SystemTableSpec): UseSystemTableState;
+
+/** The four ways one saved view can be looked at (SCR-6). */
+declare const VIEW_LAYOUTS: readonly ["grid", "kanban", "calendar", "gallery"];
+type ViewLayout = (typeof VIEW_LAYOUTS)[number];
+declare const LAYOUT_LABEL: Record<ViewLayout, string>;
+/**
+ * What each layout needs before it can draw anything, in one sentence a screen
+ * prints. A layout that is missing its Field says so instead of rendering an
+ * empty board that looks like "no records".
+ */
+declare const LAYOUT_NEEDS: Record<ViewLayout, string | null>;
+/** One sort clause. The Field's key and a direction; nothing else is a sort. */
+interface ViewSort {
+    field: string;
+    direction: "asc" | "desc";
+}
+/**
+ * THE DECLARATIVE SPEC. An agent writes this whole object; a person tweaks it.
+ * Every builder component in this package takes one of these as a prop.
+ */
+interface SavedViewSpec {
+    name: string;
+    /** The Table this view looks at. */
+    subject: Uuid$1;
+    layout: ViewLayout;
+    /** Kanban: the Field whose value becomes a column. */
+    groupField?: string | null;
+    /** Calendar: the Field that places a record in the month. */
+    dateField?: string | null;
+    /** Gallery: the Field shown large on the card. */
+    imageField?: string | null;
+    sorts?: ViewSort[];
+    /**
+     * The membership Rule. The STORE decides who is in this view; this is a
+     * reference to its Rule record, never a predicate this package evaluates.
+     */
+    ruleId?: Uuid$1 | null;
+    isDefault?: boolean;
+}
+/** A saved view as it comes back out of the store, with its record's own id. */
+interface SavedView extends SavedViewSpec {
+    id: Uuid$1;
+    /**
+     * The record's version AT LOAD, read from `custom.io_revisions` for the one
+     * record being edited. The read door answers documents and not versions, so
+     * this is null until it has been read — and a save with a null version is an
+     * ordinary last-writer-wins write, exactly as the store defines it.
+     */
+    version: number | null;
+}
+/** The package-owned Table every saved view is a record of. */
+declare const VIEW_TABLE: SystemTableSpec;
+/** The spec as the one document the store holds. */
+declare function viewDocument(spec: SavedViewSpec): Record<string, unknown>;
+/** One stored record back into the spec a screen and an agent both read. */
+declare function viewFromRecord(row: ReadRow$1): SavedView;
+
+interface ViewSwitcherProps {
+    /**
+     * THE DECLARATIVE SPEC — an agent writes the whole thing, a person tweaks it.
+     * `ViewBar` passes the saved view it loaded; a host with no saved views at all
+     * can pass a literal here and the switcher works.
+     */
+    view: SavedViewSpec;
+    /** Called when the person picks another layout, so the host can save it. */
+    onLayoutChange?: ((layout: ViewLayout) => void) | undefined;
+    onOpenRecord?: ((recordId: Uuid) => void) | undefined;
+    pageSize?: number | undefined;
+    className?: string | undefined;
+}
+/** The records this view holds: its Rule's members when it names one, the table otherwise. */
+declare function useViewRecords(view: SavedViewSpec, pageSize?: number): {
+    rows: ReadRow[];
+    loading: boolean;
+    error: RecordsError | null;
+    /** Where membership came from, in a sentence. A screen that hides this is hiding the view's meaning. */
+    membership: string;
+};
+declare function ViewSwitcher({ view, onLayoutChange, onOpenRecord, pageSize, className }: ViewSwitcherProps): react.JSX.Element;
+
+interface ViewBarProps {
+    /** The Table whose views these are. */
+    tableId: Uuid;
+    /** The view that is showing. Leave it out and the bar picks the default, then the first. */
+    activeViewId?: Uuid | null | undefined;
+    onActiveView?: ((view: SavedView) => void) | undefined;
+    /**
+     * COMPLETE DECLARATIVE SPECS an agent wrote. Any of these whose name this
+     * table does not have yet is saved as a record the first time the bar loads.
+     * The person tweaks them afterwards like any other view.
+     */
+    seed?: SavedViewSpec[] | undefined;
+    className?: string | undefined;
+}
+declare function ViewBar({ tableId, activeViewId, onActiveView, seed, className }: ViewBarProps): react.JSX.Element;
+
+/** One proposed change, in the proposer's words plus the exact act it asks for. */
+interface ProposedChange {
+    id: string;
+    act: "add" | "update" | "remove";
+    /** The Table the change lands in. */
+    table: Uuid;
+    /** The record it changes. Required for `update` and `remove`. */
+    record?: Uuid | undefined;
+    /** The document for `add`, or the patch for `update`. */
+    data?: Record<string, unknown> | undefined;
+    /** What this change is, in one line a person reads. */
+    label: string;
+    /** Why the proposer asks for it. Optional, and shown when it is there. */
+    why?: string | undefined;
+}
+type ProposalOutcome = {
+    settled: "accepted";
+    sentence: string;
+} | {
+    settled: "rejected";
+    sentence: string;
+} | {
+    settled: "refused";
+    sentence: string;
+};
+interface ProposalRowProps {
+    change: ProposedChange;
+    /** What already happened to this change, when the host remembers decisions. */
+    outcome?: ProposalOutcome | undefined;
+    /**
+     * The apply port. Left unbound, the row applies the change through the record
+     * store itself — the default that makes the component plug and play. A host
+     * whose proposals land somewhere else (a different store, a server lane)
+     * binds this and keeps the SAME row.
+     */
+    onApply?: ((change: ProposedChange) => Promise<ProposalOutcome>) | undefined;
+    onReject?: ((change: ProposedChange) => Promise<ProposalOutcome> | ProposalOutcome) | undefined;
+    /** Absent controls with this reason, instead of dead ones. */
+    readOnlyReason?: string | undefined;
+    onSettled?: ((outcome: ProposalOutcome) => void) | undefined;
+    className?: string | undefined;
+}
+declare function ProposalRow({ change, outcome, onApply, onReject, readOnlyReason, onSettled, className, }: ProposalRowProps): react.JSX.Element;
+
+/** The three things that land in the queue. One word each, closed. */
+declare const ACTION_KINDS: readonly ["approval", "assignment", "proposal"];
+type ActionKind = (typeof ACTION_KINDS)[number];
+/** The package-owned Table every queued action is a record of. */
+declare const ACTION_TABLE: SystemTableSpec;
+/**
+ * THE DECLARATIVE SPEC an agent writes. One `record_write` of this document puts
+ * a decision in front of a person — there is no per-feature approval plumbing
+ * anywhere in the platform.
+ */
+interface QueuedActionSpec {
+    kind: ActionKind;
+    title: string;
+    why?: string | undefined;
+    assignee?: Uuid | null | undefined;
+    subjectTable?: Uuid | null | undefined;
+    subject?: Uuid | null | undefined;
+    /** For a proposal: the exact acts being asked for. */
+    changes?: ProposedChange[] | undefined;
+}
+interface QueuedAction extends QueuedActionSpec {
+    id: Uuid;
+    /**
+     * The version this row was read at. The read door answers documents and not
+     * versions, so a queue row carries null and settling it is the store's
+     * ordinary last-writer-wins write — the row's own `status` is what a second
+     * settler then sees.
+     */
+    version: number | null;
+    status: "open" | "accepted" | "rejected" | "refused";
+    answer: string | null;
+    at: string;
+}
+declare function actionDocument(spec: QueuedActionSpec): Record<string, unknown>;
+interface ActionInboxProps {
+    /** Narrow the queue to one table's actions. Left out, it is everything waiting. */
+    tableId?: Uuid | null | undefined;
+    /** Show settled actions too. The default is what is still waiting. */
+    includeSettled?: boolean | undefined;
+    /**
+     * COMPLETE DECLARATIVE SPECS an agent wrote. Any of these the queue does not
+     * already hold (by title) is filed as a record on first load.
+     */
+    seed?: QueuedActionSpec[] | undefined;
+    onOpenRecord?: ((recordId: Uuid, tableId: Uuid) => void) | undefined;
+    className?: string | undefined;
+}
+declare function ActionInbox({ tableId, includeSettled, seed, onOpenRecord, className }: ActionInboxProps): react.JSX.Element;
+
+interface HistoryPanelProps {
+    tableId: Uuid;
+    recordId: Uuid;
+    className?: string | undefined;
+}
+declare function HistoryPanel({ tableId, recordId, className }: HistoryPanelProps): react.JSX.Element;
+
+/** The package-owned Table every comment is a record of. */
+declare const COMMENT_TABLE: SystemTableSpec;
+interface CommentThreadProps {
+    /** The Table the commented-on record belongs to — its rights decide the composer. */
+    tableId: Uuid;
+    /** The record being discussed. */
+    recordId: Uuid;
+    className?: string | undefined;
+}
+declare function CommentThread({ tableId, recordId, className }: CommentThreadProps): react.JSX.Element;
+
+/** How a form is put in front of a person. */
+declare const FORM_FLOWS: readonly ["one-at-a-time", "single-page"];
+type FormFlow = (typeof FORM_FLOWS)[number];
+/** One question. It ASKS FOR one Field of the subject Table — never its own column. */
+interface FormQuestionSpec {
+    /** The Field's key on the subject Table. */
+    field: string;
+    /** Ask it in the form's own words. Left out, the Field's own label is the question. */
+    ask?: string | null;
+    /** One line under the question. */
+    help?: string | null;
+    /** Override the Field's own `required`. Left out, the Field decides. */
+    required?: boolean | null;
+    /**
+     * CONDITIONAL LOGIC, AS A RULE. `{"op":"eq","args":[{"field":"<field id>"},{"const":"Yes"}]}`
+     * — the store answers it, this package never does. An UNDECIDED answer (the
+     * store's `null`, which is what an unanswered question gives) SHOWS the
+     * question: a person is never silently skipped past something.
+     */
+    showIf?: RuleExpression | null;
+}
+/** The look. Tokens, so light and dark both come out right without a second theme. */
+interface FormTheme {
+    /** A design-system accent class or a CSS color. Left out, the app's own accent. */
+    accent?: string | null;
+    align?: "left" | "center" | null;
+}
+/** THE COMPLETE DECLARATIVE SPEC. One `record_write` and the form exists. */
+interface FormSpec {
+    name: string;
+    /** The Table a submission lands in. */
+    subject: Uuid$1;
+    intro?: string | null;
+    questions: FormQuestionSpec[];
+    flow?: FormFlow | null;
+    theme?: FormTheme | null;
+    thankYou?: {
+        title: string;
+        body?: string | null;
+    } | null;
+    submitLabel?: string | null;
+    /**
+     * Is this form meant to be answerable by someone who is not signed in? The
+     * runner does NOT make that true by itself — it needs the anonymous write
+     * door, and until that door exists it says so BY NAME rather than writing as
+     * whoever happens to be signed in and calling it public.
+     */
+    isPublic?: boolean;
+}
+/** A form as it comes back out of the store, with its record's own id and version. */
+interface SavedForm extends FormSpec {
+    id: Uuid$1;
+    /**
+     * The record's version AT LOAD, read from `custom.io_revisions` for the one
+     * record being edited. The read door answers documents and not versions, so
+     * this is null until it has been read — and a save with a null version is an
+     * ordinary last-writer-wins write, exactly as the store defines it.
+     */
+    version: number | null;
+}
+/** The package-owned Table every form is a record of. */
+declare const FORM_TABLE: SystemTableSpec;
+/** The spec as the one document the store holds. */
+declare function formDocument(spec: FormSpec): Record<string, unknown>;
+/** One stored record back into the spec a screen and an agent both read. */
+declare function formFromRecord(row: ReadRow$1): SavedForm;
+/**
+ * THE SOURCE STAMP every submission carries. A record that arrived through a
+ * form is not indistinguishable from one somebody typed into the grid: it says
+ * which form, which version of it, when, and who was acting. `_source` is a
+ * stamp on the document beside the answers, so it travels with the record
+ * through export, History and the agent's context without a parallel table.
+ */
+declare function submissionStamp(args: {
+    formId: Uuid$1 | null;
+    formName: string;
+    actor: string;
+    onBehalfOf?: string | null;
+}): Record<string, unknown>;
+
+interface FormBuilderProps {
+    /** The Table this form collects into. A form is a view on a real Table. */
+    tableId: Uuid;
+    /**
+     * COMPLETE DECLARATIVE SPECS an agent wrote. Any of these whose name this
+     * table does not have yet is saved as a record the first time the builder
+     * loads. A seed whose name exists is LEFT ALONE — an agent re-running never
+     * overwrites what a person has since tweaked.
+     */
+    seed?: FormSpec[] | undefined;
+    activeFormId?: Uuid | null | undefined;
+    onActiveForm?: ((form: SavedForm) => void) | undefined;
+    className?: string | undefined;
+}
+declare function FormBuilder({ tableId, seed, activeFormId, onActiveForm, className }: FormBuilderProps): react.JSX.Element;
+
+/** The shapes a block can take. Closed: a shape nobody drew is not offered. */
+declare const CHART_KINDS: readonly ["bar", "column", "line", "donut", "number", "table"];
+type ChartKind = (typeof CHART_KINDS)[number];
+declare const CHART_KIND_LABEL: Record<ChartKind, string>;
+/** What each shape needs before it can draw, in one sentence a block prints. */
+declare const CHART_NEEDS: Record<ChartKind, string | null>;
+/** ONE BLOCK: the question and the shape, in one declarative object. */
+interface ChartSpec {
+    title: string;
+    /** The Table this block asks about. */
+    subject: Uuid$1;
+    kind: ChartKind;
+    /** Field keys whose values become the groups. */
+    groupBy?: string[];
+    /** A date Field truncated to a period — what a line runs along. */
+    bucket?: {
+        key: string;
+        by: AggregateBucket;
+    } | null;
+    /** `count` needs no key; every other measure reads one Field. */
+    measures?: AggregateMeasure[];
+    /** Equality only, and the store puts it in the SAME WHERE as visibility. */
+    filter?: Record<string, string>;
+    limit?: number;
+    /** How wide this block sits on the canvas, in twelfths. */
+    span?: number;
+}
+/** THE WHOLE DASHBOARD, as one object an agent writes in one call. */
+interface DashboardSpec {
+    name: string;
+    /** The Table most of its blocks are about. A block may name another. */
+    subject: Uuid$1;
+    blocks: ChartSpec[];
+}
+interface SavedDashboard extends DashboardSpec {
+    id: Uuid$1;
+    /**
+     * The record's version AT LOAD, read from `custom.io_revisions` for the one
+     * record being edited. The read door answers documents and not versions, so
+     * this is null until it has been read — and a save with a null version is an
+     * ordinary last-writer-wins write, exactly as the store defines it.
+     */
+    version: number | null;
+}
+/** The package-owned Table every dashboard is a record of. */
+declare const DASHBOARD_TABLE: SystemTableSpec;
+declare function dashboardDocument(spec: DashboardSpec): Record<string, unknown>;
+declare function dashboardFromRecord(row: ReadRow$1): SavedDashboard;
+/**
+ * The series palette. Six SEMANTIC tokens the design system already flips for
+ * dark mode, so a chart is correct in both themes without a second palette and
+ * without a hex code anywhere in this package.
+ */
+declare const SERIES_COLORS: readonly ["hsl(var(--primary))", "hsl(var(--info))", "hsl(var(--success))", "hsl(var(--warning))", "hsl(var(--destructive))", "hsl(var(--accent-foreground))"];
+/** The label one aggregate row carries — its groups, joined the way a person reads them. */
+declare function groupLabel(groups: Record<string, string | null>): string;
+
+/** The one token form, written the way the store's own pattern reads it. */
+declare function fieldToken(fieldId: Uuid$1): string;
+/** THE DECLARATIVE SPEC an agent writes. One template, whole, in one object. */
+interface DocTemplateSpec {
+    name: string;
+    /** The body, tokens and all. */
+    body: string;
+}
+/**
+ * A template written in terms of Field KEYS — which is how an agent thinks and
+ * how a person reads — turned into the store's id-based tokens. The agent writes
+ * `{{title}}`; what is stored points at the Field's id, so a rename never
+ * silently empties the document.
+ *
+ * A key this Table does not have is LEFT EXACTLY AS IT IS, so
+ * `custom.doc_unresolved_tokens` names it and the screen shows the store's own
+ * reason — it is never quietly deleted from the body.
+ */
+declare function bodyFromKeys(body: string, fields: Field$1[]): string;
+/** The reverse, for a person reading a stored body: ids shown as the Field's label. */
+declare function bodyForReading(body: string, fields: Field$1[]): string;
+/** VAL-10: a signature is a Value on a text Field whose format is `signature`. */
+declare function isSignatureField(field: Field$1): boolean;
+
+interface DocTemplateProps {
+    /** The Table these templates render. */
+    tableId: Uuid;
+    /** COMPLETE templates an agent wrote, in Field keys. Saved once, never overwritten. */
+    seed?: DocTemplateSpec[] | undefined;
+    activeTemplateId?: Uuid | null | undefined;
+    onActiveTemplate?: ((template: DocTemplateRow) => void) | undefined;
+    className?: string | undefined;
+}
+declare function DocTemplate({ tableId, seed, activeTemplateId, onActiveTemplate, className }: DocTemplateProps): react.JSX.Element;
+
+interface DocRenderProps {
+    templateId: Uuid;
+    recordId: Uuid;
+    /** A name for the file when somebody takes the PDF. */
+    filename?: string | undefined;
+    onRendered?: ((render: DocRenderRow) => void) | undefined;
+    className?: string | undefined;
+}
+declare function DocRender({ templateId, recordId, filename, onRendered, className }: DocRenderProps): react.JSX.Element;
+
+interface SignBlockProps {
+    tableId: Uuid;
+    recordId: Uuid;
+    /** The frozen version being signed. Without one there is nothing to seal. */
+    render: DocRenderRow | null;
+    className?: string | undefined;
+}
+declare function SignBlock({ tableId, recordId, render, className }: SignBlockProps): react.JSX.Element;
+
+/** THE DECLARATIVE SPEC an agent writes. One declaration and a person is told. */
+interface NotifyRuleSpec {
+    name: string;
+    savedViewId: Uuid;
+    /** `immediate` fires on the change; `digest` is collected and sent on a schedule. */
+    cadence?: string;
+    /** The digest's schedule, in the store's own words. Meaningless for `immediate`. */
+    schedule?: string | null;
+    channel?: string;
+    /** Who is told. Left out, the person setting it up — "tell ME". */
+    recipientUserId?: Uuid | null;
+    eventKey?: string;
+}
+interface NotifyRuleEditorProps {
+    /** The Table these subscriptions are about — the Rule's scope. */
+    tableId: Uuid;
+    /** COMPLETE declarative subscriptions an agent wrote. Saved once, never overwritten. */
+    seed?: NotifyRuleSpec[] | undefined;
+    className?: string | undefined;
+}
+declare function NotifyRuleEditor({ tableId, seed, className }: NotifyRuleEditorProps): react.JSX.Element;
+
+interface ChartBlockProps {
+    spec: ChartSpec;
+    className?: string | undefined;
+}
+declare function ChartBlock({ spec, className }: ChartBlockProps): react.JSX.Element;
+
+interface DashboardCanvasProps {
+    /** The Table these blocks are about. */
+    tableId: Uuid;
+    /** COMPLETE declarative dashboards an agent wrote. Saved once, never overwritten. */
+    seed?: DashboardSpec[] | undefined;
+    activeDashboardId?: Uuid | null | undefined;
+    className?: string | undefined;
+}
+declare function DashboardCanvas({ tableId, seed, activeDashboardId, className }: DashboardCanvasProps): react.JSX.Element;
+
+interface FormRunnerProps {
+    /** The complete spec. An agent wrote it; `FormBuilder` saved it; this runs it. */
+    form: FormSpec | SavedForm;
+    /** Preview mode answers the questions but writes nothing, and says so. */
+    preview?: boolean | undefined;
+    onSubmitted?: ((recordId: Uuid) => void) | undefined;
+    className?: string | undefined;
+}
+declare function FormRunner({ form, preview, onSubmitted, className }: FormRunnerProps): react.JSX.Element;
+
+/** THE COMPLETE DECLARATIVE SPEC — one object, one `record_write`, a whole checklist. */
+interface ChecklistSpec {
+    name: string;
+    /** The Table the steps become records in. */
+    subject: Uuid;
+    steps: ChecklistStepSpec[];
+}
+interface ChecklistStepSpec {
+    /** The document this step's record starts life with. `title` is what a person reads. */
+    title: string;
+    /** Anything else the subject Table's Fields take. */
+    data?: Record<string, unknown>;
+}
+/**
+ * The package-owned Table a checklist RUN is recorded in. The steps are records
+ * in the subject Table — this holds only which template was instantiated and
+ * when, so re-opening a checklist finds the same steps rather than making new
+ * ones. (Running the same checklist twice on purpose is two rows here, which is
+ * the correct answer: they are two runs.)
+ */
+declare const CHECKLIST_TABLE: SystemTableSpec;
+interface ChecklistRunnerProps {
+    /** The Table the steps live in — normally the same Table the checklist is about. */
+    tableId: Uuid;
+    /** The agent's half. Each spec not already run is instantiated once. */
+    seed?: ChecklistSpec[] | undefined;
+    className?: string | undefined;
+}
+declare function ChecklistRunner({ tableId, seed, className }: ChecklistRunnerProps): react.JSX.Element;
+
+interface BookingSlotsProps {
+    /** The Table holds are taken against, and the Table a booking lands in. */
+    tableId: Uuid;
+    /** The form a person fills in once they hold a slot. Its `subject` is the Table. */
+    form: FormSpec;
+    /** Availability — the organization's opinion, with a default rather than a question. */
+    availability?: {
+        /** First hour offered, 24h. Default 9. */
+        fromHour?: number;
+        /** Last hour offered, exclusive. Default 17. */
+        toHour?: number;
+        /** Minutes per slot. Default 60. */
+        everyMinutes?: number;
+        /** How many days ahead to offer. Default 5. */
+        days?: number;
+    };
+    /** How long a hold lasts before the store lets the slot go. Default 15 minutes. */
+    holdFor?: string;
+    onBooked?: ((recordId: Uuid) => void) | undefined;
+    className?: string | undefined;
+}
+declare function BookingSlots({ tableId, form, availability, holdFor, onBooked, className, }: BookingSlotsProps): react.JSX.Element;
+
+/** The three things a phone captures. Each one writes the SAME kind of record. */
+declare const CAPTURE_MODES: readonly ["reading", "photo", "voice"];
+type CaptureMode = (typeof CAPTURE_MODES)[number];
+declare const IN_MEMORY_QUEUE_REASON: string;
+interface CaptureSheetProps {
+    /** The Table a capture becomes a record in. */
+    tableId: Uuid;
+    /** Which Field a reading's number goes in. Defaults to the first range Field. */
+    readingField?: string | undefined;
+    /** Which Field the note goes in. Defaults to the Table's title field. */
+    noteField?: string | undefined;
+    /** Which Field an attachment's file id goes in. */
+    attachmentField?: string | undefined;
+    className?: string | undefined;
+}
+declare function CaptureSheet({ tableId, readingField, noteField, attachmentField, className, }: CaptureSheetProps): react.JSX.Element;
+
+interface PortalShellProps {
+    /** The Table the outsider's records belong to. */
+    tableId: Uuid;
+    /** OPTIONAL. A form the outsider may send — their one way to put something in. */
+    form?: FormSpec | undefined;
+    /** What the resources are called in `iam`'s own vocabulary. Default `record`. */
+    resourceType?: string;
+    className?: string | undefined;
+}
+declare function PortalShell({ tableId, form, resourceType, className }: PortalShellProps): react.JSX.Element;
+
+interface PublicViewPageProps {
+    /** The public address, exactly as it appears in the URL. */
+    slug: string;
+    className?: string | undefined;
+}
+declare function PublicViewPage({ slug, className }: PublicViewPageProps): react.JSX.Element;
+
+interface EmbedFrameProps {
+    /** The Table whose rights decide whether an embed may be issued at all. */
+    tableId: Uuid;
+    /** A write embed names the form it writes into. */
+    formId?: Uuid | null | undefined;
+    /** A read embed names the saved view or the record it shows. */
+    savedViewId?: Uuid | null | undefined;
+    recordId?: Uuid | null | undefined;
+    /** Where the embedded page is served from — the `src` of the iframe. */
+    embedUrl: string;
+    className?: string | undefined;
+}
+declare function EmbedFrame({ tableId, formId, savedViewId, recordId, embedUrl, className, }: EmbedFrameProps): react.JSX.Element;
+/**
+ * THE OTHER HALF, RUNNING INSIDE THE IFRAME ON SOMEBODY ELSE'S PAGE.
+ *
+ * It hands the secret and this page's own origin to the store and uses whatever
+ * comes back. It decides nothing itself: a handshake that checked the origin in
+ * JavaScript would be a handshake an attacker can edit.
+ *
+ * `origin` is taken from `window.location.origin` by default rather than from a
+ * prop, because a prop is a value the embedding page controls and the origin
+ * must not be.
+ */
+declare function useEmbedHandshake(args: {
+    secret: string;
+    requiredMode?: "read" | "write";
+    origin?: string;
+}): {
+    binding: AnonTokenBinding | null;
+    error: RecordsError | null;
+    loading: boolean;
+};
+
+declare const STORE_DECIDES_REASON: string;
+declare const KERNEL_REASON: string;
+/**
+ * The rights answer for a host whose authority IS the record store's doors.
+ * Offers the control; the store refuses with its own sentence if it must.
+ */
+declare function storeDecidesRights(table: Table): TableRights;
+interface RecordsMountProps {
+    /** The store config: the host's session-carrying client, the actor, the organization. */
+    config: RecordsConfig;
+    /** What this host binds on top — links, toasts, uploads, rights. */
+    host?: RecordsUiHost | undefined;
+    /**
+     * Use `storeDecidesRights` when the host binds no `rights` of its own. Left
+     * off, an unbound host gets `NO_RIGHTS` and every administering control is
+     * absent with its reason.
+     */
+    letTheStoreDecideRights?: boolean | undefined;
+    children: ReactNode;
+}
+declare function RecordsMount({ config, host, letTheStoreDecideRights, children, }: RecordsMountProps): react.JSX.Element;
+/**
+ * The actor a signed-in person is. `user` is the store's own word (the closed
+ * ACTOR_VOCABULARY is `user` · `agent` · `system`), and AGT-N-4 means an agent
+ * acting for this person carries exactly this authority and no other.
+ */
+declare function personActor(userId: Uuid$1 | null | undefined): RecordsActor;
+/**
+ * A supabase-js client AS this package's data seam.
+ *
+ * `RecordsDataSource` is deliberately a small structural subset of
+ * `SupabaseClient` — the package holds no key and opens no connection, the host
+ * hands it a client that already carries the person's session. Structurally the
+ * two agree. PROVING it does not fit in the type checker's budget: a generated
+ * `Database` type makes `schema().from().select()` enormous, and a host app
+ * that passes its client straight into `config` gets
+ * `TS2589: Type instantiation is excessively deep and possibly infinite` in its
+ * own build (matrx-frontend, 2026-09-18, on all three campaign routes at once).
+ *
+ * So the assertion is made HERE, once, where it is explained — rather than as a
+ * cast copied into every route that mounts a screen.
+ */
+declare function recordsDataSource(client: object, schema?: string): RecordsDataSource;
+
+type TableLane = "mine" | "organization" | "system" | "community";
+/** The four lanes, in the order a person reads them. Never a flat list. */
+declare const TABLE_LANES: readonly TableLane[];
+declare const LANE_TITLE: Record<TableLane, string>;
+/** What fills an empty lane. A heading with nothing under it must still teach. */
+declare const LANE_EMPTY: Record<TableLane, string>;
+/** Which lane one Table belongs to, from the record's own columns. */
+declare function laneFor(table: Table): TableLane;
+interface TablesHomeProps {
+    /** Where a table opens. Absent and the card is a plain row with no pretend link. */
+    onOpenTable?: ((tableId: Uuid$1) => void) | undefined;
+    className?: string | undefined;
+}
+declare function TablesHome({ onOpenTable, className }: TablesHomeProps): react.JSX.Element;
+
+interface TablePageProps {
+    tableId: Uuid$1;
+    /** Rows per page for every layout. */
+    pageSize?: number | undefined;
+    className?: string | undefined;
+}
+declare function TablePage({ tableId, pageSize, className }: TablePageProps): react.JSX.Element;
+
+/** One Field a person asked for, in the store's own behaviour words (FLD-1). */
+interface NewFieldSpec {
+    key: string;
+    label: string;
+    /** A parity type — the thirteen come from the store, see `PARITY_FIELD_TYPES`. */
+    type: string;
+    sort?: number;
+    required?: boolean;
+    multi?: boolean;
+    config?: Record<string, unknown>;
+}
+interface NewTableSpec {
+    name: string;
+    /** The token the Table is addressed by. Derived from the name when absent. */
+    slug?: string;
+    labelSingular?: string;
+    labelPlural?: string;
+    /** The Field whose value is the record's title (REC-2). Defaults to the first Field. */
+    titleField?: string;
+    fields?: NewFieldSpec[];
+}
+type DeclareResult = {
+    ok: true;
+    data: Uuid$1;
+} | {
+    ok: false;
+    error: RecordsError;
+};
+/** `My Sales Pipeline` → `my_sales_pipeline`. A token, never a sentence. */
+declare function tokenFor(name: string): string;
+/** The one Field a Table cannot be declared without: something to call a record. */
+declare const DEFAULT_FIELDS: NewFieldSpec[];
+declare function declareTable(client: RecordsClient, spec: NewTableSpec): Promise<DeclareResult>;
+/** Write Field records for an existing Table. Used by the create path and by import. */
+declare function addFields(client: RecordsClient, tableId: Uuid$1, fields: NewFieldSpec[]): Promise<{
+    ok: true;
+    data: Uuid$1;
+} | {
+    ok: false;
+    error: RecordsError;
+}>;
+
+export { ACTION_KINDS, ACTION_TABLE, ActionInbox, type ActionInboxProps, type ActionKind, BookingSlots, type BookingSlotsProps, CAPTURE_MODES, CHART_KINDS, CHART_KIND_LABEL, CHART_NEEDS, CHECKLIST_TABLE, COMMENT_TABLE, type CaptureMode, type CaptureQueuePort, CaptureSheet, type CaptureSheetProps, ChartBlock, type ChartBlockProps, type ChartKind, type ChartSpec, ChecklistRunner, type ChecklistRunnerProps, type ChecklistSpec, type ChecklistStepSpec, CommentThread, type CommentThreadProps, CustomFieldsSection, type CustomFieldsSectionProps, DASHBOARD_TABLE, DEFAULT_FIELDS, DashboardCanvas, type DashboardCanvasProps, type DashboardSpec, type DeclareResult, DocRender, type DocRenderProps, DocTemplate, type DocTemplateProps, type DocTemplateSpec, type EditorKind, EmbedFrame, type EmbedFrameProps, type EnrichAsk, type EnrichOutcome, EnrichPanel, type EnrichPanelProps, ExportMenu, type ExportMenuProps, FORM_FLOWS, FORM_TABLE, FieldControl, FieldEditor, type FieldEditorControlProps, type FieldEditorProps, FieldLabel, type FieldProposalRow, FormBuilder, type FormBuilderProps, type FormFlow, type FormQuestionSpec, FormRunner, type FormRunnerProps, type FormSpec, type FormTheme, Grid, type GridProps, HistoryPanel, type HistoryPanelProps, IN_MEMORY_QUEUE_REASON, ImportWizard, type ImportWizardProps, KERNEL_REASON, LANE_EMPTY, LANE_TITLE, LAYOUT_LABEL, LAYOUT_NEEDS, NO_CHAT_REASON, NO_ENRICH_REASON, NO_RIGHTS, NO_SAVED_VIEWS_REASON, NO_UPLOAD_REASON, type NewFieldSpec, type NewTableSpec, NotifyRuleEditor, type NotifyRuleEditorProps, type NotifyRuleSpec, PARITY_LABEL, PARITY_MADE_OF, Peek, type PeekProps, type PendingCapture, PortalShell, type PortalShellProps, type ProposalOutcome, ProposalRow, type ProposalRowProps, type ProposedChange, ProvenanceBadge, PublicViewPage, type PublicViewPageProps, type QueuedAction, type QueuedActionSpec, RecordChat, type RecordChatContext, type RecordChatEntry, type RecordChatProps, type RecordChatWithheld, RecordChip, RecordForm, type RecordFormProps, RecordsMount, type RecordsMountProps, type RecordsUiHost, RecordsUiProvider, RefusalLine, RefusalNotice, RelationPicker, type RelationPickerProps, SERIES_COLORS, STORE_DECIDES_REASON, type SavedDashboard, type SavedForm, type SavedView, type SavedViewSpec, SignBlock, type SignBlockProps, type SystemFieldSpec, type SystemTableSpec, TABLE_LANES, type TableLane, TablePage, type TablePageProps, type TableRights, TableSettings, type TableSettingsProps, TablesHome, type TablesHomeProps, type UseSystemTableState, VIEW_LAYOUTS, VIEW_TABLE, ViewBar, type ViewBarProps, type ViewLayout, type ViewSort, ViewSwitcher, type ViewSwitcherProps, actionDocument, addFields, bodyForReading, bodyFromKeys, columnForField, dashboardDocument, dashboardFromRecord, declareTable, editorKindFor, ensureSystemTable, envelopeFor, fieldToken, fieldTypeLabel, formDocument, formFromRecord, groupLabel, isSignatureField, laneFor, personActor, recordsDataSource, renderValue, scalarText, storeDecidesRights, submissionStamp, tokenFor, useEmbedHandshake, useRecordsUi, useSystemTable, useTableRights, useViewRecords, viewDocument, viewFromRecord };