@leanspec/ui 0.2.22 → 0.2.24

package/dist/lib/components/library/ai-elements/test-results.d.ts

@@ -0,0 +1,58 @@
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '../ui/collapsible';
+import { ComponentProps, HTMLAttributes } from 'react';
+type TestStatus = "passed" | "failed" | "skipped" | "running";
+interface TestResultsSummary {
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+    duration?: number;
+}
+export type TestResultsProps = HTMLAttributes<HTMLDivElement> & {
+    summary?: TestResultsSummary;
+};
+export declare const TestResults: ({ summary, className, children, ...props }: TestResultsProps) => import("react/jsx-runtime").JSX.Element;
+export type TestResultsHeaderProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsHeader: ({ className, children, ...props }: TestResultsHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type TestResultsSummaryProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsSummary: ({ className, children, ...props }: TestResultsSummaryProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsDurationProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestResultsDuration: ({ className, children, ...props }: TestResultsDurationProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsProgressProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsProgress: ({ className, children, ...props }: TestResultsProgressProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestResultsContentProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestResultsContent: ({ className, children, ...props }: TestResultsContentProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteProps = ComponentProps<typeof Collapsible> & {
+    name: string;
+    status: TestStatus;
+};
+export declare const TestSuite: ({ name, status, className, children, ...props }: TestSuiteProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteNameProps = ComponentProps<typeof CollapsibleTrigger>;
+export declare const TestSuiteName: ({ className, children, ...props }: TestSuiteNameProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteStatsProps = HTMLAttributes<HTMLDivElement> & {
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+};
+export declare const TestSuiteStats: ({ passed, failed, skipped, className, children, ...props }: TestSuiteStatsProps) => import("react/jsx-runtime").JSX.Element;
+export type TestSuiteContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const TestSuiteContent: ({ className, children, ...props }: TestSuiteContentProps) => import("react/jsx-runtime").JSX.Element;
+export type TestProps = HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    status: TestStatus;
+    duration?: number;
+};
+export declare const Test: ({ name, status, duration, className, children, ...props }: TestProps) => import("react/jsx-runtime").JSX.Element;
+export type TestStatusProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestStatus: ({ className, children, ...props }: TestStatusProps) => import("react/jsx-runtime").JSX.Element;
+export type TestNameProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestName: ({ className, children, ...props }: TestNameProps) => import("react/jsx-runtime").JSX.Element;
+export type TestDurationProps = HTMLAttributes<HTMLSpanElement>;
+export declare const TestDuration: ({ className, children, ...props }: TestDurationProps) => import("react/jsx-runtime").JSX.Element | null;
+export type TestErrorProps = HTMLAttributes<HTMLDivElement>;
+export declare const TestError: ({ className, children, ...props }: TestErrorProps) => import("react/jsx-runtime").JSX.Element;
+export type TestErrorMessageProps = HTMLAttributes<HTMLParagraphElement>;
+export declare const TestErrorMessage: ({ className, children, ...props }: TestErrorMessageProps) => import("react/jsx-runtime").JSX.Element;
+export type TestErrorStackProps = HTMLAttributes<HTMLPreElement>;
+export declare const TestErrorStack: ({ className, children, ...props }: TestErrorStackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/tool-duration.d.ts

@@ -0,0 +1,12 @@
+import { ToolPart } from './tool';
+export interface ToolDurationProps {
+    state: ToolPart["state"];
+}
+/**
+ * Live timer that tracks tool execution duration.
+ * - Captures start time on mount via useState initializer
+ * - Ticks every second while running
+ * - Stops ticking on completion (elapsed freezes at last tick)
+ * - Renders as a small Badge with ClockIcon
+ */
+export declare const ToolDuration: ({ state }: ToolDurationProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/lib/components/library/ai-elements/tool-icon-registry.d.ts

@@ -0,0 +1,26 @@
+import { LucideIcon } from 'lucide-react';
+import { ToolPart } from './tool';
+/**
+ * Returns the Lucide icon for a known tool name, or the fallback WrenchIcon.
+ */
+export declare function getToolIcon(toolName: string): LucideIcon;
+/**
+ * Returns the appropriate prefix icon based on tool state:
+ * - Running/streaming → LoaderIcon (animated)
+ * - Completed → tool-specific icon from registry
+ * - Error/denied → AlertCircleIcon or ShieldXIcon
+ */
+export declare function getToolPrefixIcon(state: ToolPart["state"], toolName: string): {
+    icon: LucideIcon;
+    className: string;
+};
+/**
+ * Humanizes a tool name for display.
+ * Splits on `_`, `-`, and camelCase boundaries, then capitalizes each word.
+ *
+ * @example
+ * humanizeToolName("read_file")      // "Read File"
+ * humanizeToolName("list-children")   // "List Children"
+ * humanizeToolName("getSpecStats")    // "Get Spec Stats"
+ */
+export declare function humanizeToolName(name: string): string;

package/dist/lib/components/library/ai-elements/tool-input-ui-view.d.ts

@@ -0,0 +1,10 @@
+interface ToolInputUIViewProps {
+    input: unknown;
+    className?: string;
+}
+/**
+ * Renders tool input as a styled key-value definition list.
+ * Handles flat objects, nested objects (collapsible), arrays, and primitives.
+ */
+export declare const ToolInputUIView: ({ input, className }: ToolInputUIViewProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/lib/components/library/ai-elements/tool.d.ts

@@ -0,0 +1,41 @@
+import { Collapsible, CollapsibleContent } from '../ui/collapsible';
+import { DynamicToolUIPart, ToolUIPart } from 'ai';
+import { ComponentProps } from 'react';
+export type ToolProps = ComponentProps<typeof Collapsible>;
+export declare const Tool: ({ className, ...props }: ToolProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolPart = ToolUIPart | DynamicToolUIPart;
+export type ToolHeaderProps = {
+    title?: string;
+    description?: string;
+    className?: string;
+} & ({
+    type: ToolUIPart["type"];
+    state: ToolUIPart["state"];
+    toolName?: never;
+} | {
+    type: DynamicToolUIPart["type"];
+    state: DynamicToolUIPart["state"];
+    toolName: string;
+});
+export declare const getStatusBadge: (status: ToolPart["state"]) => import("react/jsx-runtime").JSX.Element;
+export declare const ToolHeader: ({ className, title, description: _description, type, state, toolName, ...props }: ToolHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+export declare const ToolContent: ({ className, ...props }: ToolContentProps) => import("react/jsx-runtime").JSX.Element;
+export type ToolInputProps = ComponentProps<"div"> & {
+    input: ToolPart["input"];
+};
+export declare const ToolInput: ({ className, input }: ToolInputProps) => import("react/jsx-runtime").JSX.Element | null;
+export type ToolOutputProps = ComponentProps<"div"> & {
+    output?: ToolPart["output"];
+    rawOutput?: unknown;
+    errorText?: ToolPart["errorText"];
+};
+export declare const ToolOutput: ({ className, output, rawOutput, errorText, }: ToolOutputProps) => import("react/jsx-runtime").JSX.Element | null;
+export type ToolBodyProps = {
+    input?: ToolPart["input"];
+    output?: ToolPart["output"];
+    rawOutput?: unknown;
+    errorText?: ToolPart["errorText"];
+    className?: string;
+};
+export declare const ToolBody: ({ input, output, rawOutput, errorText, className, }: ToolBodyProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/lib/components/library/ai-elements/toolbar.d.ts

@@ -0,0 +1,5 @@
+import { NodeToolbar } from '@xyflow/react';
+import { ComponentProps } from 'react';
+type ToolbarProps = ComponentProps<typeof NodeToolbar>;
+export declare const Toolbar: ({ className, ...props }: ToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/transcription.d.ts

@@ -0,0 +1,16 @@
+import { Experimental_TranscriptionResult as TranscriptionResult } from 'ai';
+import { ComponentProps, ReactNode } from 'react';
+type TranscriptionSegment = TranscriptionResult["segments"][number];
+export type TranscriptionProps = Omit<ComponentProps<"div">, "children"> & {
+    segments: TranscriptionSegment[];
+    currentTime?: number;
+    onSeek?: (time: number) => void;
+    children: (segment: TranscriptionSegment, index: number) => ReactNode;
+};
+export declare const Transcription: ({ segments, currentTime: externalCurrentTime, onSeek, className, children, ...props }: TranscriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type TranscriptionSegmentProps = ComponentProps<"button"> & {
+    segment: TranscriptionSegment;
+    index: number;
+};
+export declare const TranscriptionSegment: ({ segment, index, className, onClick, ...props }: TranscriptionSegmentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/voice-selector.d.ts

@@ -0,0 +1,63 @@
+import { CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut } from '../ui/command';
+import { Dialog, DialogContent, DialogTrigger } from '../ui/dialog';
+import { ComponentProps, ReactNode } from 'react';
+interface VoiceSelectorContextValue {
+    value: string | undefined;
+    setValue: (value: string | undefined) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}
+export declare const useVoiceSelector: () => VoiceSelectorContextValue;
+export type VoiceSelectorProps = ComponentProps<typeof Dialog> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string | undefined) => void;
+};
+export declare const VoiceSelector: ({ value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, children, ...props }: VoiceSelectorProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorTriggerProps = ComponentProps<typeof DialogTrigger>;
+export declare const VoiceSelectorTrigger: (props: VoiceSelectorTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorContentProps = ComponentProps<typeof DialogContent> & {
+    title?: ReactNode;
+};
+export declare const VoiceSelectorContent: ({ className, children, title, ...props }: VoiceSelectorContentProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorDialogProps = ComponentProps<typeof CommandDialog>;
+export declare const VoiceSelectorDialog: (props: VoiceSelectorDialogProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorInputProps = ComponentProps<typeof CommandInput>;
+export declare const VoiceSelectorInput: ({ className, ...props }: VoiceSelectorInputProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorListProps = ComponentProps<typeof CommandList>;
+export declare const VoiceSelectorList: (props: VoiceSelectorListProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorEmptyProps = ComponentProps<typeof CommandEmpty>;
+export declare const VoiceSelectorEmpty: (props: VoiceSelectorEmptyProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorGroupProps = ComponentProps<typeof CommandGroup>;
+export declare const VoiceSelectorGroup: (props: VoiceSelectorGroupProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorItemProps = ComponentProps<typeof CommandItem>;
+export declare const VoiceSelectorItem: ({ className, ...props }: VoiceSelectorItemProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorShortcutProps = ComponentProps<typeof CommandShortcut>;
+export declare const VoiceSelectorShortcut: (props: VoiceSelectorShortcutProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorSeparatorProps = ComponentProps<typeof CommandSeparator>;
+export declare const VoiceSelectorSeparator: (props: VoiceSelectorSeparatorProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorGenderProps = ComponentProps<"span"> & {
+    value?: "male" | "female" | "transgender" | "androgyne" | "non-binary" | "intersex";
+};
+export declare const VoiceSelectorGender: ({ className, value, children, ...props }: VoiceSelectorGenderProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAccentProps = ComponentProps<"span"> & {
+    value?: "american" | "british" | "australian" | "canadian" | "irish" | "scottish" | "indian" | "south-african" | "new-zealand" | "spanish" | "french" | "german" | "italian" | "portuguese" | "brazilian" | "mexican" | "argentinian" | "japanese" | "chinese" | "korean" | "russian" | "arabic" | "dutch" | "swedish" | "norwegian" | "danish" | "finnish" | "polish" | "turkish" | "greek" | string;
+};
+export declare const VoiceSelectorAccent: ({ className, value, children, ...props }: VoiceSelectorAccentProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAgeProps = ComponentProps<"span">;
+export declare const VoiceSelectorAge: ({ className, ...props }: VoiceSelectorAgeProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorNameProps = ComponentProps<"span">;
+export declare const VoiceSelectorName: ({ className, ...props }: VoiceSelectorNameProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorDescriptionProps = ComponentProps<"span">;
+export declare const VoiceSelectorDescription: ({ className, ...props }: VoiceSelectorDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorAttributesProps = ComponentProps<"div">;
+export declare const VoiceSelectorAttributes: ({ className, children, ...props }: VoiceSelectorAttributesProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorBulletProps = ComponentProps<"span">;
+export declare const VoiceSelectorBullet: ({ className, ...props }: VoiceSelectorBulletProps) => import("react/jsx-runtime").JSX.Element;
+export type VoiceSelectorPreviewProps = Omit<ComponentProps<"button">, "children"> & {
+    playing?: boolean;
+    loading?: boolean;
+    onPlay?: () => void;
+};
+export declare const VoiceSelectorPreview: ({ className, playing, loading, onPlay, onClick, ...props }: VoiceSelectorPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/library/ai-elements/web-preview.d.ts

@@ -0,0 +1,34 @@
+import { Button } from '../ui/button';
+import { Input } from '../ui/input';
+import { ComponentProps, ReactNode } from 'react';
+export interface WebPreviewContextValue {
+    url: string;
+    setUrl: (url: string) => void;
+    consoleOpen: boolean;
+    setConsoleOpen: (open: boolean) => void;
+}
+export type WebPreviewProps = ComponentProps<"div"> & {
+    defaultUrl?: string;
+    onUrlChange?: (url: string) => void;
+};
+export declare const WebPreview: ({ className, children, defaultUrl, onUrlChange, ...props }: WebPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewNavigationProps = ComponentProps<"div">;
+export declare const WebPreviewNavigation: ({ className, children, ...props }: WebPreviewNavigationProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewNavigationButtonProps = ComponentProps<typeof Button> & {
+    tooltip?: string;
+};
+export declare const WebPreviewNavigationButton: ({ onClick, disabled, tooltip, children, ...props }: WebPreviewNavigationButtonProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewUrlProps = ComponentProps<typeof Input>;
+export declare const WebPreviewUrl: ({ value, onChange, onKeyDown, ...props }: WebPreviewUrlProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewBodyProps = ComponentProps<"iframe"> & {
+    loading?: ReactNode;
+};
+export declare const WebPreviewBody: ({ className, loading, src, ...props }: WebPreviewBodyProps) => import("react/jsx-runtime").JSX.Element;
+export type WebPreviewConsoleProps = ComponentProps<"div"> & {
+    logs?: Array<{
+        level: "log" | "warn" | "error";
+        message: string;
+        timestamp: Date;
+    }>;
+};
+export declare const WebPreviewConsole: ({ className, logs, children, ...props }: WebPreviewConsoleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/graph/dependency-graph.d.ts

@@ -0,0 +1,26 @@
+import { CompleteSpecRelationships } from '../../../types/specs';
+export interface DependencyGraphProps {
+    relationships: CompleteSpecRelationships;
+    specNumber?: number | null;
+    specTitle: string;
+    onNodeClick?: (specId: string) => void;
+    labels?: {
+        title?: string;
+        subtitle?: string;
+        badge?: string;
+        currentBadge?: string;
+        currentSubtitle?: string;
+        dependsOnBadge?: string;
+        dependsOnSubtitle?: string;
+        requiredByBadge?: string;
+        requiredBySubtitle?: string;
+        completedSubtitle?: string;
+        inProgressSubtitle?: string;
+        plannedBlockingSubtitle?: string;
+        plannedCanProceedSubtitle?: string;
+        archivedSubtitle?: string;
+    };
+    statusLabels?: Record<string, string>;
+    priorityLabels?: Record<string, string>;
+}
+export declare function SpecDependencyGraph(props: DependencyGraphProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/graph/index.d.ts

@@ -0,0 +1,2 @@
+export { SpecDependencyGraph } from './dependency-graph';
+export type { DependencyGraphProps } from './dependency-graph';

package/dist/lib/components/library/hierarchy/hierarchy-tree.d.ts

@@ -0,0 +1,23 @@
+import { LightweightSpec } from '../../../types/specs';
+import { SortOption } from '../../../lib/hierarchy';
+export interface HierarchyTreeProps {
+    /** Flat list of all specs to render in the tree */
+    specs: LightweightSpec[];
+    /** Callback when a spec is clicked */
+    onSpecClick?: (spec: LightweightSpec) => void;
+    /** Currently selected spec ID */
+    selectedSpecId?: string;
+    /** Class name */
+    className?: string;
+    /** Height of the list implementation */
+    height?: number;
+    /** Width of the list implementation */
+    width?: number | string;
+    /** Sort option for the hierarchy (default: 'id-desc') */
+    sortBy?: SortOption;
+    /** Set of expanded node IDs (controlled) */
+    expandedIds?: Set<string>;
+    /** Callback when expanded ids change (controlled) */
+    onExpandedChange?: (ids: Set<string>) => void;
+}
+export declare function HierarchyTree({ specs, onSpecClick, selectedSpecId, className, height, width, sortBy, expandedIds: controlledExpandedIds, onExpandedChange }: HierarchyTreeProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/hierarchy/index.d.ts

@@ -0,0 +1 @@
+export * from './hierarchy-tree';

package/dist/lib/components/library/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ui';
+export * from './ai-elements';
+export * from './spec';
+export * from './layout';
+export * from './project';
+export * from './navigation';
+export * from './search';
+export * from './stats';
+export * from './hierarchy';
+export * from './graph';

package/dist/lib/components/library/layout/empty-state.d.ts

@@ -0,0 +1,25 @@
+import { LucideIcon } from 'lucide-react';
+export interface EmptyStateAction {
+    label: string;
+    onClick?: () => void;
+    href?: string;
+}
+export interface EmptyStateProps {
+    /** Icon to display */
+    icon: LucideIcon;
+    /** Title text */
+    title: string;
+    /** Description text */
+    description: string;
+    /** Optional action button or custom actions */
+    action?: EmptyStateAction;
+    /** Custom actions as ReactNode (alternative to action) */
+    actions?: React.ReactNode;
+    /** Visual tone */
+    tone?: 'muted' | 'error';
+    /** Additional CSS classes */
+    className?: string;
+    /** Use card wrapper */
+    variant?: 'default' | 'card';
+}
+export declare function EmptyState({ icon: Icon, title, description, action, actions, tone, className, variant, }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/layout/index.d.ts

@@ -0,0 +1,2 @@
+export { EmptyState, type EmptyStateProps, type EmptyStateAction } from './empty-state';
+export { ProjectsSkeleton, MachinesSkeleton, ChatSkeleton, DependenciesSkeleton, DashboardSkeleton, StatsSkeleton, ContextPageSkeleton, SettingsSkeleton, SpecListSkeleton, SpecDetailSkeleton, StatsCardSkeleton, KanbanBoardSkeleton, ProjectCardSkeleton, SidebarSkeleton, SpecsNavSidebarSkeleton, ContentSkeleton, type ContentSkeletonProps, } from './loading-skeletons';

package/dist/lib/components/library/layout/loading-skeletons.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Loading skeleton components for various UI states
+ *
+ * These components provide consistent loading states across the application.
+ * All skeletons follow a unified pattern with consistent spacing and structure.
+ */
+/**
+ * Skeleton for projects page loading state
+ */
+export declare function ProjectsSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for machines page loading state
+ */
+export declare function MachinesSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for chat page loading state
+ */
+export declare function ChatSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for dependencies page loading state
+ */
+export declare function DependenciesSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for dashboard page loading state
+ */
+export declare function DashboardSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for stats page loading state
+ */
+export declare function StatsSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for context page loading state
+ */
+export declare function ContextPageSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for settings page loading state
+ */
+export declare function SettingsSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for spec list loading state
+ */
+export declare function SpecListSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for spec detail loading state
+ */
+export declare function SpecDetailSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for stats card loading state
+ */
+export declare function StatsCardSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for kanban board loading state
+ */
+export declare function KanbanBoardSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for project card loading state
+ */
+export declare function ProjectCardSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for sidebar loading state
+ */
+export declare function SidebarSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Skeleton for specs navigation sidebar loading state
+ */
+export declare function SpecsNavSidebarSkeleton(): import("react/jsx-runtime").JSX.Element;
+/**
+ * Generic content skeleton with configurable lines
+ */
+export interface ContentSkeletonProps {
+    /** Number of lines to display */
+    lines?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ContentSkeleton({ lines, className }: ContentSkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/navigation/back-to-top.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BackToTop component
+ * Floating button that scrolls to the top of the page
+ */
+export interface BackToTopProps {
+    /** Scroll threshold before showing button (in pixels) */
+    threshold?: number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Position from bottom (in pixels or CSS value) */
+    bottom?: string | number;
+    /** Position from right (in pixels or CSS value) */
+    right?: string | number;
+}
+export declare function BackToTop({ threshold, className, bottom, right, }: BackToTopProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/lib/components/library/navigation/index.d.ts

@@ -0,0 +1,2 @@
+export { ThemeToggle, useTheme, type ThemeToggleProps, type Theme } from './theme-toggle';
+export { BackToTop, type BackToTopProps } from './back-to-top';

package/dist/lib/components/library/navigation/theme-toggle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Theme Toggle component
+ * Switches between light and dark themes
+ * Framework-agnostic - no dependency on next-themes
+ */
+export type Theme = 'light' | 'dark' | 'system';
+export interface ThemeToggleProps {
+    /** Current theme */
+    theme?: Theme;
+    /** Callback when theme changes */
+    onThemeChange?: (theme: Theme) => void;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant */
+    size?: 'default' | 'sm' | 'lg' | 'icon';
+}
+export declare function ThemeToggle({ theme, onThemeChange, className, size, }: ThemeToggleProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook for managing theme state with localStorage persistence
+ */
+export declare function useTheme(defaultTheme?: Theme): {
+    theme: Theme;
+    setTheme: (newTheme: Theme) => void;
+    mounted: boolean;
+};

package/dist/lib/components/library/project/index.d.ts

@@ -0,0 +1,4 @@
+export { ProjectAvatar, type ProjectAvatarProps } from './project-avatar';
+export { ProjectCard, type ProjectCardProps, type ProjectCardData } from './project-card';
+export { ProjectSwitcher, type ProjectSwitcherProps, type Project } from './project-switcher';
+export { ProjectDialog, type ProjectDialogProps } from './project-dialog';

package/dist/lib/components/library/project/project-avatar.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Project Avatar Component
+ * Displays a project avatar with initials and custom color
+ */
+export interface ProjectAvatarProps {
+    /** Project name (used for initials) */
+    name: string;
+    /** Custom color (hex) - if not provided, will be generated from name */
+    color?: string;
+    /** Optional icon URL/path */
+    icon?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function ProjectAvatar({ name, color, icon, size, className, }: ProjectAvatarProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/project/project-card.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ProjectCard component
+ * Displays a project card with avatar, name, description, and stats
+ */
+export interface ProjectCardData {
+    id: string;
+    name: string;
+    description?: string | null;
+    color?: string | null;
+    icon?: string | null;
+    favorite?: boolean;
+    specsCount?: number;
+    updatedAt?: string | Date | null;
+    tags?: string[];
+}
+export interface ProjectCardProps {
+    /** Project data to display */
+    project: ProjectCardData;
+    /** Click handler for the card */
+    onClick?: () => void;
+    /** Handler for favorite toggle */
+    onFavoriteToggle?: (favorite: boolean) => void;
+    /** Handler for more options */
+    onMoreOptions?: () => void;
+    /** Whether the card is currently selected */
+    selected?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Locale for date formatting */
+    locale?: string;
+    /** Labels for localization */
+    labels?: {
+        specs?: string;
+        spec?: string;
+        updated?: string;
+        noDescription?: string;
+        toggleFavorite?: string;
+        moreOptions?: string;
+    };
+}
+export declare function ProjectCard({ project, onClick, onFavoriteToggle, onMoreOptions, selected, className, locale, labels, }: ProjectCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/project/project-dialog.d.ts

@@ -0,0 +1,21 @@
+export interface ProjectDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (path: string) => Promise<void> | void;
+    onBrowseFolder?: () => Promise<string | null>;
+    isLoading?: boolean;
+    labels?: {
+        title?: string;
+        descriptionPicker?: string;
+        descriptionManual?: string;
+        pathLabel?: string;
+        pathPlaceholder?: string;
+        pathHelp?: string;
+        action?: string;
+        adding?: string;
+        cancel?: string;
+        browseFolders?: string;
+        enterManually?: string;
+    };
+}
+export declare function ProjectDialog({ open, onOpenChange, onSubmit, onBrowseFolder, isLoading, labels, }: ProjectDialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/lib/components/library/project/project-switcher.d.ts

@@ -0,0 +1,27 @@
+export interface Project {
+    id: string;
+    name: string;
+    path?: string;
+    color?: string;
+    favorite?: boolean;
+}
+export interface ProjectSwitcherProps {
+    currentProject?: Project | null;
+    projects: Project[];
+    isLoading?: boolean;
+    collapsed?: boolean;
+    isSwitching?: boolean;
+    onProjectSelect?: (projectId: string) => void;
+    onAddProject?: () => void;
+    onManageProjects?: () => void;
+    labels?: {
+        switching?: string;
+        placeholder?: string;
+        searchPlaceholder?: string;
+        noProject?: string;
+        projects?: string;
+        createProject?: string;
+        manageProjects?: string;
+    };
+}
+export declare function ProjectSwitcher({ currentProject, projects, isLoading, collapsed, isSwitching, onProjectSelect, onAddProject, onManageProjects, labels, }: ProjectSwitcherProps): import("react/jsx-runtime").JSX.Element;