@arbidocs/blocks 0.3.185 → 0.4.0

package/dist/files/views/ViewSelectorMenu.d.ts

@@ -0,0 +1,66 @@
+import type { ReactNode } from 'react';
+import type { LucideIcon } from 'lucide-react';
+/** Every fixed string of the view menu. Pass a partial `labels` to translate or reword. */
+export interface ViewSelectorLabels {
+    trigger: string;
+    savePlaceholder: string;
+    save: string;
+    viewName: (name: string) => string;
+    deleteView: string;
+    deleteNamedView: (name: string) => string;
+    allFields: (count: number) => string;
+}
+export declare const DEFAULT_VIEW_SELECTOR_LABELS: ViewSelectorLabels;
+export interface ViewSelectorTestIds {
+    trigger: string;
+    saveNameInput: string;
+    saveButton: string;
+    currentView: string;
+    activeCheck: string;
+    deleteCurrent: string;
+    defaultItem: string;
+    /** Replaces the whole `view-selector-view-item-<name>` id. */
+    viewItem: (name: string) => string;
+    /** Replaces the whole `view-selector-column-toggle-<colId>` id. */
+    columnToggle: (colId: string) => string;
+}
+export interface ViewBuiltinItem {
+    key: string;
+    label: string;
+    icon: LucideIcon;
+    /** Defaults to `view-selector-builtin-item-${key}`. */
+    testId?: string;
+}
+export interface ViewColumnItem {
+    colId: string;
+    label: string;
+    hidden: boolean;
+}
+export interface ViewSelectorMenuProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Key of a built-in, the name of a saved view, or `'unsaved'`. */
+    currentView: string;
+    builtins: ViewBuiltinItem[];
+    /** Saved view names (the current one is listed in the header, not here). */
+    savedViewNames: string[];
+    columns: ViewColumnItem[];
+    saveName: string;
+    onSaveNameChange: (value: string) => void;
+    onSave: () => void;
+    isSaving?: boolean;
+    onSelectView: (key: string) => void;
+    onDeleteView: (name: string) => void;
+    onToggleColumn: (colId: string) => void;
+    /** Trigger caption (wins over `labels.trigger`); fixed so the width never jumps as views change. */
+    triggerLabel?: string;
+    className?: string;
+    labels?: Partial<ViewSelectorLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<ViewSelectorTestIds>;
+}
+/**
+ * Saved-views / column-visibility popover. Presentational: the app computes which view is
+ * active and handles load/save/delete/toggle.
+ */
+export declare function ViewSelectorMenu({ open, onOpenChange, currentView, builtins, savedViewNames, columns, saveName, onSaveNameChange, onSave, isSaving, onSelectView, onDeleteView, onToggleColumn, triggerLabel, className, labels, testIds, }: ViewSelectorMenuProps): ReactNode;

package/dist/files/views/fieldsEditorModel.d.ts

@@ -0,0 +1,43 @@
+import type { FieldsSortKey } from './FieldsEditorParts';
+export interface SortableField {
+    name: string;
+    created_at?: string | null;
+}
+/** Quick name filter: a plain case-insensitive substring match. */
+export declare function filterFieldsByName<T extends SortableField>(fields: T[], query: string): T[];
+/** Sort by name or creation time (returns a new array). */
+export declare function sortFields<T extends SortableField>(fields: T[], sortBy: FieldsSortKey): T[];
+export interface Noun {
+    singular: string;
+    plural: string;
+}
+export interface FieldsApplyBarCopyInput {
+    /** What the fields are called (field / label / annotation). */
+    nouns: Noun;
+    /** What Apply and Clear act on (document / fact ...). */
+    targetNoun: Noun;
+    fieldCount: number;
+    targetCount: number;
+    /** Acting on the single document under review rather than a selection. */
+    isReviewMode: boolean;
+    isApplying: boolean;
+    isClearing: boolean;
+}
+export interface FieldsApplyBarCopy {
+    applyLabel: string;
+    applyTitle: string;
+    clearLabel: string;
+    clearTitle: string;
+    deleteTitle: string;
+    exportTitle: string;
+    /** Shown while fields are ticked but nothing is selected to apply them to. */
+    hint: string | undefined;
+}
+/** Every label and tooltip of the apply bar, derived from what is ticked and what is targeted. */
+export declare function fieldsApplyBarCopy(i: FieldsApplyBarCopyInput): FieldsApplyBarCopy;
+/** Empty-list copy: a filter with no match, a kind-specific list, or the generic custom fields. */
+export declare function fieldsEmptyText(i: {
+    nouns: Noun;
+    filterText: string;
+    hasKind: boolean;
+}): string;

package/dist/files/views/index.d.ts

@@ -0,0 +1,5 @@
+export { ViewSelectorMenu, DEFAULT_VIEW_SELECTOR_LABELS, type ViewSelectorLabels, type ViewSelectorTestIds, type ViewBuiltinItem, type ViewColumnItem, type ViewSelectorMenuProps, } from './ViewSelectorMenu';
+export { FieldRow, FieldsApplyBar, FieldsEditorList, FieldsEditorRoot, FieldsEditorToolbar, FieldsEmptyState, DEFAULT_FIELDS_EDITOR_LABELS, type FieldsApplyBarTestIds, type FieldsEditorLabels, type FieldsEditorToolbarTestIds, type FieldRowTestIds, type FieldRenameState, type FieldRowProps, type FieldsApplyBarProps, type FieldsEditorToolbarProps, type FieldsSortKey, } from './FieldsEditorParts';
+export { fieldsApplyBarCopy, fieldsEmptyText, filterFieldsByName, sortFields, type FieldsApplyBarCopy, type FieldsApplyBarCopyInput, type SortableField, } from './fieldsEditorModel';
+export { FieldsManagerBody, FieldsManagerDefinition, FieldsManagerTitle, type FieldsManagerTitleProps, } from './FieldsManagerParts';
+export { TagFormRoot, TagFormField, TagFormNameField, TagFormSelectField, TagFormNote, TagFormOptionsEditor, TagFormInstructionField, TagFormMeta, TagFormFooter, TagFormSharedToggle, type TagFormFieldProps, type TagFormNameFieldProps, type TagFormSelectOption, type TagFormSelectFieldProps, type TagFormOptionsEditorProps, type TagFormInstructionFieldProps, type TagFormMetaLine, type TagFormFooterProps, } from './TagFormParts';

package/dist/home/ActionMenuDialog.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from 'react';
+export interface ActionMenuItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+}
+export interface ActionMenuDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Header mark, sized by the caller at `size-5`. */
+    icon?: ReactNode;
+    title: string;
+    description: string;
+    items: ActionMenuItem[];
+    /** A choice was made; the host performs it (the dialog does not close itself). */
+    onPick: (id: string) => void;
+    /** Dialog id; items are `<prefix>-<item id>` (default `action-menu-item-<id>`). */
+    testId?: string;
+    itemTestId?: string;
+}
+/**
+ * A plain menu of one-click actions in a dialog: no form, no schema, nothing generative. Use it
+ * for "create new" style choices; anything that asks questions belongs to a workflow or operation.
+ */
+export declare function ActionMenuDialog({ open, onOpenChange, icon, title, description, items, onPick, testId, itemTestId, }: ActionMenuDialogProps): import("react").JSX.Element;

package/dist/home/AddFilesFirst.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+/** Fixed strings of the empty-files state. */
+export interface AddFilesFirstLabels {
+    heading: string;
+}
+export declare const DEFAULT_ADD_FILES_FIRST_LABELS: AddFilesFirstLabels;
+export interface AddFilesFirstProps {
+    /** Why this action needs files, in the action's own words. */
+    reason: string;
+    /** The host's own "Add" control. */
+    action: ReactNode;
+    testId?: string;
+    labels?: Partial<AddFilesFirstLabels>;
+}
+/**
+ * What a quick-action dialog shows when the workspace has no files yet.
+ *
+ * Greying the action out says you cannot do it without saying how to get
+ * there. Offering the same "Add" menu the Files view carries turns the dead
+ * end into the first step: add files here, then run the action.
+ */
+export declare function AddFilesFirst({ reason, action, testId, labels }: AddFilesFirstProps): import("react").JSX.Element;

package/dist/home/CardHeaderBar.d.ts

@@ -0,0 +1,40 @@
+import type { MouseEvent, ReactNode } from 'react';
+export interface CardHeaderBarAction {
+    icon: ReactNode;
+    onClick: (e: MouseEvent) => void;
+    ariaLabel?: string;
+}
+export interface CardHeaderBarProps {
+    icon: ReactNode;
+    title: string;
+    subtitle?: string;
+    /** Filled variant only: background class (default: the primary token). */
+    bgColor?: string;
+    /** Rendered under the title. */
+    badge?: ReactNode;
+    /** Wrap the title in a pill. */
+    titleBadge?: boolean;
+    titleBadgeColor?: string;
+    actionButton?: CardHeaderBarAction;
+    /**
+     * `filled` (default): solid fill with on-primary text.
+     * `plain`: tonal fill, foreground text and an optional coloured bottom
+     * divider (`accentClass`), so the header reads as part of the card.
+     */
+    variant?: 'filled' | 'plain';
+    /** Plain variant only: border colour class for the bottom divider. */
+    accentClass?: string;
+    /** Inline element right after the title text. */
+    titleTrailing?: ReactNode;
+    className?: string;
+    /** Root test id (default `card-header`). */
+    testId?: string;
+    /** Sub-element ids; defaults are the current ids. */
+    testIds?: Partial<Record<'title' | 'subtitle' | 'actionButton', string>>;
+}
+/**
+ * Header bar for card-like tiles: icon, title, optional subtitle and one
+ * action button (44px on touch). Named `CardHeaderBar` to stay clear of the
+ * kit's structural `CardHeader`.
+ */
+export declare function CardHeaderBar({ icon, title, subtitle, bgColor, badge, titleBadge, titleBadgeColor, actionButton, variant, accentClass, titleTrailing, className, testId, testIds, }: CardHeaderBarProps): import("react").JSX.Element;

package/dist/home/CollapsibleSection.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+/** Fixed strings of the section header. */
+export interface CollapsibleSectionLabels {
+    /** The chevron button's name (only with `onHeaderClick`). */
+    collapseSection: string;
+    expandSection: string;
+}
+export declare const DEFAULT_COLLAPSIBLE_SECTION_LABELS: CollapsibleSectionLabels;
+export interface CollapsibleSectionProps {
+    /** The section's heading. A node, so callers can add badges or tooltips. */
+    title: ReactNode;
+    /** Leading glyph before the title. */
+    icon?: ReactNode;
+    isExpanded: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    /** Count badge beside the title. When 0 the section cannot expand (unless `expandWhenEmpty`). */
+    count?: number;
+    /** The count badge is filled (a filter is active). */
+    hasActiveFilters?: boolean;
+    expandWhenEmpty?: boolean;
+    /** Class for the body wrapper. */
+    childrenClassName?: string;
+    headerClassName?: string;
+    className?: string;
+    /** Trailing header content. */
+    rightContent?: ReactNode;
+    /** When false the section is always open: no chevron, a plain header. */
+    collapsible?: boolean;
+    /**
+     * When set, the whole header is one click target firing this (e.g. open a
+     * detail panel) and the chevron becomes its own separate toggle.
+     */
+    onHeaderClick?: () => void;
+    labels?: Partial<CollapsibleSectionLabels>;
+}
+/**
+ * A section with a chevron toggle, title, optional count and body. The header
+ * is a `role="button"` div (not a native button) because `title`/`rightContent`
+ * may hold interactive nodes such as tooltip triggers; a button inside a button
+ * is invalid HTML.
+ */
+export declare function CollapsibleSection({ title, icon, isExpanded, onToggle, children, count, hasActiveFilters, expandWhenEmpty, childrenClassName, headerClassName, className, rightContent, collapsible, onHeaderClick, labels, }: CollapsibleSectionProps): import("react").JSX.Element;

package/dist/home/CreateTile.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+export interface CreateTileProps {
+    /** Visible label, e.g. "New workspace". */
+    label: string;
+    /** Accessible name; defaults to `label`. */
+    ariaLabel?: string;
+    onSelect?: () => void;
+    /** One line explaining what is being created (first-run empty state). */
+    help?: ReactNode;
+    className?: string;
+    testId?: string;
+}
+/**
+ * The "create" tile. Sits in the grid beside the workspace tiles at the same
+ * height, in the same tonal family: no dashed outline, no shadow.
+ */
+export declare function CreateTile({ label, ariaLabel, onSelect, help, className, testId, }: CreateTileProps): import("react").JSX.Element;

package/dist/home/DashboardParts.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+/** A section's quiet header action: ghost, small, still 44px on touch. */
+export declare const DASHBOARD_QUIET_ACTION_CLASS = "h-8 gap-1.5 px-2 text-sm bg-transparent text-muted-foreground hover:bg-muted hover:text-foreground pointer-coarse:h-11";
+/** Column of the workspace dashboard's bands. A container, so children can use `@2xl:` queries. */
+export declare function DashboardRoot({ testId, className, children, }: {
+    testId?: string;
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A dashboard band: `start` is the tiles under the identity bar, `recent` the lists with an eyebrow. */
+export declare function DashboardBand({ kind, children, }: {
+    kind: 'start' | 'recent';
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Two equal columns from the `@2xl` container width, one below it. */
+export declare function DashboardColumns({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** A fact row's mark: pinned facts wear the pin, the rest a quiet dot. */
+export declare function FactMark({ pinned }: {
+    pinned: boolean;
+}): import("react").JSX.Element;
+export interface DashboardActionProps {
+    /** `primary` is the page's one filled action; `quiet` the ghost header actions. */
+    emphasis: 'primary' | 'quiet';
+    icon: ReactNode;
+    label: string;
+    onClick: () => void;
+    testId?: string;
+}
+/** Header action of a dashboard section ("New chat", "New fact"). */
+export declare function DashboardAction({ emphasis, icon, label, onClick, testId }: DashboardActionProps): import("react").JSX.Element;

package/dist/home/FactsStrip.d.ts

@@ -0,0 +1,41 @@
+import type { ReactNode } from 'react';
+import type { LucideIcon } from 'lucide-react';
+export interface FactsStripRow {
+    id: string;
+    leading?: ReactNode;
+    title: string;
+    /** Right-aligned stamp: a date or a time. */
+    time?: string;
+    onSelect?: () => void;
+}
+export interface FactsStripGroup {
+    /** Captions the group ("Upcoming", "Created"); an empty group is not rendered. */
+    caption: string;
+    rows: FactsStripRow[];
+    /** Test id of every row in this group. Defaults to `${testId}-row`. */
+    rowTestId?: string;
+}
+export interface FactsStripEmpty {
+    icon: LucideIcon;
+    label: ReactNode;
+    description?: ReactNode;
+    onSelect?: () => void;
+    testId?: string;
+}
+export interface FactsStripProps {
+    icon?: LucideIcon;
+    title: string;
+    count?: number;
+    onOpen?: () => void;
+    action?: ReactNode;
+    groups: FactsStripGroup[];
+    empty?: FactsStripEmpty;
+    className?: string;
+    /** Root test id; the title button gets `${testId}-open`. */
+    testId?: string;
+}
+/**
+ * A glanceable band of captioned groups (facts: upcoming, recently created).
+ * Not a third list page: callers hand it a few rows per group.
+ */
+export declare function FactsStrip({ icon, title, count, onOpen, action, groups, empty, className, testId, }: FactsStripProps): import("react").JSX.Element;

package/dist/home/FoldSection.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+export interface FoldSectionProps {
+    label: string;
+    /** Shown as plain muted text beside the name; omit or pass 0 to hide. */
+    count?: number;
+    /** A word or two of state for sections a count cannot summarise (shown while shut). */
+    hint?: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Trigger test id; the caller owns the naming. */
+    testId: string;
+    children: ReactNode;
+}
+/**
+ * One foldable block of a dialog. The chevron and the name are the whole hit
+ * target (44px on touch), and the count keeps the selection readable while the
+ * section is shut, so you need not re-open it to check.
+ */
+export declare function FoldSection({ label, count, hint, open, onOpenChange, testId, children, }: FoldSectionProps): import("react").JSX.Element;

package/dist/home/GettingStartedStrip.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode } from 'react';
+/** Fixed strings of the strip. */
+export interface GettingStartedStripLabels {
+    /** The close banner's headline. */
+    allSet: (firstName?: string) => string;
+    /** The close banner's second line. */
+    finished: (stepCount: number) => string;
+    done: string;
+    welcome: (firstName: string) => string;
+    getStarted: string;
+    replayDone: string;
+    almostThere: string;
+    dismiss: string;
+}
+export declare const DEFAULT_GETTING_STARTED_STRIP_LABELS: GettingStartedStripLabels;
+export interface JourneyStep {
+    id: string;
+    title: string;
+    /** The instruction shown beside the CURRENT step. */
+    description: string;
+    done: boolean;
+}
+export interface GettingStartedStripProps {
+    /** The core steps, in order. Numbers are their position. */
+    steps: JourneyStep[];
+    /** The first step not yet done; undefined when all are. */
+    currentStepId?: string;
+    firstName?: string;
+    /** Replaying the tour: the finished banner is skipped and copy says so. */
+    isReplay?: boolean;
+    /** Every core step is done (and this is not a replay): show the close banner. */
+    isComplete?: boolean;
+    onDismiss: () => void;
+    /** Brand mark before the greeting. */
+    logo?: ReactNode;
+    labels?: Partial<GettingStartedStripLabels>;
+    className?: string;
+    /** Root test id (default `getting-started`). */
+    testId?: string;
+    /** Sub-element ids; defaults are the current ids. The per-step id is `<stepper>-<step id>`. */
+    testIds?: Partial<Record<'stepper' | 'complete' | 'done' | 'dismiss', string>>;
+}
+/**
+ * First-run activation row: greeting, the numbered journey and the current
+ * step's instruction, all in ONE bare row (no container, no border), so it can
+ * live in a topbar slot. A guide, not a shortcut: it says WHERE to go and the
+ * host detects completion itself.
+ */
+export declare function GettingStartedStrip({ steps, currentStepId, firstName, isReplay, isComplete, onDismiss, logo, labels, className, testId, testIds, }: GettingStartedStripProps): import("react").JSX.Element;

package/dist/home/Greeting.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+export interface GreetingProps {
+    /** Small line above the title, e.g. today's date. */
+    eyebrow?: string;
+    title: string;
+    description?: string;
+    /** Trailing controls (view toggle, primary action). */
+    actions?: ReactNode;
+    className?: string;
+    testId?: string;
+    eyebrowTestId?: string;
+    titleTestId?: string;
+}
+/**
+ * The home page header: eyebrow, greeting, one muted line and trailing
+ * actions, centred in the same column as the content below it.
+ */
+export declare function Greeting({ eyebrow, title, description, actions, className, testId, eyebrowTestId, titleTestId, }: GreetingProps): import("react").JSX.Element;

package/dist/home/HomeLayout.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react';
+/** Column of the home page: greeting header, then the content. */
+export declare function HomeFrame({ testId, children, }: {
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Content area under the header; the pages inside own their scrolling. */
+export declare function HomeMain({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Scroll container that spans the full width (so its scrollbar rides the window edge) with the
+ * content centred in a bounded column.
+ */
+export declare function HomeCenteredScroll({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Bounded, centred column for a full-height child (the workspaces table). */
+export declare function HomeCenteredColumn({ className, children, }: {
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Centred error notice for a page that could not load. */
+export declare function HomeLoadError({ title, body, testId, }: {
+    title: string;
+    body: string;
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/home/KeyValueRow.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+/** Fixed strings of the row controls. */
+export interface KeyValueRowLabels {
+    hideField: string;
+    showField: string;
+    dragToReorder: string;
+}
+export declare const DEFAULT_KEY_VALUE_ROW_LABELS: KeyValueRowLabels;
+export interface KeyValueRowProps {
+    /** Label text; also the accessible name when `labelSlot` replaces it visually. */
+    label: string;
+    /** Glyph before the label. */
+    icon?: ReactNode;
+    /** Id of the control in the value: renders the label as a real `<label for>`. */
+    htmlFor?: string;
+    /** Replaces the icon + label (e.g. a tag pill that is itself the label). */
+    labelSlot?: ReactNode;
+    /** The value, on the right (or below the label when the container is narrow). */
+    children: ReactNode;
+    className?: string;
+    'data-testid'?: string;
+    /** Enables drag reordering; requires a parent `DndContext` + `SortableContext`. */
+    sortableId?: string;
+    /** Shows a "hide this field" control on the label line. */
+    onHide?: () => void;
+    /** Shows a "show this field" control (for hidden rows, rendered dimmed). */
+    onShow?: () => void;
+    labels?: Partial<KeyValueRowLabels>;
+}
+/**
+ * Wrap rows in this to switch on container-query responsiveness: a row stacks
+ * its label above its value in a narrow container and goes side by side when
+ * wider, by the container's width and not the viewport's.
+ */
+export declare function KeyValueContainer({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * A label/value row for forms, settings and detail views. Optionally sortable
+ * (drag handle) and hideable (hide/show controls), all visible without hover.
+ */
+export declare function KeyValueRow({ label, icon, htmlFor, labelSlot, children, className, 'data-testid': testId, sortableId, onHide, onShow, labels, }: KeyValueRowProps): import("react").JSX.Element;

package/dist/home/ProjectBandParts.d.ts

@@ -0,0 +1,70 @@
+import type { ReactNode } from 'react';
+/** Name + count text of a band that has no project to open ("Common", own workspaces). */
+export declare function PlainBandTitle({ title, count, hint, }: {
+    title: string;
+    count: number;
+    /** Muted explanation after the count, e.g. "Shared with everyone". */
+    hint?: string;
+}): import("react").JSX.Element;
+export interface ProjectBandTitleProps {
+    name: string;
+    count: number;
+    nameTestId: string;
+    /** Full plan / usage breakdown shown as a tooltip on the name. */
+    breakdown?: ReactNode;
+    /** Plan badge and usage readout, right after the count. */
+    readout?: ReactNode;
+}
+/** Title of a project band: name (with breakdown tooltip), count and the plan / usage readout. */
+export declare function ProjectBandTitle({ name, count, nameTestId, breakdown, readout, }: ProjectBandTitleProps): import("react").JSX.Element;
+export interface ProjectBreakdownProps {
+    name: string;
+    /** Plan badge (owned projects only). */
+    badge?: ReactNode;
+    /** Quota meters; shown for owned projects only. */
+    meters?: ReactNode;
+    dailyCap?: {
+        label: string;
+        value: string;
+    };
+}
+/** Plan + limits panel of the project tooltip. */
+export declare function ProjectBreakdown({ name, badge, meters, dailyCap }: ProjectBreakdownProps): import("react").JSX.Element;
+export interface ProjectReadoutProps {
+    /** Plan badge, with the id of its wrapper. */
+    plan?: {
+        badge: ReactNode;
+        testId: string;
+    };
+    usageLabel?: string;
+    /** The quota meter (a slot: it needs the host's formatter), with its wrapper's test id. */
+    usage: {
+        testId: string;
+        node: ReactNode;
+    };
+}
+/** Plan / usage readout beside a project name: always visible, nothing hover-only. */
+export declare function ProjectReadout({ plan, usageLabel, usage }: ProjectReadoutProps): import("react").JSX.Element;
+/** Column filling its container: scrolling grid on top, selection bar underneath. */
+export declare function GridWithSelectionBar({ className, grid, bar, }: {
+    className?: string;
+    grid: ReactNode;
+    bar: ReactNode;
+}): import("react").JSX.Element;
+export interface BulkDeleteButtonProps {
+    count: number;
+    /** Icon only (a narrow selection bar). */
+    isCompact: boolean;
+    disabled?: boolean;
+    onClick: () => void;
+    label?: string;
+}
+/** "Delete (n)" of a selection bar. */
+export declare function BulkDeleteButton({ count, isCompact, disabled, onClick, label, }: BulkDeleteButtonProps): import("react").JSX.Element;
+/** Single-line row inside a grid cell (identity pill, avatars). */
+export declare function GridCellRow({ testId, children }: {
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Muted em dash of an empty grid cell. */
+export declare function EmptyCellDash(): import("react").JSX.Element;

package/dist/home/QuickActionDialogHeader.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+export interface QuickActionDialogHeaderProps {
+    /** The tile's glyph, sized by the caller at `size-5`. */
+    icon: ReactNode;
+    title: string;
+    /** One sentence on what the dialog does. Keep it to a line or two. */
+    description: ReactNode;
+    /** Test id for the description, where a test asserts on the copy. */
+    descriptionTestId?: string;
+}
+/**
+ * The header every "Start" quick-action dialog wears: the tile's own mark in
+ * its disc, the action's name, and one line saying what the dialog will do.
+ *
+ * - The disc centres on the TITLE row, so it reads as the title's mark.
+ * - The description keeps the title's left edge (`pl-13` = disc + gap), so the
+ *   header is one text column beside the mark rather than an L.
+ * - `max-w-prose` + `text-pretty` cap the measure and stop two-word orphans.
+ * - `pr-8` keeps the copy clear of the close button.
+ */
+export declare function QuickActionDialogHeader({ icon, title, description, descriptionTestId, }: QuickActionDialogHeaderProps): import("react").JSX.Element;

package/dist/home/RecentList.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+import type { LucideIcon } from 'lucide-react';
+/** One listed item. Source-agnostic: a chat, a file. */
+export interface RecentRow {
+    id: string;
+    /** Bare entity mark (an icon carries its own identity; no tinted box). */
+    leading?: ReactNode;
+    title: string;
+    subtitle?: string;
+    /** Pinned right on the title line, like a message time. Hidden when `trailing` is set. */
+    time?: string;
+    onSelect?: () => void;
+    /** Real link target; `onSelect` still fires on a plain click (see `ActionLink`). */
+    href?: string;
+    /** A control rendered beside the row, outside its button. */
+    trailing?: ReactNode;
+}
+export interface RecentListEmpty {
+    icon?: LucideIcon;
+    label: ReactNode;
+    description?: ReactNode;
+    /** Makes the empty strip an invitation button. */
+    onSelect?: () => void;
+}
+export interface RecentListProps {
+    icon?: LucideIcon;
+    title: string;
+    count?: number;
+    /** Opens the full list; makes the header title a button. */
+    onOpen?: () => void;
+    /** Real link target of the header title (with `onOpen`, plain clicks call `onOpen`). */
+    openHref?: string;
+    /** The section's one quiet header action. */
+    action?: ReactNode;
+    rows: RecentRow[];
+    /** Names the right-hand column ("Added", "Messaged"). */
+    caption?: string;
+    /** What an empty section says. A plain muted line unless `onSelect` is set. */
+    empty?: RecentListEmpty;
+    className?: string;
+    /** Root test id; derived ids: `-open`, `-caption`, `-row`, `-empty-action`. */
+    testId?: string;
+}
+/**
+ * A titled list of recent items (files, chats): plain rows under a quiet
+ * header. An empty list is one tonal strip that invites the first item.
+ */
+export declare function RecentList({ icon, title, count, onOpen, openHref, action, rows, caption, empty, className, testId, }: RecentListProps): import("react").JSX.Element;