@letterncms/ui 0.0.0-stage → 0.1.0

package/src/ui/Icon.d.ts

@@ -0,0 +1,8 @@
+import { type SVGProps } from 'react';
+export interface IconProps extends Omit<SVGProps<SVGSVGElement>, 'name'> {
+    /** Semantic name (see icons.json), a registered plugin icon, or "svg:<path data>". */
+    name: string;
+    size?: number;
+}
+/** All iconography goes through here, so the icon set can be swapped in one place. */
+export declare const Icon: import("react").MemoExoticComponent<({ name, size, className, children: _ignored, ...props }: IconProps) => import("react").JSX.Element>;

package/src/ui/Input.d.ts

@@ -0,0 +1,15 @@
+import { type InputHTMLAttributes, type TextareaHTMLAttributes } from 'react';
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    icon?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    invalid?: boolean;
+    suffix?: React.ReactNode;
+}
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    invalid?: boolean;
+    autoGrow?: boolean;
+    /** Keep shared sizing/focus behavior while the caller supplies document typography. */
+    appearance?: 'default' | 'plain';
+}
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/src/ui/InspectorPanel.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+/** A workspace inspector docks on desktop and becomes a focus-managed sheet on smaller screens. */
+export declare function useWideInspector(): boolean;
+export declare function InspectorPanel({ open, onOpenChange, title, children, className, docked }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    children: ReactNode;
+    className?: string;
+    docked?: boolean;
+}): import("react").JSX.Element | null;

package/src/ui/Kbd.d.ts

@@ -0,0 +1,5 @@
+/** Keyboard shortcut. "mod" renders ⌘ on macOS and Ctrl elsewhere. */
+export declare function Kbd({ keys, className }: {
+    keys: string;
+    className?: string;
+}): import("react").JSX.Element;

package/src/ui/List.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+/** Dense row list (36px rows, hairline dividers). */
+export declare function List({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function Row({ to, onClick, children, selected, className, actions }: {
+    to?: string;
+    onClick?: () => void;
+    children: ReactNode;
+    selected?: boolean;
+    className?: string;
+    actions?: ReactNode;
+}): import("react").JSX.Element;

package/src/ui/Marquee.d.ts

@@ -0,0 +1,5 @@
+/** Reveal the end of an overflowing title when its `cms-sidebar-row` is hovered. */
+export declare function Marquee({ children, className }: {
+    children: string;
+    className?: string;
+}): import("react").JSX.Element;

package/src/ui/Menu.d.ts

@@ -0,0 +1,37 @@
+import type { ReactElement, ReactNode } from 'react';
+export interface MenuItemDef {
+    label: string;
+    /** A second, quieter line under the label. */
+    description?: string;
+    icon?: string;
+    shortcut?: string;
+    danger?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+    /** Render as a group label instead of an item. */
+    heading?: boolean;
+    separator?: boolean;
+    checked?: boolean;
+}
+export declare function Menu({ trigger, items, align, side, className }: {
+    trigger: ReactElement;
+    items: (MenuItemDef | false | null | undefined)[];
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
+}): import("react").JSX.Element;
+/** The same menu on right-click (or long-press) of its child — for actions on a row that has no room for a button. */
+export declare function ContextMenu({ children, items, className }: {
+    children: ReactElement;
+    items: (MenuItemDef | false | null | undefined)[];
+    className?: string;
+}): import("react").JSX.Element;
+/** A generic menu panel item for custom popovers. */
+export declare function MenuButton({ icon, label, onClick, active, hint, className }: {
+    icon?: string;
+    label: ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+    hint?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/src/ui/Page.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+export interface Crumb {
+    label: ReactNode;
+    to?: string;
+    icon?: string;
+}
+/** Sticky 48px bar at the top of every screen: breadcrumbs left, actions right. */
+export declare function Topbar({ crumbs, actions, children, className }: {
+    crumbs?: Crumb[];
+    actions?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** Standard screen: topbar + scrolling body with a readable max width. A title, no subtitle: the screen explains itself. */
+export declare function Page({ crumbs, actions, title, headerActions, children, width, className }: {
+    crumbs?: Crumb[];
+    actions?: ReactNode;
+    title?: ReactNode;
+    headerActions?: ReactNode;
+    children: ReactNode;
+    width?: 'narrow' | 'default' | 'wide' | 'full';
+    className?: string;
+}): import("react").JSX.Element;
+/** A titled group inside a page — rows and dividers, not a card. */
+export declare function Section({ title, description, actions, children, className }: {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;

package/src/ui/PagePagination.d.ts

@@ -0,0 +1,7 @@
+export declare function PagePagination({ page, pages, total, perPage, onPage }: {
+    page: number;
+    pages: number;
+    total?: number;
+    perPage?: number;
+    onPage: (page: number) => void;
+}): import("react").JSX.Element | null;

package/src/ui/PersonPicker.d.ts

@@ -0,0 +1,12 @@
+interface PersonPickerProps {
+    value: string[];
+    onChange: (ids: string[]) => void;
+    max?: number;
+    disabled?: boolean;
+    label?: string;
+    id?: string;
+    'aria-describedby'?: string;
+}
+/** Public summaries only. The single-person control keeps the same geometry in every state. */
+export declare function PersonPicker({ value, onChange, max, disabled, label, id, 'aria-describedby': describedBy }: PersonPickerProps): import("react").JSX.Element;
+export {};

package/src/ui/Popover.d.ts

@@ -0,0 +1,13 @@
+import { type ReactElement, type ReactNode } from 'react';
+export interface PopoverProps {
+    trigger: ReactElement;
+    children: ReactNode;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'center' | 'end';
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    modal?: boolean;
+    returnFocus?: () => HTMLElement | null | false;
+}
+export declare function Popover({ trigger, children, side, align, open, onOpenChange, className, modal, returnFocus }: PopoverProps): import("react").JSX.Element;

package/src/ui/QueryError.d.ts

@@ -0,0 +1,6 @@
+/** A failed request remains distinguishable from a valid empty result. */
+export declare function QueryError({ message, onRetry, compact }: {
+    message?: string;
+    onRetry: () => void;
+    compact?: boolean;
+}): import("react").JSX.Element;

package/src/ui/Segmented.d.ts

@@ -0,0 +1,36 @@
+export interface SegmentOption<T extends string> {
+    value: T;
+    label?: string;
+    icon?: string;
+    title?: string;
+}
+/**
+ * Compact segmented control (lenses, breakpoints, alignment…). With no value, the
+ * `placeholder` option (the default that applies) shows lighter than a chosen one.
+ */
+export declare function Segmented<T extends string>({ value, onChange, options, size, block, className, placeholder, id, disabled, 'aria-label': ariaLabel }: {
+    value: T;
+    onChange: (v: T) => void;
+    options: SegmentOption<T>[];
+    size?: 'xs' | 'sm';
+    block?: boolean;
+    className?: string;
+    placeholder?: T;
+    id?: string;
+    disabled?: boolean;
+    'aria-label'?: string;
+}): import("react").JSX.Element;
+export declare function Tabs<T extends string>({ value, onChange, tabs, className, id, bordered, size }: {
+    value: T;
+    onChange: (v: T) => void;
+    tabs: {
+        value: T;
+        label: string;
+        count?: number;
+        indicator?: boolean;
+    }[];
+    className?: string;
+    id?: string;
+    bordered?: boolean;
+    size?: 'xs' | 'sm';
+}): import("react").JSX.Element;

package/src/ui/Select.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+export interface SelectOption {
+    value: string;
+    label: string;
+    icon?: string;
+    description?: string;
+}
+export interface SelectProps {
+    value: string | null;
+    onChange: (value: string | null) => void;
+    options: SelectOption[];
+    placeholder?: string;
+    /** A compact state hint beside the selected value, such as an inherited setting. */
+    valueHint?: ReactNode;
+    size?: 'xs' | 'sm' | 'md';
+    disabled?: boolean;
+    invalid?: boolean;
+    className?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    id?: string;
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+}
+export declare function Select({ value, onChange, options, placeholder, valueHint, size, disabled, invalid, className, clearable, clearLabel, id, 'aria-label': ariaLabel, 'aria-describedby': describedBy }: SelectProps): import("react").JSX.Element;

package/src/ui/SelectionBar.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+/** Floats over the list while entries are selected, so nothing below moves. */
+export declare function SelectionBar({ count, children, onClear }: {
+    count: number;
+    children: ReactNode;
+    onClear: () => void;
+}): import("react").JSX.Element;

package/src/ui/SidebarRow.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import { type MenuItemDef } from './Menu';
+export interface SidebarRowAction extends MenuItemDef {
+    /** Also a button on the row, shown on hover and focus (it needs an `icon`). */
+    quick?: boolean;
+}
+export interface SidebarRowProps {
+    label: string;
+    icon?: string;
+    to?: string;
+    onClick?: () => void;
+    active?: boolean;
+    /** The rail: the icon alone, its label in a tooltip. */
+    collapsed?: boolean;
+    title?: string;
+    /** A count, or a dot in the rail. */
+    badge?: ReactNode;
+    shortcut?: string | null;
+    status?: ReactNode;
+    /** Everything the row can do, in its context menu; `quick` ones are buttons on the row too. */
+    actions?: (SidebarRowAction | false | null | undefined)[];
+    /** A row being dragged into place must not drag its link out of the page. */
+    sortable?: boolean;
+}
+/**
+ * Every row in the sidebar: a link or button, its label sliding to show its end
+ * when it does not fit, quick actions on hover, and all of them on right-click
+ * (or long-press) after Open in New Tab. Navigation and actions are siblings so
+ * buttons never live inside a link.
+ */
+export declare function SidebarRow({ label, icon, to, onClick, active, collapsed, title, badge, shortcut, status, actions, sortable }: SidebarRowProps): import("react").JSX.Element;

package/src/ui/Slideover.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode, type RefObject } from 'react';
+interface SlideoverProps {
+    id: string;
+    open: boolean;
+    expanded: boolean;
+    onOpenChange: (open: boolean) => void;
+    onExpandedChange: (expanded: boolean) => void;
+    title: ReactNode;
+    icon?: string;
+    actions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+/** Keeps workspace overlays anchored to the content area, independently of sidebar width. */
+export declare const WorkspaceContext: import("react").Context<{
+    host: HTMLDivElement | null;
+    content: RefObject<HTMLDivElement | null>;
+} | null>;
+/** A persistent workspace overlay. Expansion leaves global navigation available. */
+export declare function Slideover({ id, open, expanded, onOpenChange, onExpandedChange, title, icon, actions, children, className }: SlideoverProps): import("react").JSX.Element;
+export {};

package/src/ui/SortableTree.d.ts

@@ -0,0 +1,30 @@
+import { type ReactNode } from 'react';
+/** A tree node as the editor sees it: any data plus children. */
+export interface TreeItem {
+    id: string;
+    children?: TreeItem[];
+    [key: string]: unknown;
+}
+export interface SortableTreeProps<T extends TreeItem> {
+    items: T[];
+    onChange: (items: T[]) => void;
+    /** Row content. `handle` is the drag grip; place it where it fits. */
+    renderItem: (item: T, ctx: {
+        depth: number;
+        handle: ReactNode;
+        indent: () => void;
+        outdent: () => void;
+        canIndent: boolean;
+        canOutdent: boolean;
+    }) => ReactNode;
+    maxDepth?: number;
+    /** Pixels per level; also the horizontal drag distance that changes the level. */
+    indent?: number;
+    className?: string;
+}
+/**
+ * Drag-and-drop tree editor (menus, page trees). Drag vertically to reorder,
+ * sideways to nest; children travel with their parent. Keyboard: focus the
+ * grip, space to lift, arrows to move, space to drop.
+ */
+export declare function SortableTree<T extends TreeItem>({ items, onChange, renderItem, maxDepth, indent, className }: SortableTreeProps<T>): import("react").JSX.Element;

package/src/ui/Spinner.d.ts

@@ -0,0 +1,7 @@
+export declare function Spinner({ size, className }: {
+    size?: number;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function Skeleton({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/src/ui/Surface.d.ts

@@ -0,0 +1,8 @@
+import { type SurfaceAction, type SurfaceDocument } from '@letterncms/sdk';
+/** A native json-render spec, backed by the current CMS registry and design system. */
+export interface SurfaceProps {
+    document: SurfaceDocument;
+    disabled?: boolean;
+    onAction?: (action: SurfaceAction) => void;
+}
+export declare function Surface({ document, disabled, onAction }: SurfaceProps): import("react").JSX.Element;

package/src/ui/SurfaceHost.d.ts

@@ -0,0 +1,2 @@
+import type { SurfaceProps } from './Surface';
+export declare function Surface(props: SurfaceProps): import("react").JSX.Element;

package/src/ui/Switch.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+export declare function Switch({ checked, onChange, disabled, label, size, 'aria-label': ariaLabel }: {
+    checked: boolean;
+    onChange: (v: boolean) => void;
+    disabled?: boolean;
+    label?: ReactNode;
+    size?: 'sm' | 'md';
+    'aria-label'?: string;
+}): import("react").JSX.Element;
+export declare function Checkbox({ checked, onChange, disabled, label, indeterminate }: {
+    checked: boolean;
+    onChange: (v: boolean) => void;
+    disabled?: boolean;
+    label?: ReactNode;
+    indeterminate?: boolean;
+}): import("react").JSX.Element;

package/src/ui/Tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { ReactElement, ReactNode } from 'react';
+export declare function TooltipProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function Tooltip({ content, shortcut, side, children }: {
+    content: ReactNode;
+    shortcut?: string;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    children: ReactElement;
+}): import("react").JSX.Element;

package/src/ui/ViewControls.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentProps, ReactNode } from 'react';
+import type { CalendarDate } from './viewPrefs';
+export type OverviewView = 'table' | 'grid' | 'calendar';
+export interface ViewColumn {
+    id: string;
+    label: string;
+    sort?: string;
+    descFirst?: boolean;
+    field?: unknown;
+}
+/** Shared display preferences for every overview, including collection entries. */
+export declare function DisplayOptions({ view, all, shown, sortable, sortKey, isTree, cardColumns, onColumns, onSort, onReset, calendarDate, onCalendarDate }: {
+    view: OverviewView;
+    all: ViewColumn[];
+    shown: Set<string>;
+    sortable: ViewColumn[];
+    sortKey: string | null;
+    isTree?: boolean;
+    cardColumns?: string[];
+    onColumns: (ids: string[]) => void;
+    onSort: (key: string | null) => void;
+    onReset?: () => void;
+    calendarDate?: CalendarDate;
+    onCalendarDate?: (date: CalendarDate) => void;
+}): import("react").JSX.Element;
+export declare function ViewSwitcher({ value, onChange }: {
+    value: OverviewView;
+    onChange: (view: OverviewView) => void;
+}): import("react").JSX.Element;
+/** Every overview presents the same menu, view choices and reset behavior. */
+export declare function OverviewControls({ onView, children, ...display }: ComponentProps<typeof DisplayOptions> & {
+    onView: (view: OverviewView) => void;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/** Header clicks cycle natural direction, reverse, then the source's default order. */
+export declare function nextTableSort(field: string, current: string | null, descFirst?: boolean, implicit?: string | null): string | null;

package/src/ui/Widget.d.ts

@@ -0,0 +1,121 @@
+import { type ReactNode } from 'react';
+/**
+ * Home-screen widgets. The home screen gives each widget its registration (label, icon)
+ * through context; the widget draws its body inside `<Widget>`, which supplies the
+ * header, loading skeleton, error and empty states — so every widget, core or plugin,
+ * looks and behaves the same:
+ *
+ *   export default function LatestReviews() {
+ *     const reviews = useAbility<Review[]>('reviews/latest', { limit: 5 })
+ *     return (
+ *       <Widget action={{ label: t('All Reviews'), to: '/reviews' }} query={reviews} empty={reviews.data?.length === 0 && { icon: 'star', title: t('No reviews yet') }}>
+ *         {reviews.data?.map((r) => <WidgetRow key={r.id} to={`/reviews/${r.id}`} icon="star" title={r.title} meta={timeAgo(r.createdAt)} />)}
+ *       </Widget>
+ *     )
+ *   }
+ *
+ * The body sits in a container (`@container`), so a widget can adapt to the column it is
+ * in with container variants (`@md:grid-cols-4`) — the main column is wide, the side one narrow.
+ */
+export interface WidgetMeta {
+    id: string;
+    label: string;
+    icon: string;
+}
+export declare const WidgetContext: import("react").Context<WidgetMeta | null>;
+/** The registration of the widget being rendered (label, icon), when it is on the home screen. */
+export declare function useWidget(): WidgetMeta | null;
+export interface WidgetEmpty {
+    icon?: string;
+    title: string;
+    description?: ReactNode;
+    action?: ReactNode;
+}
+export interface WidgetProps {
+    /** Defaults to the registered label and icon. */
+    title?: ReactNode;
+    icon?: string;
+    /** A link in the header ("View all"), or any node (a menu, a button). */
+    action?: {
+        label: string;
+        to?: string;
+        onClick?: () => void;
+    } | ReactNode;
+    /** A react-query result: loading shows the skeleton, an error a retry. */
+    query?: {
+        isLoading: boolean;
+        isError?: boolean;
+        refetch?: () => unknown;
+    };
+    loading?: boolean;
+    /** The loading placeholder; rows by default. */
+    skeleton?: ReactNode;
+    /** Shown instead of the body when truthy. */
+    empty?: WidgetEmpty | false | null;
+    children?: ReactNode;
+    className?: string;
+}
+export declare function Widget({ title, icon, action, query, loading, skeleton, empty, children, className }: WidgetProps): import("react").JSX.Element;
+/** Placeholder rows while a widget loads. */
+export declare function WidgetSkeleton({ rows }: {
+    rows?: number;
+}): import("react").JSX.Element;
+/** The quiet empty (or error) state inside a widget: what it is, and one action. */
+export declare function WidgetMessage({ icon, title, description, action }: WidgetEmpty): import("react").JSX.Element;
+/**
+ * A row in a widget list: something to open, with an icon (or any leading node),
+ * a title, an optional second line and a quiet value on the right.
+ */
+export declare function WidgetRow({ to, onClick, href, icon, leading, title, description, meta, className }: {
+    to?: string;
+    onClick?: () => void;
+    href?: string;
+    icon?: string;
+    leading?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    meta?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/** 1,284 · 12.9K · 4.2M in the admin's language. */
+export declare function compactNumber(value: number): string;
+/**
+ * A headline number: label, value, change against the previous period and an optional trend.
+ * `delta` is a fraction (0.12 = +12%); `good` says which direction is good news.
+ */
+export declare function Stat({ label, value, delta, good, trend, size, className }: {
+    label: ReactNode;
+    value: ReactNode;
+    delta?: number | null;
+    good?: 'up' | 'down';
+    trend?: number[];
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+}): import("react").JSX.Element;
+/** Change as a signed percentage, green when it is good news. */
+export declare function Delta({ value, good }: {
+    value: number;
+    good?: 'up' | 'down';
+}): import("react").JSX.Element;
+/** A small trend line with a soft wash — one series, no axes (details live on the screen it links to). */
+export declare function Sparkline({ values, className, label }: {
+    values: number[];
+    className?: string;
+    label?: string;
+}): import("react").JSX.Element | null;
+/** A filled bar for a share or a score (0–1). The tone carries the state; the label stays in text color. */
+export declare function Meter({ value, tone, className, label }: {
+    value: number;
+    tone?: 'ink' | 'success' | 'warning' | 'danger' | 'muted';
+    className?: string;
+    label?: string;
+}): import("react").JSX.Element;
+/** A row with a proportional bar behind it — top pages, sources, devices. */
+export declare function BarRow({ label, value, share, icon, to, href }: {
+    label: ReactNode;
+    value: ReactNode;
+    share: number;
+    icon?: ReactNode;
+    to?: string;
+    href?: string;
+}): import("react").JSX.Element;

package/src/ui/WidgetSlot.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import { type WidgetMeta } from './Widget';
+/** One rendering path for home, chat and any other host of registered widgets. */
+export declare function WidgetSlot({ widget, fallback }: {
+    widget: WidgetMeta;
+    fallback?: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null;

package/src/ui/calendar.d.ts

@@ -0,0 +1,10 @@
+export declare const calendarDayKey: (date: Date) => string;
+export declare function calendarRange(value?: string): {
+    month: string;
+    year: number;
+    monthIndex: number;
+    first: Date;
+    start: Date;
+    end: Date;
+    days: Date[];
+};

package/src/ui/cn.d.ts

@@ -0,0 +1,2 @@
+/** Join class names, skipping falsy values. */
+export declare function cn(...classes: (string | false | null | undefined)[]): string;

package/src/ui/dateTime.d.ts

@@ -0,0 +1,6 @@
+/** datetime-local controls represent wall time; scheduling stores an unambiguous UTC instant. */
+export declare function formatDateTimeInZone(iso: string, timeZone: string): string;
+export declare function parseDateTimeInZone(wallTime: string, timeZone: string): {
+    value: string | null;
+    error?: 'invalid' | 'nonexistent' | 'ambiguous';
+};

package/src/ui/entryActions.d.ts

@@ -0,0 +1,13 @@
+import type { EntryCapabilities, EntrySummary } from '@letterncms/sdk';
+/** The editor, row menus, bulk bar and shortcuts share one capability policy. null means a new entry. */
+export declare function entryActionAvailability(can: EntryCapabilities | undefined, entry?: Pick<EntrySummary, 'status'> | null): {
+    create: boolean;
+    edit: boolean;
+    duplicate: boolean;
+    delete: boolean;
+    publish: boolean;
+    unpublish: boolean;
+    restore: boolean;
+    discard: boolean;
+    move: boolean;
+};

package/src/ui/entryDisplay.d.ts

@@ -0,0 +1,16 @@
+import { type FieldDef } from '@letterncms/sdk';
+export declare const fieldColumnId: (handle: string) => string;
+export declare function entryFieldColumns(fields: FieldDef[]): {
+    id: string;
+    label: string;
+    width: string | number;
+    field: FieldDef;
+    sort: string | undefined;
+    descFirst: boolean;
+    align: "end" | undefined;
+}[];
+export declare function entrySystemColumns(routable: boolean, locales: string[]): {
+    id: string;
+    label: string;
+}[];
+export declare function standardEntryColumns(routable: boolean, listing?: string[], view?: string, fields?: FieldDef[]): string[];

package/src/ui/fieldIdentity.d.ts

@@ -0,0 +1,3 @@
+import type { FieldDef } from '@letterncms/sdk';
+/** Form identity follows the value path, so nested names never collide with record fields. */
+export declare function fieldControlId(field: Pick<FieldDef, 'handle' | 'id'>, path?: string[]): string;