@camstack/ui-library 0.1.39 → 0.1.41

package/dist/composites/addon-global-settings-form.d.ts

@@ -0,0 +1,60 @@
+import { ConfigUISchemaWithValues } from '@camstack/types';
+interface AddonGlobalSettingsFormTrpc {
+    addonSettings: {
+        getGlobalSettings: {
+            query: (input: {
+                addonId: string;
+                nodeId?: string;
+                overlay?: Record<string, unknown>;
+            }) => Promise<ConfigUISchemaWithValues | null>;
+        };
+        updateGlobalSettings: {
+            mutate: (input: {
+                addonId: string;
+                nodeId?: string;
+                patch: Record<string, unknown>;
+            }) => Promise<unknown>;
+        };
+    };
+}
+interface AddonGlobalSettingsFormProps {
+    readonly trpc: AddonGlobalSettingsFormTrpc;
+    readonly addonId: string;
+    readonly nodeId: string;
+    readonly title?: string;
+    readonly disabled?: boolean;
+    readonly onAfterChange?: () => void;
+    /** Bump to force refetch (e.g. after an external mutation). */
+    readonly refreshToken?: number;
+    /**
+     * Render as collapsible. When true, the form body is hidden until
+     * the operator expands the header (click). Defaults to open so
+     * callers that always want the form visible don't have to opt out.
+     */
+    readonly collapsible?: boolean;
+    /** When `collapsible`, start expanded (true) or collapsed (false). Defaults to false. */
+    readonly defaultOpen?: boolean;
+    /**
+     * - `'persist'` (default): edits call `updateGlobalSettings` and
+     *   re-fetch — the live store is mutated. Use in settings editors
+     *   (NodePipelineTab, device details).
+     * - `'override'`: edits stay local (never touch the store).
+     *   `onOverrideChange` receives the current override values on
+     *   every edit so the caller can pass them to a per-run action.
+     *   Use in the benchmark tabs — operator tweaks for a single
+     *   bench run without mutating the addon's saved settings.
+     */
+    readonly mode?: 'persist' | 'override';
+    /**
+     * Called on every edit when `mode: 'override'`. `patch` is the sparse
+     * diff vs the persisted baseline (only the fields the operator touched).
+     * `effective` is the baseline merged with the patch — every field a
+     * downstream action might need, with the operator's override applied.
+     * Callers that need to emit a full engine triple (runtime+backend+format)
+     * should read from `effective`, not `patch`, so partial edits (e.g.
+     * operator tweaks only `device`) still produce a complete payload.
+     */
+    readonly onOverrideChange?: (patch: Record<string, unknown>, effective: Record<string, unknown>) => void;
+}
+export declare function AddonGlobalSettingsForm({ trpc, addonId, nodeId, title, disabled, onAfterChange, refreshToken, collapsible, defaultOpen, mode, onOverrideChange, }: AddonGlobalSettingsFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/addon-page-props.d.ts

@@ -0,0 +1,12 @@
+import { TRPCClient } from '@trpc/client';
+import { AppRouter } from '@camstack/types';
+export interface AddonPageProps {
+    /** Vanilla tRPC client — fully typed access for non-React call sites. */
+    readonly trpc: TRPCClient<AppRouter>;
+    /** Current theme state */
+    readonly theme: {
+        readonly isDark: boolean;
+    };
+    /** Navigate to a route within the admin UI */
+    readonly navigate: (path: string) => void;
+}

package/dist/composites/agent-step-editor.d.ts

@@ -0,0 +1,15 @@
+import { PipelineAddonSchema, AgentAddonConfig, CameraStepOverridePatch } from '@camstack/types';
+export type EditorMode = 'agent' | 'device';
+export interface AgentStepEditorProps {
+    readonly mode: EditorMode;
+    readonly addon: PipelineAddonSchema;
+    /** L1 base — always visible as the "inherited" baseline. */
+    readonly agentDefault: AgentAddonConfig;
+    readonly agentNodeId: string;
+    /** Device mode only — current L2.5 patch for (agent, addon). */
+    readonly currentPatch?: CameraStepOverridePatch | null;
+    readonly onChangeAgentConfig?: (next: AgentAddonConfig) => void;
+    readonly onChangePatch?: (next: CameraStepOverridePatch | null) => void;
+    readonly engineFormat: string;
+}
+export declare function AgentStepEditor(props: AgentStepEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/app-shell/app-shell.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { SidebarProps } from './sidebar';
+export interface AppShellProps {
+    sidebar: SidebarProps;
+    header?: {
+        breadcrumbs?: {
+            label: string;
+            href?: string;
+        }[];
+        actions?: ReactNode;
+    };
+    /** Content shown in the center of the mobile top bar (e.g. logo) */
+    mobileLogo?: ReactNode;
+    /** Content shown on the right side of the mobile top bar (e.g. avatar menu) */
+    mobileActions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+export declare function AppShell({ sidebar, header, mobileLogo, mobileActions, children, className }: AppShellProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/app-shell/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sidebar-item';
+export * from './sidebar';
+export * from './app-shell';

package/dist/composites/app-shell/sidebar-item.d.ts

@@ -0,0 +1,10 @@
+import { LucideIcon } from 'lucide-react';
+export interface SidebarItemProps {
+    label: string;
+    icon: LucideIcon;
+    href: string;
+    badge?: string | number;
+    active?: boolean;
+    className?: string;
+}
+export declare function SidebarItem({ label, icon: Icon, href, badge, active, className, }: SidebarItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/app-shell/sidebar.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { SidebarItemProps } from './sidebar-item';
+export interface SidebarSection {
+    label?: string;
+    items: SidebarItemProps[];
+}
+export interface SidebarProps {
+    logo?: ReactNode;
+    sections: SidebarSection[];
+    footer?: SidebarItemProps[];
+    onNavigate?: () => void;
+    className?: string;
+}
+export declare function Sidebar({ logo, sections, footer, onNavigate, className }: SidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/audio-classification-list.d.ts

@@ -0,0 +1,20 @@
+export interface AudioClassification {
+    readonly className: string;
+    readonly score: number;
+}
+export interface AudioClassificationListProps {
+    /** Sorted classifications (highest score first) */
+    readonly classifications: readonly AudioClassification[];
+    /** Processing state indicator */
+    readonly processing?: boolean;
+    /** Inference time in ms */
+    readonly inferenceMs?: number;
+    /** Max items to show (default: 10) */
+    readonly maxItems?: number;
+    /** Optional className */
+    readonly className?: string;
+}
+/**
+ * Displays audio classification results as a ranked list with score bars.
+ */
+export declare function AudioClassificationList({ classifications, processing, inferenceMs, maxItems, className, }: AudioClassificationListProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/audio-level-waveform.d.ts

@@ -0,0 +1,35 @@
+export interface AudioLevelSample {
+    readonly dbfs: number;
+    readonly timestamp: number;
+}
+export interface AudioLevelWaveformProps {
+    /** Current dBFS level — push a new value to append to the internal ring buffer. */
+    readonly currentDbfs: number | null;
+    /** How many seconds of history to display (default 30) */
+    readonly durationSec?: number;
+    /** Max samples to keep in memory (default 120 ≈ 60s at 2 samples/s) */
+    readonly maxSamples?: number;
+    /** Height in pixels (default 64) */
+    readonly height?: number;
+    /** CSS class for the container */
+    readonly className?: string;
+    /** Bar color (CSS) */
+    readonly color?: string;
+    /** Clipping color when dBFS > threshold (default red) */
+    readonly clipColor?: string;
+    /** dBFS threshold for clipping color (default -6) */
+    readonly clipThreshold?: number;
+    /** Min dBFS to display (default -96) */
+    readonly minDbfs?: number;
+}
+/**
+ * Canvas-based live audio level waveform with internal state.
+ *
+ * Receives `currentDbfs` — each time it changes, a new sample is appended
+ * to an internal ring buffer and the canvas is redrawn. The component
+ * manages its own history, so callers just push the latest dBFS value.
+ *
+ * Designed to be fed from the `pipeline.audio-inference-result` event
+ * (each chunk, ~0.5s, produces one sample via `frame.level.dbfs`).
+ */
+export declare function AudioLevelWaveform({ currentDbfs, durationSec, maxSamples, height, className, color, clipColor, clipThreshold, minDbfs, }: AudioLevelWaveformProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/audio-waveform.d.ts

@@ -0,0 +1,20 @@
+export interface AudioWaveformProps {
+    /** Raw audio samples (mono Float32Array, -1..1 range) */
+    readonly samples: Float32Array | null;
+    /** Sample rate in Hz (for time axis labels) */
+    readonly sampleRate?: number;
+    /** Height in pixels */
+    readonly height?: number;
+    /** CSS class for the container */
+    readonly className?: string;
+    /** Waveform color (CSS color string) */
+    readonly color?: string;
+    /** Background color */
+    readonly bgColor?: string;
+}
+/**
+ * Canvas-based audio waveform visualization.
+ * Renders a waveform from Float32Array audio samples.
+ * Downsamples to pixel resolution for performance.
+ */
+export declare function AudioWaveform({ samples, sampleRate, height, className, color, bgColor, }: AudioWaveformProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/battery-badge.d.ts

@@ -0,0 +1,12 @@
+export interface BatteryStatusLike {
+    readonly percentage: number;
+    readonly charging: 'dc' | 'solar' | 'none';
+    readonly sleeping: boolean;
+}
+export interface BatteryBadgeProps {
+    readonly status: BatteryStatusLike | null | undefined;
+    /** `'compact'` shows only icon + %; `'full'` adds the source label. */
+    readonly variant?: 'compact' | 'full';
+    readonly className?: string;
+}
+export declare function BatteryBadge({ status, variant, className }: BatteryBadgeProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/composites/breadcrumb.d.ts

@@ -0,0 +1,25 @@
+export interface BreadcrumbItem {
+    /** Display label */
+    label: string;
+    /** If provided, renders as a clickable link. Last item is never a link. */
+    href?: string;
+    /** Click handler — used instead of href for SPA navigation */
+    onClick?: () => void;
+}
+export interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    className?: string;
+}
+/**
+ * Breadcrumb navigation component.
+ *
+ * Usage with react-router:
+ * ```tsx
+ * <Breadcrumb items={[
+ *   { label: 'Integrations', onClick: () => navigate('/integrations') },
+ *   { label: 'RTSP Cameras', onClick: () => navigate('/integrations/int_0001') },
+ *   { label: 'Front Door' },
+ * ]} />
+ * ```
+ */
+export declare function Breadcrumb({ items, className }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/camera-stream-player.d.ts

@@ -0,0 +1,87 @@
+import { ReactNode } from 'react';
+export type PlayerConnectionState = 'connecting' | 'playing' | 'error' | 'disconnected' | 'idle';
+/**
+ * Signaling function for WebRTC connection.
+ * Called by the player to establish the WebRTC session.
+ * Must return an RTCSessionDescription (the server's offer or answer depending on mode).
+ *
+ * Server-offer mode (default):
+ *   1. signalingFn is called with streamId → returns { sessionId, sdpOffer }
+ *   2. Player sets remote description (server offer), creates answer
+ *   3. Player calls answerFn(sessionId, sdpAnswer) to complete
+ *
+ * WHEP mode (legacy):
+ *   1. Player creates offer, gathers ICE
+ *   2. signalingFn is called with the client SDP offer → returns sdpAnswer
+ *   3. Player sets remote description (answer)
+ */
+export interface SignalingResult {
+    /** Server-offer mode: session ID + SDP offer from server */
+    sessionId: string;
+    sdpOffer: string;
+}
+/**
+ * Client-side capabilities sent to the server at session creation.
+ * The server uses these to pick the best native source for adaptive
+ * streams (e.g. a 320×180 thumbnail player on a slow link gets the
+ * camera's low stream rather than ffmpeg-transcoded 4K).
+ *
+ * All fields are optional — when omitted the server defaults to its
+ * highest-quality registered source.
+ */
+export interface ClientStreamHints {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    devicePixelRatio?: number;
+    downlinkMbps?: number;
+    prefersTier?: string;
+}
+export interface CameraStreamPlayerProps {
+    /** Server base URL (e.g. window.location.origin) */
+    serverUrl: string;
+    /**
+     * Stable key used for React reconciliation (the player remounts when
+     * this changes), the snapshot filename, and WHEP fallback URL. The
+     * value is opaque to the player — no parsing, no semantic meaning.
+     * Typical values: a `StreamChoice.id` (`'profile:high'`, `'stream:native:main'`).
+     */
+    streamKey: string;
+    /** Human-readable label shown in overlay */
+    label?: string;
+    /** Auto-play on mount (default: true) */
+    autoPlay?: boolean;
+    /** Start muted (default: true) */
+    muted?: boolean;
+    /** Show toolbar controls (default: true) */
+    showControls?: boolean;
+    /** Additional CSS classes for the root container */
+    className?: string;
+    /** Called on connection state change */
+    onStateChange?: (state: PlayerConnectionState) => void;
+    /** Called on error */
+    onError?: (error: string) => void;
+    /** Custom overlay rendered on top of the video */
+    overlay?: ReactNode;
+    /**
+     * Create a WebRTC session (server-offer signaling). When provided,
+     * uses server-offer mode instead of WHEP. The caller closes over the
+     * target (profile / cam-stream / adaptive) and any device context;
+     * the player just hands it the auto-derived `hints` (viewport,
+     * downlink) so the server can score adaptive selections.
+     */
+    createSession?: (hints?: ClientStreamHints) => Promise<SignalingResult>;
+    /**
+     * Send the client's SDP answer (server-offer signaling).
+     * Required when createSession is provided.
+     */
+    sendAnswer?: (sessionId: string, sdpAnswer: string) => Promise<void>;
+    /** Explicitly close the WebRTC session on server (cleanup on unmount). */
+    closeSession?: (sessionId: string) => Promise<void>;
+    /**
+     * Override client hints sent to the server at session creation.
+     * Values provided here replace the auto-computed browser values.
+     * Use for network simulation (benchmark) or manual tier forcing.
+     */
+    hintsOverride?: Partial<ClientStreamHints>;
+}
+export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, className, onStateChange, onError, overlay, createSession, sendAnswer, closeSession, hintsOverride, }: CameraStreamPlayerProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/code-block.d.ts

@@ -0,0 +1,6 @@
+export interface CodeBlockProps {
+    children: string;
+    maxHeight?: number;
+    className?: string;
+}
+export declare function CodeBlock({ children, maxHeight, className }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/config-form-builder.d.ts

@@ -0,0 +1,18 @@
+import { ConfigUISchema, FieldProbeResult } from '@camstack/types';
+import { ProbeState } from './config-form-field';
+export type TranslationFn = (key: string) => string;
+export declare function resolveLabel(value: string | undefined, t?: TranslationFn): string | undefined;
+interface FormBuilderProps {
+    schema: ConfigUISchema;
+    values: Record<string, unknown>;
+    onChange: (values: Record<string, unknown>) => void;
+    disabled?: boolean;
+    translationFn?: TranslationFn;
+    onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
+    /** External probe results from useProbeAll hook */
+    probeResults?: Record<string, ProbeState>;
+    /** Callback to clear a probe result when a field value changes */
+    onClearProbe?: (key: string) => void;
+}
+export declare function ConfigFormBuilder({ schema, values, onChange, disabled, translationFn, onTestField, probeResults, onClearProbe }: FormBuilderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/config-form-field.d.ts

@@ -0,0 +1,70 @@
+import { ConfigField, ConfigNodeSelectField, ConfigNodeMultiSelectField, FieldProbeResult } from '@camstack/types';
+import { TranslationFn } from './config-form-builder';
+/** Probe state for a single field — exported for callers that need to track probe lifecycle externally. */
+export interface ProbeState {
+    status: 'probing' | 'ok' | 'error';
+    result?: FieldProbeResult;
+}
+interface FormFieldProps {
+    field: ConfigField;
+    values: Record<string, unknown>;
+    onChange: (key: string, value: unknown) => void;
+    disabled?: boolean;
+    translationFn?: TranslationFn;
+    /**
+     * Dedicated probe callback — used by the device-creation dialog where
+     * the device doesn't exist yet so the generic `onAction` routing
+     * cannot resolve an addon owner. For existing-device forms prefer
+     * `onAction` with action `'test-probe'`: the probe field falls back
+     * to it when `onTestField` is absent, so the two paths converge.
+     */
+    onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
+    /** External probe result (from "Test All" button) */
+    externalProbe?: {
+        status: 'probing' | 'ok' | 'error';
+        result?: FieldProbeResult;
+    };
+    /**
+     * Inline-action callback. Fired by icon buttons on any field
+     * (copy-value, regenerate-rtsp-token, …) and by the probe field's
+     * Test button when `onTestField` is not provided — in that case the
+     * action name is `'test-probe'` and the current field value flows
+     * through the third arg so the handler can probe it.
+     *
+     * Returns `Promise<unknown>` (not `void`) because some actions yield
+     * a result the caller wants (the probe returns a `FieldProbeResult`).
+     */
+    onAction?: (action: string, key: string, value?: unknown) => Promise<unknown>;
+    /** All fields in the section — used to resolve defaults for showWhen conditions */
+    allFields?: readonly ConfigField[];
+}
+export declare function NodeSelectField({ field, value, onChange, disabled, translationFn, }: {
+    field: ConfigNodeSelectField;
+    value: unknown;
+    onChange: (v: unknown) => void;
+    disabled?: boolean;
+    translationFn?: TranslationFn;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function NodeMultiSelectField({ field, value, onChange, disabled, translationFn, }: {
+    field: ConfigNodeMultiSelectField;
+    value: unknown;
+    onChange: (v: unknown) => void;
+    disabled?: boolean;
+    translationFn?: TranslationFn;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Resolve a `ConfigCondition` against the form's flat values bag and the
+ * sibling-field list (used to recover schema defaults when the
+ * referenced field hasn't been touched yet). Returns `true` for fields
+ * with no `showWhen` — i.e. always visible — and for fields whose
+ * condition is missing a recognised operator (forward-compat: a future
+ * operator added to `ConfigCondition` won't accidentally hide every
+ * field on older clients).
+ *
+ * Exported so callers (FormBuilder section renderer, future
+ * sub-tab visibility checks, …) can pre-evaluate which fields would be
+ * rendered without instantiating a React subtree.
+ */
+export declare function isFieldVisible(field: ConfigField, values: Record<string, unknown>, allFields?: readonly ConfigField[]): boolean;
+export declare function FormField({ field, values, onChange, disabled, translationFn, onTestField, externalProbe, allFields, onAction }: FormFieldProps): import("react/jsx-runtime").JSX.Element | null;
+export { FormField as ConfigFormField };

package/dist/composites/confirm-action-button.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode, ComponentType } from 'react';
+import { ButtonProps } from '../primitives/button';
+export interface ConfirmActionButtonProps<TResult> {
+    /** Visible label on the trigger button. */
+    readonly label: string;
+    /** Icon component (lucide-react) rendered inside the trigger. */
+    readonly icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Dialog title. Defaults to "Confirm action". */
+    readonly title?: string;
+    /**
+     * Dialog body — accepts either a string (rendered as DialogDescription)
+     * or arbitrary ReactNode for callers that need lists, code blocks, etc.
+     */
+    readonly description?: ReactNode;
+    /** Label on the confirm button inside the dialog. Defaults to `label`. */
+    readonly confirmLabel?: string;
+    /** Visual variant for the trigger button (defaults to `outline`). */
+    readonly triggerVariant?: ButtonProps['variant'];
+    /**
+     * Visual variant for the confirm button inside the dialog. Defaults to
+     * `danger` since this component is meant for destructive actions.
+     */
+    readonly confirmVariant?: ButtonProps['variant'];
+    /** Trigger button size — propagated to the underlying Button. */
+    readonly size?: ButtonProps['size'];
+    /** Disable the trigger entirely (gates rendering instead of UX state). */
+    readonly disabled?: boolean;
+    /** Optional extra class name on the trigger. */
+    readonly className?: string;
+    /**
+     * The async action to run on confirm. Must throw on failure so this
+     * component can surface the error inline. The result is returned to
+     * `onSuccess` for callers that need it (e.g. to invalidate queries).
+     */
+    readonly action: () => Promise<TResult>;
+    /** Called after `action` resolves, with the result. */
+    readonly onSuccess?: (result: TResult) => void;
+}
+export declare function ConfirmActionButton<TResult>({ label, icon: Icon, title, description, confirmLabel, triggerVariant, confirmVariant, size, disabled, className, action, onSuccess, }: ConfirmActionButtonProps<TResult>): import("react/jsx-runtime").JSX.Element;

package/dist/composites/confirm-dialog.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+interface ConfirmOptions {
+    title: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: 'danger' | 'warning' | 'default';
+}
+export declare function useConfirm(): (options: ConfirmOptions) => Promise<boolean>;
+export declare function ConfirmDialogProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/data-table/data-table-header.d.ts

@@ -0,0 +1,10 @@
+import { HeaderGroup, flexRender } from '@tanstack/react-table';
+import { SortingState } from './types';
+interface DataTableHeaderProps<T> {
+    headerGroups: HeaderGroup<T>[];
+    onSortingChange?: (sorting: SortingState) => void;
+    stickyHeader?: boolean;
+    flexRender: typeof flexRender;
+}
+export declare function DataTableHeader<T>({ headerGroups, onSortingChange, stickyHeader, flexRender: render, }: DataTableHeaderProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/data-table/data-table-pagination.d.ts

@@ -0,0 +1,9 @@
+import { PaginationState } from './types';
+interface DataTablePaginationProps {
+    page: number;
+    pageSize: number;
+    total: number;
+    onPaginationChange?: (pagination: PaginationState) => void;
+}
+export declare function DataTablePagination({ page, pageSize, total, onPaginationChange, }: DataTablePaginationProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/data-table/data-table-row.d.ts

@@ -0,0 +1,10 @@
+import { Row, flexRender } from '@tanstack/react-table';
+import { DataTableAction } from './types';
+interface DataTableRowProps<T> {
+    row: Row<T>;
+    onRowClick?: (row: T) => void;
+    rowActions?: (row: T) => DataTableAction[];
+    flexRender: typeof flexRender;
+}
+export declare function DataTableRow<T>({ row, onRowClick, rowActions, flexRender: render, }: DataTableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/composites/data-table/data-table.d.ts

@@ -0,0 +1,2 @@
+import { DataTableProps } from './types';
+export declare function DataTable<T>({ data, columns: userColumns, sorting, onSortingChange, filtering, onFilteringChange, pagination, onPaginationChange, loading, emptyState, rowActions, onRowClick, selectable, compact, stickyHeader, className, mobileMode, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/composites/data-table/index.d.ts

@@ -0,0 +1,2 @@
+export { DataTable } from './data-table';
+export type { DataTableProps, ColumnDef, SortingState, ColumnFiltersState, PaginationState, DataTableAction, } from './types';

package/dist/composites/data-table/types.d.ts

@@ -0,0 +1,34 @@
+import { ColumnDef, SortingState, ColumnFiltersState, PaginationState } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+export type { ColumnDef, SortingState, ColumnFiltersState, PaginationState };
+export interface DataTableAction {
+    label: string;
+    icon?: LucideIcon;
+    onClick: () => void;
+    variant?: 'danger' | 'default';
+}
+export interface DataTableProps<T> {
+    data: T[];
+    columns: ColumnDef<T, unknown>[];
+    sorting?: SortingState;
+    onSortingChange?: (sorting: SortingState) => void;
+    filtering?: ColumnFiltersState;
+    onFilteringChange?: (filtering: ColumnFiltersState) => void;
+    pagination?: {
+        page: number;
+        pageSize: number;
+        total: number;
+    };
+    onPaginationChange?: (pagination: PaginationState) => void;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    rowActions?: (row: T) => DataTableAction[];
+    onRowClick?: (row: T) => void;
+    selectable?: boolean;
+    compact?: boolean;
+    stickyHeader?: boolean;
+    className?: string;
+    /** How to render on mobile. 'scroll' keeps table with horizontal scroll. 'cards' renders each row as a card. Default: 'scroll' */
+    mobileMode?: 'scroll' | 'cards';
+}

package/dist/composites/data-table.d.ts

@@ -0,0 +1,37 @@
+import { ReactNode } from 'react';
+export interface DataColumn<T> {
+    /** Stable key for React reconciliation + tests. */
+    readonly key: string;
+    /** Plain text header. Mutually exclusive with `headerRender`. */
+    readonly header?: string;
+    /** Custom header markup — overrides `header`. */
+    readonly headerRender?: () => ReactNode;
+    /** Cell horizontal alignment. Default: `left`. */
+    readonly align?: 'left' | 'right' | 'center';
+    /** Suppress text wrapping on header + cell. Default: header `true`, cell `false`. */
+    readonly nowrap?: boolean;
+    /** Cell renderer. Receives the row value. */
+    readonly render: (row: T, rowIndex: number) => ReactNode;
+    /** Optional explicit Tailwind width class (e.g. `'w-24'`). */
+    readonly width?: string;
+}
+export interface DataTableProps<T> {
+    readonly columns: readonly DataColumn<T>[];
+    readonly rows: readonly T[];
+    /** Stable key per row. Default: rowIndex (works for stable lists). */
+    readonly rowKey?: (row: T, rowIndex: number) => string | number;
+    /** Click handler attached to each row. Adds hover + cursor-pointer. */
+    readonly onRowClick?: (row: T, rowIndex: number) => void;
+    /** Min width in px for the inner table. Default: 480. */
+    readonly minWidthPx?: number;
+    /** Empty-state message. Default: hides the table when rows=[]. */
+    readonly emptyMessage?: string;
+    /** Additional className for the outer container. */
+    readonly className?: string;
+    /** Wrapper border style — set false to drop the rounded border (e.g. when the
+     *  table sits inside another bordered card). Default: `true`. */
+    readonly bordered?: boolean;
+    /** Per-row className resolver (e.g. status-coloured backgrounds). */
+    readonly rowClassName?: (row: T, rowIndex: number) => string | undefined;
+}
+export declare function DataTable<T>({ columns, rows, rowKey, onRowClick, minWidthPx, emptyMessage, className, bordered, rowClassName, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element | null;

package/dist/composites/detection-canvas.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { ObjectDetection } from '@camstack/types';
+export type { ObjectDetection, ScoredLabel, DetectionBoundingBox } from '@camstack/types';
+/** Legacy alias kept so pre-rework consumers don't need a coordinated rename. */
+export type Detection = ObjectDetection;
+export interface DetectionCanvasProps {
+    /** Image source (data URL or regular URL) */
+    readonly src: string | null;
+    /** Image dimensions (used for bbox coordinate mapping) */
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+    /** Detections to overlay — flat list (first-level + details). */
+    readonly detections?: readonly ObjectDetection[];
+    /** Custom class → hex color mapping (merged with defaults) */
+    readonly classColors?: Readonly<Record<string, string>>;
+    /** Aspect ratio CSS value (default: auto based on image dimensions) */
+    readonly aspectRatio?: string;
+    /** Additional CSS classes on the container */
+    readonly className?: string;
+    /** Placeholder content when no image is loaded */
+    readonly placeholder?: ReactNode;
+    /** Show confidence percentage in bbox labels */
+    readonly showConfidence?: boolean;
+    /** Minimum confidence to display (0-1, default: 0) */
+    readonly minConfidence?: number;
+    /** Border width for bboxes in px (default: 2) */
+    readonly borderWidth?: number;
+}
+export declare function DetectionCanvas({ src, imageWidth, imageHeight, detections, classColors, aspectRatio, className, placeholder, showConfidence, minConfidence, borderWidth, }: DetectionCanvasProps): import("react/jsx-runtime").JSX.Element;