@k2b/ui 0.1.0-rc.0 → 0.1.0

package/dist/types/content/Calendar.d.ts

@@ -0,0 +1,115 @@
+import { type LinkNavigateEvent } from "@k2b/ssr/nav";
+import { type DateContext } from "@k2b/stdlib";
+import type { JSX } from "solid-js";
+export type CalendarView = "day" | "week" | "month" | "year" | "mobile-month";
+export type CalendarEventColor = "blue" | "emerald" | "amber" | "red" | "violet" | "cyan" | "zinc";
+export type CalendarEvent = {
+    id: string;
+    title: string;
+    start: Date | string;
+    end?: Date | string;
+    allDay?: boolean;
+    color?: CalendarEventColor;
+    colorHex?: string;
+    href?: string;
+    dataSpaceItemId?: string;
+    meta?: string;
+    description?: string;
+    display?: "event" | "background";
+    location?: string;
+    calendarName?: string;
+    attendees?: CalendarAttendee[];
+    resources?: CalendarResource[];
+    recurrence?: CalendarRecurrence;
+};
+export type CalendarAttendee = {
+    name: string;
+    status?: "accepted" | "declined" | "tentative" | "needs-action";
+};
+export type CalendarResource = {
+    name: string;
+    kind?: "room" | "equipment" | "link" | "other";
+};
+export type CalendarRecurrence = {
+    rrule: string;
+    exdate?: Array<Date | string>;
+    recurrenceId?: Date | string;
+};
+export type CalendarLabels = Partial<{
+    today: string;
+    day: string;
+    week: string;
+    month: string;
+    year: string;
+    allDay: string;
+    noEvents: string;
+    previous: string;
+    next: string;
+}>;
+export type CalendarEventRenderContext = {
+    compact: boolean;
+    fill: boolean;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    durationHours: number;
+    timeLabel: string;
+};
+export type CalendarProps = {
+    date: Date | string;
+    events: CalendarEvent[];
+    view?: CalendarView;
+    views?: CalendarView[];
+    labels?: CalendarLabels;
+    /** stdlib date context used for timezone-aware rendering and calendar math. */
+    dateConfig?: DateContext;
+    /** Convenience override for dateConfig.timeZone. */
+    timeZone?: string;
+    firstDayOfWeek?: 0 | 1;
+    withWeekNumbers?: boolean;
+    startHour?: number;
+    endHour?: number;
+    visibleStartHour?: number;
+    visibleEndHour?: number;
+    allDayMaxHeightRem?: number;
+    hideAllDay?: boolean;
+    selectedDate?: Date | string;
+    selectedEventId?: string;
+    dayBadges?: Record<string, CalendarDayBadge>;
+    getViewHref?: (view: CalendarView) => string;
+    getDateHref?: (date: Date, view: CalendarView) => string;
+    getEventHref?: (event: CalendarEvent) => string | undefined;
+    renderEvent?: (event: CalendarEvent, context: CalendarEventRenderContext) => JSX.Element;
+    /** Progressively enhance canonical calendar links after the app has loaded their target state. */
+    onNavigate?: (event: LinkNavigateEvent) => void | Promise<void>;
+    /** Progressively enhance canonical links without a document view transition. */
+    onNavigateHref?: (href: string) => void;
+    /** Optionally preload the target behind a canonical calendar link. */
+    onPrefetch?: (href: string) => void;
+    navigationPending?: boolean;
+    onViewChange?: (view: CalendarView) => void;
+    onDateChange?: (date: Date, view: CalendarView) => void;
+    /** One activation contract for pointer and keyboard input. */
+    onEventActivate?: (event: CalendarEvent) => void;
+    /** Pointer gesture used for activation. Keyboard activation is always immediate. */
+    eventActivation?: "single" | "double";
+    onEventDrop?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
+    onEventResize?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
+    onSlotActivate?: (slot: CalendarEventTimeChange) => void;
+    /** Pointer gesture used for empty slots. Keyboard activation is always immediate. */
+    slotActivation?: "single" | "double";
+    toolbarActions?: JSX.Element;
+    toolbarContent?: JSX.Element;
+    class?: string;
+};
+export type CalendarEventTimeChange = {
+    start: Date;
+    end: Date;
+    allDay?: boolean;
+};
+export type CalendarDayBadge = {
+    icon?: string;
+    label: string;
+};
+declare const Calendar: (props: CalendarProps) => JSX.Element;
+export default Calendar;

package/dist/types/content/Chart.d.ts

@@ -0,0 +1,90 @@
+import { charts } from "@k2b/stdlib";
+import type { JSX } from "solid-js";
+import { type StateTimelineChartOptions } from "./chart-state-timeline";
+/**
+ * Chart — minimal Solid wrapper around `stdlib.charts`.
+ *
+ * **Live-update story.** `charts.<kind>(opts)` returns an SVG string;
+ * Solid's `innerHTML` is reactive, so any time a prop (signal, store
+ * slice, derived value) changes, the SVG re-renders. No manual
+ * subscription, no imperative DOM patching. Trade-off: every change
+ * is a full SVG re-build, not a diff — fine for dashboard cadences
+ * (poll, websocket, store updates). Don't use this for 60fps streaming.
+ *
+ * **Sizing.** stdlib emits `<svg viewBox="0 0 W H">` with no width/
+ * height attributes, so the SVG would otherwise fall back to the
+ * browser's replaced-element default (300×150) and either overflow
+ * or look squished. We measure the wrapping `<div>` with a
+ * ResizeObserver and pass the actual pixel dimensions to stdlib —
+ * the viewBox matches the container, no aspect distortion, no
+ * letterboxing. Sizing the wrapper itself is the caller's job
+ * (`style={{ height: "14rem" }}`, an app class, a flex child, …).
+ * On SSR (no observer)
+ * the chart renders at stdlib's default size; the first client-side
+ * frame re-measures and re-renders.
+ *
+ * One documented exception: `kind: "stateTimeline"` derives its own
+ * initial height from the row count and legend via
+ * `stateTimelineHeight()`, because a timeline's height is a function of
+ * how many rows it has rather than of the layout around it. Every other
+ * kind starts at 280px until the observer reports the real box. Layout
+ * code that sizes charts uniformly must account for this.
+ *
+ * **Why so thin.** The props are a discriminated union over each
+ * stdlib chart function — `kind: "line"` brings in exactly the params
+ * `charts.line` expects, `kind: "bar"` brings in `charts.bar`'s, etc.
+ * Options stay aligned with stdlib without renaming. Shared interactive
+ * layers add bounded pan / zoom controls to maps and state timelines, plus
+ * nearest-point hover and keyboard inspection for line charts.
+ * If stdlib gains a new option, it's automatically available at every
+ * callsite.
+ *
+ * **Theming.** stdlib charts use `currentColor` for axes / ticks /
+ * tick labels — set the wrapping element's `color` and everything
+ * inherits. Series colors come from `--stdlib-chart-c1..c8` CSS
+ * custom properties; override on the parent for per-chart palettes.
+ *
+ * ```tsx
+ * <Chart kind="line" style={{ height: "12rem" }}
+ *        series={[{ data: points() }]}
+ *        yAxis={{ format: v => `€${v}k` }} />
+ *
+ * <Chart kind="donut" style={{ height: "12rem" }} data={slices()} />
+ *
+ * <Chart kind="sparkline" style={{ width: "6rem", height: "1.5rem" }} data={trend()} />
+ *
+ * <Chart kind="map" style={{ height: "16rem" }} series={locations()} interactive />
+ * ```
+ */
+/** All chart kinds shipped by `stdlib.charts`. */
+export type ChartKind = keyof typeof charts;
+export type ChartLabels = Partial<{
+    empty: string;
+    series: string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    interactiveLine: string;
+    zoomIn: string;
+    zoomOut: string;
+    resetMap: string;
+    resetTimeline: string;
+}>;
+/**
+ * Per-kind props: `kind` discriminator + the exact options that
+ * `charts.<kind>` accepts, **minus** `width` / `height` (the wrapper
+ * owns those — they're derived from container measurement). Solid's
+ * component model handles discriminated unions natively, so callsites
+ * get full type safety.
+ */
+export type ChartProps = {
+    [K in ChartKind]: {
+        kind: K;
+        class?: string;
+        style?: JSX.CSSProperties | string;
+        labels?: ChartLabels;
+    } & (K extends "stateTimeline" ? StateTimelineChartOptions : Omit<Parameters<(typeof charts)[K]>[0], "width" | "height"> & (K extends "map" | "line" ? {
+        interactive?: boolean;
+    } : {}));
+}[ChartKind];
+declare const Chart: (props: ChartProps) => JSX.Element;
+export default Chart;

package/dist/types/content/CodeDisplay.d.ts

@@ -0,0 +1,11 @@
+import { type CodeDisplayLanguage } from "./code-highlight";
+export type { CodeDisplayLanguage };
+export type CodeDisplayProps = {
+    code: string;
+    title?: string;
+    language?: CodeDisplayLanguage;
+    copy?: boolean;
+    lineNumbers?: boolean;
+    class?: string;
+};
+export default function CodeDisplay(props: CodeDisplayProps): import("solid-js").JSX.Element;

package/dist/types/content/DataTable.d.ts

@@ -0,0 +1,113 @@
+import { type JSX } from "solid-js";
+export type DataTableColumn<T> = {
+    id: string;
+    header: JSX.Element | ((ctx: {
+        col: DataTableColumn<T>;
+    }) => JSX.Element);
+    subtitle?: JSX.Element | ((ctx: {
+        col: DataTableColumn<T>;
+    }) => JSX.Element);
+    value?: keyof T | ((row: T) => unknown);
+    class?: string;
+    headerClass?: string;
+    cellClass?: string;
+    /** Defaults to right for numeric values and left for everything else. */
+    align?: "left" | "center" | "right";
+    /**
+     * Marks the column sortable. Pass a string when the server's sort key
+     * differs from the column id — they often do, because one column can show a
+     * rate while another sorts by the absolute count behind it.
+     */
+    sortable?: boolean | string;
+};
+export type DataTableSort = {
+    key: string;
+    direction: "asc" | "desc";
+};
+export type DataTableRenderCell<T> = (ctx: {
+    row: T;
+    col: DataTableColumn<T>;
+    value: unknown;
+    render: (value: unknown) => JSX.Element;
+}) => JSX.Element;
+export type DataTableRenderHeader<T> = (ctx: {
+    col: DataTableColumn<T>;
+    render: () => JSX.Element;
+}) => JSX.Element;
+export type DataTableFooter<T> = {
+    values?: Record<string, unknown>;
+    renderCell?: (ctx: {
+        col: DataTableColumn<T>;
+        value: unknown;
+        render: (value: unknown) => JSX.Element;
+    }) => JSX.Element;
+};
+export type DataTableProps<T> = {
+    rows: readonly T[];
+    columns: readonly DataTableColumn<T>[];
+    /** Accessible name for a standalone table region. Defaults to "Data table". */
+    ariaLabel?: string;
+    /** ID of a visible heading that labels the table region. Takes precedence over ariaLabel. */
+    ariaLabelledBy?: string;
+    getRowId?: (row: T) => string;
+    /** Current server-side ordering, or null when the default applies. */
+    sort?: DataTableSort | null;
+    /**
+     * Link target for a sortable header. Link-based because every admin table is
+     * server-rendered: sorting is a query change, not client state.
+     */
+    sortHref?: (next: DataTableSort) => string;
+    selectedRowId?: string | null;
+    rowClass?: string | ((row: T) => string | undefined);
+    hoverRows?: boolean;
+    onRowClick?: (row: T) => void;
+    onRowDoubleClick?: (row: T) => void;
+    renderCell?: DataTableRenderCell<T>;
+    renderHeader?: DataTableRenderHeader<T>;
+    footer?: DataTableFooter<T>;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onLoadMore?: () => void;
+    empty?: JSX.Element;
+    density?: "compact" | "normal";
+    stickyHeader?: boolean;
+    highlightColumns?: boolean;
+    verticalAlign?: "top" | "middle" | "bottom";
+    cellContentClass?: string;
+    fillHeight?: boolean;
+    /** Visual frame for a standalone table. Defaults preserve the legacy class-based behavior. */
+    surface?: "paper" | "plain";
+    class?: string;
+    /** Additional classes for the table element. Core table geometry is always retained. */
+    tableClass?: string;
+    scrollPreserveKey?: string | false;
+};
+export type DataTablePanelProps = {
+    children: JSX.Element;
+    class?: string;
+};
+export type DataTableHeaderProps = {
+    title: string;
+    subtitle?: string;
+    children?: JSX.Element;
+    as?: "h1" | "h2" | "h3";
+    size?: "sm" | "md";
+    class?: string;
+};
+export type DataTableControlsProps = {
+    children: JSX.Element;
+    class?: string;
+};
+export type DataTablePanelFooterProps = {
+    children: JSX.Element;
+    class?: string;
+};
+type DataTableComponent = {
+    <T>(props: DataTableProps<T>): JSX.Element;
+    Panel: (props: DataTablePanelProps) => JSX.Element;
+    Header: (props: DataTableHeaderProps) => JSX.Element;
+    Controls: (props: DataTableControlsProps) => JSX.Element;
+    Footer: (props: DataTablePanelFooterProps) => JSX.Element;
+};
+declare const DataTable: DataTableComponent;
+export default DataTable;

package/dist/types/content/Docs.d.ts

@@ -0,0 +1,52 @@
+import { type JSX } from "solid-js";
+import type { CodeDisplayLanguage } from "./CodeDisplay";
+export type DocCodeHighlighter = (code: string) => string;
+export type DocCodeProps = {
+    code: string;
+    title?: string;
+    language?: CodeDisplayLanguage;
+    highlight?: DocCodeHighlighter;
+    format?: (code: string) => string;
+    copy?: boolean;
+    copyText?: string;
+    lineNumbers?: boolean;
+    class?: string;
+};
+export type DocNoteVariant = "info" | "tip" | "warning";
+export type DocRow = {
+    title: string;
+    icon?: string;
+    text: JSX.Element;
+};
+export type DocConcept = {
+    title: string;
+    icon: string;
+    text: JSX.Element;
+};
+export declare const DocPage: (props: {
+    children: JSX.Element;
+    class?: string;
+}) => JSX.Element;
+export declare const DocLead: (props: {
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocSection: (props: {
+    title: string;
+    eyebrow?: string;
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocInlineCode: (props: {
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocCode: (props: DocCodeProps) => JSX.Element;
+export declare const DocConceptGrid: (props: {
+    items: DocConcept[];
+}) => JSX.Element;
+export declare const DocRows: (props: {
+    items: DocRow[];
+}) => JSX.Element;
+export declare const DocNote: (props: {
+    title: string;
+    variant?: DocNoteVariant;
+    children: JSX.Element;
+}) => JSX.Element;

package/dist/types/content/FileBrowser.d.ts

@@ -0,0 +1,40 @@
+import { type FileTreeEntry } from "./FileTree";
+import { type FileViewContent, type FileViewRenderer } from "./FileView";
+export type FileSource = {
+    list(): Promise<FileTreeEntry[]>;
+    read(path: string): Promise<FileViewContent>;
+    write?(path: string, content: string, encoding?: "utf8" | "base64"): Promise<void>;
+    remove?(path: string): Promise<void>;
+    rename?(from: string, to: string): Promise<void>;
+    upload?(dirPath: string, files: File[]): Promise<void>;
+    downloadHref?(path: string): string | null;
+    /** Paths matching this predicate stay read-only even when the source can write (e.g. /input). */
+    isReadOnly?(path: string): boolean;
+};
+export type FileBrowserPanelProps = {
+    source: FileSource;
+    /** Hide every mutating affordance while retaining file selection and downloads. */
+    readOnly?: boolean;
+    /** Refetch entries when this host-controlled value changes. */
+    refreshKey?: unknown;
+    /** Preselect a file once entries are loaded. */
+    initialPath?: string;
+    /** Mirrors file selection into route state when the host needs durable navigation. */
+    onSelectedPathChange?: (path: string | null) => void;
+    /** Per-instance preview extensions forwarded to FileView. */
+    renderers?: readonly FileViewRenderer[];
+    /** Optional host copy/policy for leaving an unsaved file. */
+    confirmDiscard?: (path: string, nextPath: string | null) => boolean | Promise<boolean>;
+    /** Fixed shell height — the panes scroll inside it. */
+    class?: string;
+    /** Optional imperative refresh used by realtime owners that must await the visible update. */
+    registerRefresh?: (refresh: () => Promise<void>) => void | (() => void);
+};
+export declare function FileBrowserPanel(props: FileBrowserPanelProps): import("solid-js").JSX.Element;
+/** Open the file browser as a dialog. Returns when the dialog closes. */
+export declare const openFileBrowser: (options: {
+    source: FileSource;
+    title?: string;
+    subtitle?: string;
+    icon?: string;
+}) => Promise<void>;

package/dist/types/content/FileTree.d.ts

@@ -0,0 +1,29 @@
+import { type DropdownItem } from "../actions/Dropdown";
+import { type FileTreeEntry } from "./file-tree";
+export type { FileTreeEntry } from "./file-tree";
+/** Presence of a callback enables the matching UI affordance. */
+export type FileTreeActions = {
+    rename?: (path: string, nextName: string) => void | Promise<void>;
+    remove?: (path: string) => void | Promise<void>;
+    createFile?: (dirPath: string) => void | Promise<void>;
+    createFolder?: (dirPath: string) => void | Promise<void>;
+    /** Enables drag & drop of files and folders onto folders (and the tree root). */
+    move?: (path: string, targetDir: string) => void | Promise<void>;
+    /** Download menu entry — folders arrive as "Download as ZIP". */
+    download?: (path: string, isFolder: boolean) => void | Promise<void>;
+};
+export type FileTreeProps = {
+    entries: FileTreeEntry[];
+    selectedPath?: string | null;
+    onSelect?: (entry: FileTreeEntry) => void;
+    /** Controlled expansion; omit for internal state (folders start expanded). */
+    expandedPaths?: Set<string>;
+    onExpandedChange?: (expanded: Set<string>) => void;
+    /** Extra context-menu items per entry, merged above the built-in actions. */
+    contextMenu?: (entry: FileTreeEntry) => DropdownItem[];
+    actions?: FileTreeActions;
+    /** Accessible name for the tree. */
+    label?: string;
+    class?: string;
+};
+export default function FileTree(props: FileTreeProps): import("solid-js").JSX.Element;

package/dist/types/content/FileView.d.ts

@@ -0,0 +1,59 @@
+/**
+ * FileView — renders one file through a small renderer registry keyed by
+ * media type / path. Editing is enabled purely by the presence of `save`;
+ * without it every renderer is read-only. IDE-style chrome: editors reuse
+ * the markdown editor's surface (toolbar with an in-toolbar save, Ctrl/Cmd+S),
+ * previews are quiet paper panels with icon-only actions overlaid top-right.
+ * Custom renderers are passed per instance, which keeps SSR requests and
+ * independently mounted applications isolated.
+ */
+import { type Component, type JSX } from "solid-js";
+import { type FileViewFile } from "./file-view-preview";
+export type { FileViewFile, FileViewPreviewKind } from "./file-view-preview";
+export { canPreviewFile, getFileViewPreviewKind } from "./file-view-preview";
+export type FileViewContent = {
+    encoding: "utf8" | "base64";
+    content: string;
+    mediaType: string;
+};
+export type FileViewProps = {
+    file: FileViewFile;
+    load: () => Promise<FileViewContent>;
+    /** Refetch the current path when this host-owned revision changes. */
+    revision?: unknown;
+    /** Register an awaitable refresh for the currently visible preview. */
+    registerRefresh?: (refresh: () => Promise<void>) => void | (() => void);
+    /** Presence enables editing for text-based renderers. */
+    save?: (content: string) => Promise<void>;
+    /** Authenticated inline URL used by browser-native image, PDF, audio, and video previews. */
+    previewHref?: string | null;
+    downloadHref?: string | null;
+    /** App-specific renderers matched before the built-ins for this instance. */
+    renderers?: readonly FileViewRenderer[];
+    /** Reports local edit state so a parent browser can guard navigation. */
+    onDirtyChange?: (dirty: boolean) => void;
+    class?: string;
+};
+export type FileViewRendererProps = {
+    file: FileViewFile;
+    content: FileViewContent;
+    previewHref: string | null;
+    downloadHref: string | null;
+    /** Null when the file is read-only. */
+    editor: {
+        draft: () => string;
+        setDraft: (value: string) => void;
+        dirty: () => boolean;
+        saving: () => boolean;
+        save: () => Promise<void>;
+    } | null;
+};
+export type FileViewRenderer = {
+    id: string;
+    match: (file: FileViewFile, content: FileViewContent) => boolean;
+    component: Component<FileViewRendererProps>;
+    /** Text renderers that support the edit affordance when `save` is present. */
+    editable?: boolean;
+};
+export declare const formatFileViewSize: (bytes: number) => string;
+export default function FileView(props: FileViewProps): JSX.Element;

package/dist/types/content/Lightbox.d.ts

@@ -0,0 +1,16 @@
+export type LightboxImage = {
+    src: string;
+    alt?: string;
+    downloadUrl?: string;
+};
+type LightboxProps = {
+    images: LightboxImage[];
+    initialIndex?: number;
+    onClose: () => void;
+};
+/**
+ * Minimal, accessible lightbox using native <dialog>.
+ * Supports keyboard navigation, touch swipe gestures, and screen readers.
+ */
+export default function Lightbox(props: LightboxProps): import("solid-js").JSX.Element;
+export {};

package/dist/types/content/LogEntriesTable.d.ts

@@ -0,0 +1,14 @@
+export type LogTableEntry = {
+    id: number | string;
+    level: string;
+    source: string;
+    message: string;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+};
+type Props = {
+    entries: readonly LogTableEntry[];
+    emptyMessage?: string;
+};
+export default function LogEntriesTable(props: Props): import("solid-js").JSX.Element;
+export {};

package/dist/types/content/MarkdownView.d.ts

@@ -0,0 +1,46 @@
+type CommonProps = {
+    /** Optional additional CSS classes */
+    class?: string;
+    /**
+     * Visual heading scale. Markdown heading levels and document structure stay
+     * unchanged.
+     */
+    headingScale?: "compact" | "normal" | "large";
+};
+export type MarkdownViewProps = CommonProps & ({
+    /** Untrusted Markdown. Raw HTML and unsafe link protocols are escaped. */
+    markdown: string;
+    /** Exact standalone text tokens to emphasize without changing Markdown parsing or trusted-HTML boundaries. */
+    inlineTokens?: readonly string[];
+    trustedHtml?: never;
+} | {
+    /** Explicitly trusted, already-rendered HTML. The caller owns sanitization. */
+    trustedHtml: string;
+    markdown?: never;
+    inlineTokens?: never;
+});
+export type MarkdownRenderOptions = {
+    inlineTokens?: readonly string[];
+};
+export declare const renderSafeMarkdown: (markdown: string, options?: MarkdownRenderOptions) => string;
+/**
+ * Markdown View Component (SSR)
+ *
+ * Renders untrusted Markdown safely by default. Raw HTML and unsafe link
+ * protocols are escaped. Already-rendered HTML requires the deliberately named
+ * `trustedHtml` boundary; the caller owns sanitization in that mode.
+ *
+ * @example
+ * ```tsx
+ * import { MarkdownView } from "@k2b/ui";
+ *
+ * <MarkdownView markdown={source} />;
+ * ```
+ *
+ * @example Compact headings, e.g. inside comments or file previews:
+ * ```tsx
+ * <MarkdownView markdown={source} headingScale="compact" />;
+ * ```
+ */
+export default function MarkdownView(props: MarkdownViewProps): import("solid-js").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { type LinkNavigateEvent } from "@k2b/ssr/nav";
+import { type JSX } from "solid-js";
+export type PaginationProps = {
+    currentPage: number;
+    totalPages: number;
+    baseUrl: string;
+    onNavigate?: (event: LinkNavigateEvent) => void | Promise<void>;
+};
+/** Link-based pagination with directional navigation and compact mobile disclosure. */
+export declare const Pagination: (props: PaginationProps) => JSX.Element;

package/dist/types/content/PdfPreview.d.ts

@@ -0,0 +1,11 @@
+export type PdfPreviewRequest = () => Promise<Response | Blob>;
+export type PdfPreviewProps = {
+    request: PdfPreviewRequest;
+    disabled?: () => boolean;
+    title?: string;
+    buttonLabel?: string;
+    openButtonLabel?: string;
+    emptyText?: string;
+    class?: string;
+};
+export default function PdfPreview(props: PdfPreviewProps): import("solid-js").JSX.Element;

package/dist/types/content/RangePicker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * RangePicker — the time window every observability surface needs.
+ *
+ * Rendered as links rather than buttons on purpose: window selection is a
+ * server concern (the query, not the rendering), so it belongs in the URL and
+ * works without hydration. Callers supply the href per option, which is what
+ * lets each page keep its own other params intact — the hand-rolled copies
+ * differed exactly there, with one silently dropping every unrelated filter.
+ *
+ * The vocabulary stays with the caller too. Traces think in `10m…30d`, request
+ * telemetry in `1h…30d`, audit in days; a single hardcoded list would be wrong
+ * for most of them.
+ */
+export type RangeOption<T extends string> = {
+    value: T;
+    /** Defaults to the value, which is already short by convention (`24h`). */
+    label?: string;
+    href: string;
+};
+export type RangePickerProps<T extends string> = {
+    options: readonly RangeOption<T>[];
+    value: T;
+    /** Leading caption. Pass `null` to omit it in tight toolbars. */
+    label?: string | null;
+    /** Names the control for assistive tech; defaults to the visible label. */
+    ariaLabel?: string;
+    class?: string;
+};
+export default function RangePicker<T extends string>(props: RangePickerProps<T>): import("solid-js").JSX.Element;

package/dist/types/content/StructuredDataPreview.d.ts

@@ -0,0 +1,20 @@
+import { type MaybeAccessor } from "../inputs/field-contract";
+export type StructuredDataPreviewMode = "formatted" | "raw";
+export type StructuredDataValue = null | boolean | number | string | readonly StructuredDataValue[] | {
+    readonly [key: string]: StructuredDataValue;
+};
+export declare const isStructuredDataValue: (value: unknown, seen?: WeakSet<object>) => value is StructuredDataValue;
+export type StructuredDataPreviewProps = {
+    title?: string;
+    data: StructuredDataValue;
+    /** Controlled display mode. */
+    mode?: MaybeAccessor<StructuredDataPreviewMode>;
+    onModeChange?: (mode: StructuredDataPreviewMode) => void;
+    /** Initial mode for an uncontrolled preview. */
+    defaultMode?: StructuredDataPreviewMode;
+    copy?: boolean;
+    empty?: string;
+    maxRows?: number;
+    class?: string;
+};
+export default function StructuredDataPreview(props: StructuredDataPreviewProps): import("solid-js").JSX.Element;