@seekbuddy/dsh-ui 0.0.0-stage → 0.2.0-beta.0

package/dist/types/seekbuddy/Card.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes } from 'react';
+/** Inner padding: `none` = 0 (self-laid-out content such as a cover image), `sm` = 14px (dense catalog cards), `md` = 16px (default). */
+export type CardPadding = 'none' | 'sm' | 'md';
+/** Rendered element; pick `li` inside a list so the card needs no wrapper. */
+export type CardElement = 'div' | 'section' | 'article' | 'li';
+export interface CardProps extends HTMLAttributes<HTMLElement> {
+    /** Inner padding; see `CardPadding`. Default `md` (16px). */
+    padding?: CardPadding | undefined;
+    /**
+     * Hover feedback for cards the caller makes clickable: the translucent `--dsw-alias-interactive-bg-hover`
+     * fill upstream's plugin cards use, plus the pointer cursor.
+     * Styling only — clicking is wired by the caller (`onClick` here, or a `<button>` inside).
+     */
+    interactive?: boolean | undefined;
+    /** Element to render; see `CardElement`. Default `div`. */
+    as?: CardElement | undefined;
+}
+/**
+ * Card surface only — background, hairline stroke, radius, elevation, padding — with the content
+ * left entirely to `children`. Upstream primitives ship no card / panel, so hand-rolled cards
+ * tend to drift apart. No header / footer / title slots by design:
+ * business cards do not share an inner structure, so the library does not pretend they do.
+ *
+ * Server-safe (no hooks, no DOM access): a Next.js Server Component may import it from
+ * `@seekbuddy/dsh-ui/seekbuddy/card`. Sets no `role` / `tabIndex` — a fully clickable card is the
+ * caller's accessibility decision (put a `<button>` inside, or wire `role="button"` + keyboard).
+ */
+export declare function Card({ padding, interactive, as: Element, className, ...rest }: CardProps): import("react").JSX.Element;

package/dist/types/seekbuddy/DangerButton.d.ts

@@ -0,0 +1,31 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { Button } from '@seekbuddy/dsh-ui';
+/** Upstream `Button` props minus `variant`: the shape is fixed to the outline capsule. */
+export type DangerButtonProps = Omit<ComponentPropsWithoutRef<typeof Button>, 'variant' | 'className'> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+};
+/**
+ * Outline capsule in the error tone — red label and stroke — for destructive actions (delete,
+ * disable) and error-state affordances (e.g. a "review failed" chip that opens the reason).
+ *
+ * Upstream `ButtonVariant` has no danger family, and restyling the upstream `Button` through a
+ * consumer `className` tends to cover only the hover state. This owns the whole state set
+ * once — hover, active, focus-visible — while geometry, sizes and the disabled 40 % opacity stay
+ * with the upstream `Button` it wraps.
+ *
+ * Tokens: `--dsw-alias-state-error-primary` (label and stroke; the same token upstream `Menu`
+ * uses for its danger item), `--dsw-alias-interactive-bg-hover-danger` (hover fill), an 18 %
+ * `color-mix` of the error tone (active fill; no dedicated alias token), and the shared focus ring (width and colour from the theme's `focus.css`).
+ * All are theme-aware, so dark mode needs no extra rules.
+ */
+export declare const DangerButton: import("react").ForwardRefExoticComponent<Omit<Omit<{
+    variant?: import("@seekbuddy/dsh-ui").ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: import("react").ReactNode;
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>, "ref">, "className" | "variant"> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/seekbuddy/Empty.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** The three content states a data-driven view has to handle. */
+export type EmptyStatus = 'loading' | 'empty' | 'error';
+export interface EmptyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Which state to show. Precedence between loading / error / empty is the caller's decision. */
+    status: EmptyStatus;
+    /** Main line; localized by the caller. */
+    title: string;
+    /** Secondary line under the title. */
+    description?: ReactNode | undefined;
+    /**
+     * Leading visual. `undefined` picks the default for the status (spinner / search / warning);
+     * `null` renders no icon at all.
+     */
+    icon?: ReactNode | null | undefined;
+    /** Action row (e.g. a "create" button for the empty state). Rendered before the retry button. */
+    action?: ReactNode | undefined;
+    /** Label of the retry button; rendered only for `status="error"` together with `onRetry`. */
+    retryLabel?: string | undefined;
+    /** Retry handler; rendered only for `status="error"` together with `retryLabel`. */
+    onRetry?: (() => void) | undefined;
+    /** Reserved height so a list that refreshes into a state does not jump. Default 240. */
+    minHeight?: number | string | undefined;
+    /** Dashed frame; turn off for full-screen or already-framed placements. Default `true`. */
+    bordered?: boolean | undefined;
+}
+/**
+ * Placeholder block for the loading / empty / error states of a page or a list region: icon,
+ * title, description and an action row. Text and buttons come from the caller; the component only
+ * fixes structure, tokens and the live-region semantics per state (`status` + polite for loading,
+ * `alert` for error, nothing for empty). server-safe (no hooks); the retry button needs a handler
+ * so it is only usable from Client Components.
+ */
+export declare function Empty({ status, title, description, icon, action, retryLabel, onRetry, minHeight, bordered, className, style, ...rest }: EmptyProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Mark.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Closed set of marks the extension layer knows how to draw. Each kind is one fixed meaning with
+ * its own glyph and colour token; adding a kind means adding an entry to `GLYPHS`, a colour class
+ * in `Mark.module.css` and a story — callers only ever pick a kind.
+ */
+export type MarkKind = 'official';
+/** Pixel edge of the glyph. 14 / 16 next to card titles, 20 / 24 next to detail-page headings. */
+export type MarkSize = 14 | 16 | 18 | 20 | 24;
+export interface MarkProps {
+    /** Which mark to draw; each kind has a fixed glyph and colour. */
+    kind: MarkKind;
+    /** Screen-reader name and tooltip text, e.g. "Official"; localized by the caller. */
+    label: string;
+    /** Default 16. */
+    size?: MarkSize | undefined;
+    /** Wrap in a hover / focus tooltip showing `label`. Default `true`; pass `false` when the meaning is already spelled out next to the mark. */
+    tooltip?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Inline status mark: a fixed glyph with one meaning per `kind`, sized to sit on the text
+ * baseline without growing the line. Not a generic badge — no free icon or colour props.
+ * `<span role="img" aria-label tabIndex={0}>` so keyboard users can reach the tooltip; the SVG is
+ * decorative. Uses the upstream `Tooltip`, so it lives in the Client Component aggregate entry only.
+ */
+export declare function Mark({ kind, label, size, tooltip, className }: MarkProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Message.d.ts

@@ -0,0 +1,52 @@
+import { type ReactNode } from 'react';
+export type MessageType = 'success' | 'info' | 'warning' | 'error' | 'loading';
+export interface MessageOptions {
+    /** Default `info`. */
+    type?: MessageType | undefined;
+    /** Message text or nodes. */
+    content: ReactNode;
+    /** Seconds. Default 3; `0` stays until closed. `loading` defaults to 0. */
+    duration?: number | undefined;
+    /** Re-opening with the same key updates that message in place (e.g. loading → success). */
+    key?: string | undefined;
+    /** Replaces the type's default glyph. */
+    icon?: ReactNode | undefined;
+    /** Called after the message has faded out, however it closed: timeout, `close()`, `destroy`, or eviction by `maxCount`. */
+    onClose?: (() => void) | undefined;
+}
+/** Closes the message it was returned for. */
+export type MessageClose = () => void;
+export interface MessageApi {
+    /** Shows a message with full options; returns a function that closes it. */
+    open(options: MessageOptions): MessageClose;
+    /** Shows a success message; `duration` in seconds (default 3, `0` keeps it open). */
+    success(content: ReactNode, duration?: number): MessageClose;
+    /** Shows an info message; `duration` in seconds (default 3, `0` keeps it open). */
+    info(content: ReactNode, duration?: number): MessageClose;
+    /** Shows a warning message; `duration` in seconds (default 3, `0` keeps it open). */
+    warning(content: ReactNode, duration?: number): MessageClose;
+    /** Shows an error message; `duration` in seconds (default 3, `0` keeps it open). */
+    error(content: ReactNode, duration?: number): MessageClose;
+    /** Shows a loading message; it stays until closed unless `duration` is given. */
+    loading(content: ReactNode, duration?: number): MessageClose;
+    /** Without a key closes every message. */
+    destroy(key?: string): void;
+}
+export interface MessageProviderProps {
+    /** Distance from the viewport top in px. Default 120, where the upstream Toast sits. */
+    top?: number | undefined;
+    /** Messages shown at once; the oldest closes when exceeded. Default 3. */
+    maxCount?: number | undefined;
+    /** The subtree that may call `useMessage()`. */
+    children: ReactNode;
+}
+/**
+ * Stacked transient messages: antd's `useMessage` shape on top of the upstream Toast look.
+ * The provider owns the stack and renders it through a body portal only while something is
+ * showing, so server rendering never touches `document`. A provider per page root, not a global
+ * singleton — separately built bundles on one page each include their own copy of this module, so a
+ * module-level store would split across them.
+ */
+export declare function MessageProvider({ top, maxCount, children }: MessageProviderProps): import("react").JSX.Element;
+/** The message API of the nearest `MessageProvider`; stable across renders. Throws outside one. */
+export declare function useMessage(): MessageApi;

package/dist/types/seekbuddy/Pagination.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from 'react';
+/** All user-visible text, localized by the caller. */
+export interface PaginationLabels {
+    /** `aria-label` of the `<nav>`, e.g. "Pagination". */
+    navigation: string;
+    /** `aria-label` of the previous-page button. */
+    previous: string;
+    /** `aria-label` of the next-page button. */
+    next: string;
+    /** `aria-label` of a page button, e.g. `(page) => \`Page ${page}\``. */
+    page: (page: number) => string;
+    /** `aria-label` of the ellipsis that jumps back, e.g. "Previous 5 pages". */
+    jumpPrevious: string;
+    /** `aria-label` of the ellipsis that jumps forward. */
+    jumpNext: string;
+}
+export interface PaginationProps {
+    /** Controlled current page (1-based). Omit for uncontrolled with `defaultCurrent`. */
+    current?: number | undefined;
+    /** Initial page when uncontrolled. Default 1. */
+    defaultCurrent?: number | undefined;
+    /** Items per page; with `total` this yields the page count. */
+    pageSize?: number | undefined;
+    /** Initial page size when `pageSize` is omitted. Default 10. */
+    defaultPageSize?: number | undefined;
+    /** Total item count. */
+    total: number;
+    /** Fired with the target page; `pageSize` rides along so a future size changer keeps the signature. */
+    onChange?: ((page: number, pageSize: number) => void) | undefined;
+    /** Summary rendered at the start, e.g. `(total, [from, to]) => \`${from}–${to} of ${total}\``. */
+    showTotal?: ((total: number, range: [number, number]) => ReactNode) | undefined;
+    /** Render nothing when everything fits on one page. Default `true` (antd defaults to `false`). */
+    hideOnSinglePage?: boolean | undefined;
+    /** Previous / `current / pages` / next only. */
+    simple?: boolean | undefined;
+    /** Middle window of 3 page buttons instead of 5, for narrow rows. */
+    showLessItems?: boolean | undefined;
+    /** Disables every button in the strip. */
+    disabled?: boolean | undefined;
+    /** All visible and screen-reader text; see `PaginationLabels`. */
+    labels: PaginationLabels;
+    /** Extra class on the root `<nav>`, for layout. */
+    className?: string | undefined;
+}
+/** One slot of the page strip: a page button or an ellipsis that jumps by the window size. */
+export type PaginationItem = {
+    type: 'page';
+    page: number;
+} | {
+    type: 'jump-previous' | 'jump-next';
+    page: number;
+};
+/**
+ * antd's page strip: with few pages list them all; otherwise keep page 1 and the last page, a
+ * window of 5 (or 3) around `current`, and an ellipsis on each side that has a gap. Jumps move by
+ * the window size, clamped. Pure, exported for tests.
+ */
+export declare function pageItems(current: number, pages: number, lessItems?: boolean): PaginationItem[];
+/**
+ * Page navigation for catalog lists. Mirrors a subset of antd's Pagination:
+ * controlled or uncontrolled `current`, `total` + `pageSize` → page count, first / last page
+ * always visible with ellipsis jumps, `showTotal`, `simple`, `hideOnSinglePage`. Text comes from
+ * `labels`; the component has no strings of its own. Client Component (state for the
+ * uncontrolled mode), aggregate entry only.
+ */
+export declare function Pagination({ current, defaultCurrent, pageSize, defaultPageSize, total, onChange, showTotal, hideOnSinglePage, simple, showLessItems, disabled, labels, className, }: PaginationProps): import("react").JSX.Element | null;

package/dist/types/seekbuddy/Spinner.d.ts

@@ -0,0 +1,20 @@
+/** `sm` = 0.85rem / 2px ring for buttons and inline text; `md` = 2rem / 3px for page-level waits. */
+export type SpinnerSize = 'sm' | 'md';
+/** `inherit` rides `currentColor` (button foreground); `page` pins `--dsw-alias-label-primary`. */
+export type SpinnerTone = 'inherit' | 'page';
+export interface SpinnerProps {
+    /** Ring size; see `SpinnerSize`. Default `sm`. */
+    size?: SpinnerSize | undefined;
+    /** Ring colour source; see `SpinnerTone`. Default `inherit`. */
+    tone?: SpinnerTone | undefined;
+    /** Screen-reader text; when present the spinner becomes a live status region instead of aria-hidden. */
+    label?: string | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * The shared loading ring: track = currentColor at
+ * 35%, arc = currentColor, reduced motion keeps a static two-tone ring. Without `label`
+ * it is decorative (`aria-hidden`) and the surrounding text must say what is loading.
+ */
+export declare function Spinner({ size, tone, label, className }: SpinnerProps): import("react").JSX.Element;

package/dist/types/seekbuddy/StatusBadge.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+/**
+ * Closed set of tones. Each one is a fixed meaning with its own state dot and theme token; adding a
+ * tone means adding an entry here and in `DOTS`, a colour class in `StatusBadge.module.css` and a
+ * story — callers only pick a tone, never a colour.
+ */
+export type StatusTone = 'neutral' | 'success' | 'progress' | 'warning' | 'error';
+export interface StatusBadgeProps {
+    /** Meaning of the badge, which fixes its dot and colour; see `StatusTone`. */
+    tone: StatusTone;
+    /** Label text; localized by the caller. */
+    children: ReactNode;
+    /** Drop the leading dot when the row already carries one. Default `true`. */
+    dot?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Read-only status chip: a state dot plus a label, in one of five tones — "running", "mounting",
+ * "not connected", "mount failed", "delisted" and friends.
+ *
+ * The dot is the upstream `StateDot` (the same glyph the terminal block uses for run state), so
+ * `progress` gets upstream's animated chase rather than a second spinner vocabulary. Colour comes
+ * from the tone: upstream `Pill` has no tone variants, and recolouring an upstream component through
+ * a consumer `className` couples the caller to its internal styles. This owns the tones once so no
+ * call site needs that override. Geometry — capsule,
+ * height, font — stays with the `Pill` it wraps.
+ *
+ * Static by design: no `onClick`, so `Pill` renders a `<span>` and there are no interactive states
+ * to keep in sync. The dot is `aria-hidden`; the label carries the meaning. Tokens are theme-aware
+ * (`--dsw-alias-state-*` / `--dsw-alias-label-tertiary`), so dark mode needs no extra rules.
+ */
+export declare function StatusBadge({ tone, children, dot, className }: StatusBadgeProps): import("react").JSX.Element;

package/dist/types/seekbuddy/SubtleButton.d.ts

@@ -0,0 +1,30 @@
+import { type ComponentPropsWithoutRef } from 'react';
+import { Button } from '@seekbuddy/dsh-ui';
+/** Upstream `Button` props minus `variant`: the shape is fixed to the ghost capsule. */
+export type SubtleButtonProps = Omit<ComponentPropsWithoutRef<typeof Button>, 'variant' | 'className'> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+};
+/**
+ * Ghost capsule with a secondary label — for low-emphasis navigation that sits next to real actions
+ * (a card's "view details" link, a back button), where the default ghost label would compete with them.
+ *
+ * Upstream `ButtonVariant` has no quiet family, and setting `color` on a ghost `Button` through a consumer
+ * `className` covers its resting state only. This owns the whole state set once — the label steps up to the
+ * primary label on hover and press, plus a focus-visible ring — while geometry, sizes, the hover / press
+ * fills and the disabled 40 % opacity stay with the upstream ghost `Button` it wraps.
+ *
+ * Tokens: `--dsw-alias-label-secondary` (resting label), `--dsw-alias-label-primary` (hover / press label)
+ * and the shared focus ring (width and colour from the theme's `focus.css`).
+ * All are theme-aware, so dark mode needs no extra rules.
+ */
+export declare const SubtleButton: import("react").ForwardRefExoticComponent<Omit<Omit<{
+    variant?: import("@seekbuddy/dsh-ui").ButtonVariant;
+    size?: 'md' | 'sm';
+    icon?: import("react").ReactNode;
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("react").RefAttributes<HTMLButtonElement>, "ref">, "className" | "variant"> & {
+    /** Extra class on the `<button>`, for layout. */
+    className?: string | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/seekbuddy/Switch.d.ts

@@ -0,0 +1,36 @@
+import type { ButtonHTMLAttributes, MouseEvent, ReactNode } from 'react';
+/** `large` = 44×22 (antd default), `medium` = 36×20 (default), `small` = 28×16 for dense rows and table cells. */
+export type SwitchSize = 'large' | 'medium' | 'small';
+export interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'onClick' | 'children' | 'type' | 'role' | 'aria-checked' | 'defaultValue'> {
+    /** Controlled state; when given, the caller owns it and `defaultChecked` is ignored. */
+    checked?: boolean | undefined;
+    /** Initial state for the uncontrolled form. */
+    defaultChecked?: boolean | undefined;
+    /** Alias of `defaultChecked` (antd parity). */
+    defaultValue?: boolean | undefined;
+    /** Content shown inside the track while on (short text or a 12px icon). */
+    checkedChildren?: ReactNode;
+    /** Content shown inside the track while off. */
+    unCheckedChildren?: ReactNode;
+    /** Blocks clicks and dims the switch; `onChange` does not fire. */
+    disabled?: boolean | undefined;
+    /** Track size; see `SwitchSize`. Default `medium`. */
+    size?: SwitchSize | undefined;
+    /** Fires when the value flips (after `onClick`); not fired while `disabled`. */
+    onChange?: ((checked: boolean, event: MouseEvent<HTMLButtonElement>) => void) | undefined;
+    /** Fires on every click with the value the switch is about to take. */
+    onClick?: ((checked: boolean, event: MouseEvent<HTMLButtonElement>) => void) | undefined;
+}
+/**
+ * Binary on/off toggle (`role="switch"`, WAI-ARIA switch pattern) with the antd `Switch` prop
+ * shape. Upstream's own `Switch` is a minimal, fully controlled control with a different prop shape; this
+ * one keeps antd's. Colours follow upstream's: on track
+ * `--dsw-alias-brand-primary` with thumb and track text in `--dsw-alias-label-primary-foreground`,
+ * off track a 40 % `color-mix` of `--dsw-alias-label-primary` with a `--dsw-alias-switch-thumb`
+ * thumb; capsule and thumb are true circles (`corner-shape: round`); no motion. Differences from antd (deliberate, only these two): the default `size` is `medium`
+ * (36×20) rather than `large`, and there is no `loading` prop.
+ *
+ * Accessibility: a switch without `checkedChildren` / `unCheckedChildren` is purely graphical, so
+ * pass `aria-label` (or `aria-labelledby` pointing at the visible row label).
+ */
+export declare function Switch({ checked, defaultChecked, defaultValue, checkedChildren, unCheckedChildren, disabled, size, onChange, onClick, className, ...rest }: SwitchProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Tabs.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode } from 'react';
+export interface TabItem<T extends string> {
+    /** Stable identity of the tab; also the value handed to `onChange` (antd `items[].key`). */
+    key: T;
+    /** Visible tab text. */
+    label: ReactNode;
+    /** Optional count badge; omitted when undefined. */
+    count?: number | undefined;
+    /** Skipped by the arrow keys and not selectable. */
+    disabled?: boolean | undefined;
+    /**
+     * Optional panel content. When any item carries `children`, the component renders the
+     * active item's panel itself (`role="tabpanel"`, wired with `aria-controls` / `aria-labelledby`).
+     * Leave it out when the panel is routed content the caller renders (for example a router outlet).
+     */
+    children?: ReactNode | undefined;
+}
+export interface TabsProps<T extends string> {
+    /** Accessible name of the tab list ("Skill views"). */
+    label: string;
+    /** Tabs in display order. */
+    items: ReadonlyArray<TabItem<T>>;
+    /** Controlled selection (antd `activeKey`); the caller owns it (URL state, useState, …). */
+    activeKey: T;
+    /** Called with the key of the tab the user selects. */
+    onChange: (key: T) => void;
+    /**
+     * DOM id of a caller-rendered panel showing the selected tab's content. Every tab then declares
+     * `aria-controls={panelId}` and gets the id `<panelId>-tab-<key>` for the panel's `aria-labelledby`.
+     * Ignored when items carry `children` (ids are generated and wired automatically).
+     */
+    panelId?: string | undefined;
+    /**
+     * Type scale of the tab labels: `sm` = `--dsw-font-xxs-12` (default; toolbars and in-card switches),
+     * `md` = `--dsw-font-s-14`, `lg` = `--dsw-font-base-16` (page-level view switches).
+     */
+    size?: 'sm' | 'md' | 'lg' | undefined;
+    /** Bold labels: every tab takes the `-strong-` variant of its size's font token (weight 600 in the theme). */
+    bold?: boolean | undefined;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Underline tab list (WAI-ARIA tabs, automatic activation): roving tabindex, arrow /
+ * Home / End keys move selection and focus, disabled tabs are skipped. Upstream ships
+ * no Tabs — its view switchers are rows of `Pill` — so this package provides one.
+ * Data-driven like antd's `items`.
+ */
+export declare function Tabs<T extends string>({ label, items, activeKey, onChange, panelId, size, bold, className, }: TabsProps<T>): import("react").JSX.Element;

package/dist/types/seekbuddy/Timeline.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+/** Run state shown by the left badge: grey spinner / green check / red cross / grey dash. */
+export type TimelineStatus = 'running' | 'succeeded' | 'failed' | 'canceled';
+export interface TimelineItem {
+    /** Stable identity of the entry (React key). */
+    key: string;
+    /** Run state shown by the left badge. */
+    status: TimelineStatus;
+    /** Title line; may carry a `Pill` tag or other inline nodes. */
+    title: ReactNode;
+    /** Grey metadata parts (trigger kind, time, duration); the component spaces them. */
+    meta?: ReadonlyArray<ReactNode> | undefined;
+    /** Optional third line — rendered in the error color for `failed`, grey otherwise. */
+    message?: ReactNode | undefined;
+    /** When given the whole entry becomes a button (keep `message` free of interactive nodes). */
+    onSelect?: (() => void) | undefined;
+}
+export interface TimelineGroup {
+    /** Stable identity of the group (React key). */
+    key: string;
+    /** Group heading such as a date bucket ("Today"); omit for a headless single group. */
+    heading?: ReactNode | undefined;
+    /** Entries of the group, in display order. */
+    items: ReadonlyArray<TimelineItem>;
+}
+export interface TimelineProps {
+    /** Accessible name of the whole timeline ("Run history"). */
+    label: string;
+    /** Screen-reader text per status; badges themselves are aria-hidden. Copy comes from the caller's locale. */
+    statusLabels: Readonly<Record<TimelineStatus, string>>;
+    /** Groups in display order; ordering and bucketing are the caller's. */
+    groups: ReadonlyArray<TimelineGroup>;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * Vertical run timeline: date-bucket groups,
+ * each an ordered list of entries with a status badge, title, grey meta line, optional message
+ * and a rail that runs continuously inside a group. Data-driven like antd's `items`; grouping,
+ * sorting, copy and time formatting stay with the caller. Upstream ships no Timeline.
+ */
+export declare function Timeline({ label, statusLabels, groups, className }: TimelineProps): import("react").JSX.Element;

package/dist/types/seekbuddy/Upload.d.ts

@@ -0,0 +1,101 @@
+/** `button`: a trigger button above the list. `dragger`: a dashed drop zone above the list. */
+export type UploadLayout = 'button' | 'dragger';
+export type UploadStatus = 'uploading' | 'done' | 'error';
+export interface UploadItem {
+    /** Stable identity of the item. */
+    uid: string;
+    /** File name shown in the list. */
+    name: string;
+    /** Bytes. */
+    size: number;
+    /** Transfer state of the item. */
+    status: UploadStatus;
+    /** 0–100. */
+    percent: number;
+    /** Present for files picked locally; absent on items the caller backfills from history. */
+    file?: File | undefined;
+    /** Resolved value of `upload()`. */
+    response?: unknown;
+    /** `Error.message` when `upload()` rejected. */
+    error?: string | undefined;
+    /** Address of a backfilled item, for `onPreview`. */
+    url?: string | undefined;
+}
+/** Why a picked file was refused before entering the list. */
+export type UploadRejectReason = 'accept' | 'size' | 'count';
+export interface UploadRejection {
+    /** The refused file. */
+    file: File;
+    /** Which check refused it. */
+    reason: UploadRejectReason;
+}
+/** All user-visible text, localized by the caller. */
+export interface UploadLabels {
+    /** Button caption; the drop zone's title in the `dragger` layout. */
+    trigger: string;
+    /** Caption under the trigger, e.g. ".zip only, up to 10 MB". */
+    hint?: string | undefined;
+    /** `aria-label` of the file list. */
+    list: string;
+    /** `aria-label` of an item's remove button. */
+    remove: string;
+    /** `aria-label` of a failed item's retry button. */
+    retry: string;
+    /** Status text of an item in progress; also names its progress bar. */
+    uploading: string;
+    /** Status text of a finished item. */
+    done: string;
+    /** Status text of a failed item. */
+    error: string;
+}
+export interface UploadProps {
+    /** Default `button`. */
+    layout?: UploadLayout | undefined;
+    /** Same grammar as the input `accept` attribute; non-matching files go to `onReject('accept')`. */
+    accept?: string | undefined;
+    /** Default `false`: a drop of several files keeps the first. */
+    multiple?: boolean | undefined;
+    /** Upper bound on list length; `1` makes a new file replace the current one (antd). */
+    maxCount?: number | undefined;
+    /** Bytes; larger files go to `onReject('size')`. */
+    maxSize?: number | undefined;
+    /** Disables picking, dropping, retry and remove. */
+    disabled?: boolean | undefined;
+    /** Controlled list; echo `onChange` back. Omit for uncontrolled with `defaultItems`. */
+    items?: UploadItem[] | undefined;
+    /** Initial list when uncontrolled. */
+    defaultItems?: UploadItem[] | undefined;
+    /** Extra check after the built-in ones (e.g. a ZIP magic number); `false` or a rejection keeps the file out. */
+    beforeUpload?: ((file: File, files: File[]) => boolean | Promise<boolean>) | undefined;
+    /**
+     * The only transport hook (antd `customRequest`). Resolve → `done` with the value as `response`;
+     * reject → `error` with the message. `signal` aborts when the item is removed mid-flight.
+     */
+    upload: (file: File, context: {
+        onProgress: (percent: number) => void;
+        signal: AbortSignal;
+    }) => Promise<unknown>;
+    /** Every list change: additions, progress, completion, removal. */
+    onChange?: ((items: UploadItem[]) => void) | undefined;
+    /** Files refused by `accept` / `maxSize` / `maxCount`, batched per pick, for the caller to toast. */
+    onReject?: ((rejections: UploadRejection[]) => void) | undefined;
+    /** Return `false` to keep the item. */
+    onRemove?: ((item: UploadItem) => boolean | Promise<boolean>) | undefined;
+    /** Makes file names clickable. */
+    onPreview?: ((item: UploadItem) => void) | undefined;
+    /** Default `true`. */
+    showList?: boolean | undefined;
+    /** All visible and screen-reader text; see `UploadLabels`. */
+    labels: UploadLabels;
+    /** Extra class on the root element, for layout. */
+    className?: string | undefined;
+}
+/**
+ * File picker with a status list: pick or drop → built-in `accept` / `maxSize` / `maxCount`
+ * filter → `beforeUpload` → the item enters the list as `uploading` and `upload()` runs with a
+ * progress callback and an abort signal. The component never talks to the network itself — the
+ * transport (multipart POST, presigned PUT, …) belongs to the caller. Text comes
+ * from `labels`; the component has no strings of its own. Client Component (state, refs),
+ * aggregate entry only.
+ */
+export declare function Upload({ layout, accept, multiple, maxCount, maxSize, disabled, items, defaultItems, beforeUpload, upload, onChange, onReject, onRemove, onPreview, showList, labels, className, }: UploadProps): import("react").JSX.Element;