@toolr/ui-design 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2714 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode, MouseEvent, InputHTMLAttributes, ElementType, RefObject } from 'react';
+import * as lucide_react from 'lucide-react';
+import { LucideIcon } from 'lucide-react';
+import { ClassValue } from 'clsx';
+
+type FormColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky';
+
+declare const SCALE_KEYS: readonly ["black", "950", "900", "800", "700", "600", "500", "400", "300", "200"];
+type ScaleKey = (typeof SCALE_KEYS)[number];
+type ThemeId = 'oled' | 'dark' | 'night' | 'soft' | 'bright' | 'paper' | 'muted';
+declare const DARK_THEMES: ThemeId[];
+declare const LIGHT_THEMES: ThemeId[];
+declare const BASE_THEMES: Record<ThemeId, {
+    label: string;
+    maxSat: number;
+    lightness: Record<ScaleKey, number>;
+}>;
+interface AccentDef {
+    id: FormColor;
+    hue: number | null;
+    dotColor: string;
+}
+declare const ACCENT_DEFS: AccentDef[];
+declare function satCurve(l: number): number;
+declare function hslToHex(h: number, s: number, l: number): string;
+declare function generateScale(theme: ThemeId, hue: number | null, maxSat: number): Record<ScaleKey, string>;
+declare function isLightTheme(themeId: ThemeId): boolean;
+declare function applyTheme(themeId: ThemeId, accentHue: number | null, root?: HTMLElement): void;
+
+type ToolrAppId = 'toolr' | 'configr' | 'reviewr' | 'vibr' | 'learnr' | 'planr' | 'seedr';
+declare const TOOLR_APPS: Record<ToolrAppId, {
+    name: string;
+    color: string;
+}>;
+declare function ToolrAppLogo({ app, color: colorOverride, size, className }: {
+    app?: ToolrAppId;
+    color?: string;
+    size?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare const AI_TOOL_LOGOS: {
+    readonly claude: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAMAAABF0y+mAAAAJFBMVEVHcEzZd1fZd1fZd1fZd1fad1jZd1fZd1fZd1fZd1fZd1fZd1deZDooAAAADHRSTlMA//F3mhLfyjpWsiMDGU5mAAABH0lEQVQokXVSWXbEIAzDuw33v28FJCnpTP3BA6+yRGvbLK39a0F9RUvHZ5CIazZwkm+VpCi1nZP1GpJEnq2NdabzU594N0XpzInRhq/7jvm8wsOjFfVmcQG4guTWZKYL8HSiA1XFHDjgHMqCpKfpNPgIXiZVVvSJ9yazOJARxBiYf/ZMoIUxrYGjRHs/di2nbdzDZxIb1maPriold3QlyFJCAonMd08A7/WhkN19PWDolSeiXU7URWPm8S3ewMCuvGpB+kigVXvWZKlgIVycF0Hjl6DIoVRCGKz9pE8W0QKXkgkIEmjzUDuh11TSuVkn348DLHs1Y7/kzTi+ksX8GLn0wBRrdvCQS949C43fstj6FhfM8Unfqqwv3gf3+/kDMJgHC0kwnjEAAAAASUVORK5CYII=";
+    readonly copilot: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHZpZXdCb3g9IjAgMCAyOCAyOCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHJ4PSI2IiBmaWxsPSIjMWYxZjFmIi8+PHBhdGggZD0iTTE0IDVjLTQuOTcgMC05IDQuMDMtOSA5IDAgMy45NyAyLjU2IDcuMzQgNi4xMiA4LjUzLjQ1LjA4LjYxLS4xOS42MS0uNDN2LTEuNjdjLTIuNDkuNTQtMy4wMS0xLjA2LTMuMDEtMS4wNi0uNDEtMS4wNC0uOTktMS4zMS0uOTktMS4zMS0uODEtLjU2LjA2LS41NC4wNi0uNTQuOS4wNiAxLjM3LjkyIDEuMzcuOTIuOCAxLjM3IDIuMDkuOTggMi42Ljc0LjA4LS41OC4zMS0uOTguNTctMS4yLTEuOTktLjIzLTQuMDgtLjk5LTQuMDgtNC40MiAwLS45OC4zNS0xLjc4LjkyLTIuNDEtLjA5LS4yMy0uNC0xLjE0LjA5LTIuMzcgMCAwIC43NS0uMjQgMi40Ni45Mi43MS0uMiAxLjQ4LS4zIDIuMjQtLjNzMS41My4xIDIuMjQuMzFjMS43MS0xLjE2IDIuNDYtLjkyIDIuNDYtLjkyLjQ5IDEuMjMuMTggMi4xNC4wOSAyLjM3LjU3LjYzLjkyIDEuNDMuOTIgMi40MSAwIDMuNDQtMi4xIDQuMTktNC4wOSA0LjQxLjMyLjI4LjYxLjgyLjYxIDEuNjZ2Mi40NmMwIC4yNC4xNi41MS42MS40M0MxOS40NCAyMS4zNCAyMiAxOC4wMyAyMiAxNGMwLTQuOTctNC4wMy05LTktOVoiIGZpbGw9IiNmZmYiLz48L3N2Zz4=";
+    readonly codex: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAP1BMVEVHcEwAgPgAgPgAgPcAgPcAgPcAgPcAgPcAgPcAgPcAd/dzsvq+2/2Kvvtfpvru+P/Z6/77/v83lvmnzfwbjPhuMd/TAAAACnRSTlMAF0adyun/9k+LLZxzywAAAXZJREFUeAFkUlmWwyAMC03qZITxAtz/rPNiaLpEvwhJCC1vpMe6PYn2bT3Sckf6e9KF55pux/SDvy9K2uiG7YNx7BQAgDdjP677r/PMXOhN2tOXPkSN2byUkis+XV75vBFA7mqugpE0BKY+M0DNuQIoXgbjlFinv1Zk0wxUAppeEin66ebe4Q2o7J6pq4zG0nLEfTPRDhUUNSlu3fKQeAwH0V5PQlPV1kHFfcZcl20GPAnuuWe1DIjx7HPZw+EkEOJ1cDcBtCBCLBGhGVVlimTQ3FxQbHgEgaoLuoVx6FiG+CQ8h4RWUFYVdHYhy8iDsEfI6IEjvTlrEJgxQq7DQ8W0kbgKgiAu85mPQYiiPZo+LdRnUcesGsZAzxVozp2MBa+q5293bx2gs2kgK2hgvb4b4mpsWgggbS9C+hgMcmtFrRT2ck37e9IAajHjjJ9hz9FO0n201+wn7rP/H76MQzjrIZQwI2deTqz5m4OZhR0oycLMhCQNACpMHlEZrAKTAAAAAElFTkSuQmCC";
+    readonly gemini: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAEMklEQVR4Ab2XA5AkSRSGv5ddXb095t2tbdu2bW/wbNsXONuBs23bttY2p2e7Kt/1VNQZ3cMv4o9U46+XrxJCSIvLduTv0ezjPTGzfaGNCk5KWAEVyMVSrKFQSsJ6UUolWAp9j5i3j2hK7sG9uMl9Ke0NtQ8nuS+ZKn+IeAceSLj2qtZ3X7sHQACaXLC3434n/rQvNLWiSNk21CZR0ZQIFEUprJDalIKSgoo6QTuo1/PKiHr7A7nJoCQalnG/jPriB2ZSfSv3+zKh+ZO3fCfBk/t5n1uhaeTn54m9dw1m70Zqg/r1sjiySSvG5uXgeGUrdyTzuslhF5Sf70Ui5wR//tIZgFKbCHBxq/aMy42jas8xKmY2Cm7qyUGpbRS4fu1KrHEwyGyjmNbmwFZk30bqivXlCbZ6igptDYqD71HXJDCAcY0Aki5ssRwQoSaxxglkhPSUtxrJzvn3kGwzGsRQE6hUGIhiUJA0uScKfkkbdk+4DH/xA7jtJyHGqXYEfBPNLAKCIApqYU9hcxhzDvWXPEhp5xkYx62qgTACpI9AZNsPODtXYxQ8YLsY9uQ1oHDYyfRNGWnTfR7RaLzyBsTBiJKWyJZvyL97FrnPnU506w8kVCpMBNqXXUrzgUcxc8kD9O+1hHgsNzMDEiYhgJABanF/fIGCexeQ/8TxJDZ/zTYxbAuNHIgX0KXPCo5bfC9Tey8mN5aTJgIRbJgDlUMVd+Ub5N+3DH3kSHas/4RtSEphRNwc+vVcQq8WA9NEIBpEwAlzoEqYtR9QntL6+p2xvZYSa9qPGBAzDuVOFv+HBkkoGFGqTXLjl6x95gx+/PqJ33MjIZLRQuRQTTQaJ9F5JvHuC7DZRWxTHxdDAkmbhL4x4RRQeTSWS3nnuZR1m4+XVUBClBiWmFaUcMD6GUQgEk6BkjEaLyTZ5yj2L3yaRJ8j0HqF4fogbMewZct3fPHM6az6+vGM1gFHEDIi+xD8zkvw2s/ARuNgFBOatwjuuo+IfXgH+9e8V6l1wCETGg3CjrgCdaKIgCgYCxjFWf0O7se342z8rEq7oSMKmm4zipdgxP3jg9ZiVr+C89ntmG3fVWs3dADSToOCUVDfx6x6FueLO2HXL9XcDUMDkkkO2oPww0PI13cie9fX6IHEQSGdCf3lmUBVI815wICHONQ1ESdeYeKgEfRHiZdCTn3qitLcQ8nJLsEz7vdG4AEQpOdxgFDbiAhT+iwlmAJxHzT5yd1XirCKZmNh2GWQ04DaIj+vPvPGnEOXFsPwJbqyrLDgKgHocPreDgec7KctNFNRNLE1vJwSyIZlMMbf+gj7hd+VE15iK1QQ1kuMQ8N4YXCjzrfeSrUHxs85u8X3Qkir8zTPet7xvjGzFW3jG4kqYP9uICj/3h+OhX0xlGJseIUPhSZT7e+LsA/4ZVx9zHnFewB+BQL7BcuXk7EZAAAAAElFTkSuQmCC";
+    readonly opencode: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAIKADAAQAAAABAAAAIAAAAACshmLzAAABl0lEQVRYCe1XS2rDMBAd/70xBJoubJqVF83Sm+YooVcIPUDJTUpOUHIa71Ov0ht4Y/yJ6zEYHFnyZBKKNx4IkTSjNw/pzQhrT4tFDROaPmHuNvVMYPITMCkNVFVFhYz6DcMY9SsJ1HUNmqbB1+EAYRiOgqicSZLAx24HHZYsTkmgC46iCF7X627K+vc8j4wnNVAUBQmiCrhlL3kCIjilCerORTwWgTzP4X27hd/zGcRESOxltYLv4xFs2xbzKOcsAiimn9MJUFymeb21LEvIsqwVnDKbxHGNIgkQl8ymrDC5SADj0Mc1NgGjSW5Z1oAAliz6uMbaoes6vG027V3LNOD7PmAMx1gEENhxHHBdVypC9HGNTQCF2P36yWRrfb9qzDsvFcoD6zMBtgaw48nasWqduh0WAaz1IAjAalqtIZRbdbnA83LZPuFU0r6fRQC73+d+398/GP97H+AmGDAUFsgqwLZ7r92yl7yCOI4hTdO7OOCrSZlGfRnJFE+B9v3im9H34Zg8AQpABOTOSQ1wAbnxM4HJT+APfgFr0DSNhC0AAAAASUVORK5CYII=";
+};
+type AiToolKey = 'claude' | 'gemini' | 'codex' | 'copilot' | 'opencode';
+declare const AI_TOOL_NAMES: Record<AiToolKey, string>;
+declare function AiToolIcon({ tool, size, showName, className, style }: {
+    tool: string;
+    size?: number;
+    showName?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface TooltipContent {
+    title?: string;
+    /** Description can be a string or React node for rich content with icons/colors */
+    description: string | ReactNode;
+    extra?: string;
+}
+type TooltipPosition = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+type TooltipAlign = 'start' | 'center' | 'end';
+interface TooltipProps {
+    children: ReactNode;
+    /** Tooltip content with required title and description */
+    content: TooltipContent;
+    position?: TooltipPosition;
+    align?: TooltipAlign;
+    /** Allow multi-line content (disables whitespace-nowrap) */
+    multiline?: boolean;
+    /** Maximum width for multiline tooltips (number for px, string for CSS value, default '80vw') */
+    maxWidth?: number | string;
+    /** Maximum height for scrollable tooltips (only when interactive) */
+    maxHeight?: number;
+    /** Allow hovering into the tooltip and scrolling its content */
+    interactive?: boolean;
+    /** Trigger mode: 'hover' (default) or 'click' (toggle on click, dismiss on click-outside) */
+    trigger?: 'hover' | 'click';
+    /** Additional classes for the wrapper element (e.g., 'h-full' for flex containers) */
+    wrapperClassName?: string;
+}
+/**
+ * Portal-based tooltip that renders at document body level.
+ * This ensures tooltips always appear above all other elements,
+ * regardless of parent overflow or z-index settings.
+ */
+declare function Tooltip({ children, content, position, align, multiline, maxWidth, maxHeight, trigger, interactive, wrapperClassName, }: TooltipProps): react_jsx_runtime.JSX.Element;
+/**
+ * Simple tooltip wrapper for icon buttons.
+ * Provides consistent styling for action button tooltips.
+ */
+declare function TooltipButton({ children, content, onClick, className, disabled, }: {
+    children: ReactNode;
+    content: TooltipContent;
+    onClick?: () => void;
+    className?: string;
+    disabled?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+declare const iconMap: {
+    readonly 'arrow-down-to-line': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'arrow-left': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'arrow-right': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'arrow-up': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'arrow-down': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevron-left': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevron-right': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevron-up': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevron-down': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevrons-up-down': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'chevrons-down-up': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly check: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly x: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly plus: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly minus: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly pencil: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly trash: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly copy: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly save: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly refresh: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly rotate: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly undo: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly redo: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly search: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly filter: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly download: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly upload: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'external-link': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly link: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly unlink: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly eye: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'eye-off': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly lock: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly unlock: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly settings: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'more-h': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'more-v': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly loader: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'check-circle': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'alert-triangle': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'x-circle': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly info: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly help: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly user: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly users: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly folder: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly file: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'file-text': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly image: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly code: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly terminal: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly star: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly heart: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly bell: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly bookmark: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly tag: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly pin: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly mail: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly send: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly globe: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly database: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly cloud: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly wand: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly shield: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'shield-check': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly zap: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly sparkles: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly play: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly pause: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly stop: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'stop-circle': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'circle-play': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly scan: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly menu: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly grip: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly maximize: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly minimize: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly webhook: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly bot: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly puzzle: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly plug: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'panel-bottom-close': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly package: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly wrench: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly store: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'scroll-text': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly cpu: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'flask-conical': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly layers: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly timer: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly camera: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'alert-circle': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'file-code': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly gauge: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly home: react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'pie-chart': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+    readonly 'settings-2': react.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & react.RefAttributes<SVGSVGElement>>;
+};
+type IconName = keyof typeof iconMap;
+interface ActionItem {
+    icon: IconName;
+    onClick: () => void;
+    color?: IconButtonColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    variant?: IconButtonVariant;
+    tooltip?: TooltipContent;
+    disabled?: boolean;
+    status?: IconButtonStatus;
+    active?: boolean;
+    href?: string;
+    testId?: string;
+}
+type IconButtonStatus = 'loading' | 'success' | 'warning' | 'error';
+type IconButtonColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky';
+type IconButtonVariant = 'filled' | 'outline';
+interface IconButtonProps {
+    icon: IconName | ReactNode;
+    onClick?: (e?: MouseEvent) => void;
+    /** When provided, renders an <a> tag instead of <button>. Opens in a new tab. */
+    href?: string;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    color?: IconButtonColor;
+    variant?: IconButtonVariant;
+    active?: boolean;
+    disabled?: boolean;
+    /** Async action status. Overrides icon, color, and active state when set. */
+    status?: IconButtonStatus;
+    /** Tooltip shown on hover. Title and description are required. */
+    tooltip?: TooltipContent;
+    tooltipPosition?: 'bottom' | 'bottom-left' | 'left' | 'right' | 'top' | 'top-left' | 'top-right';
+    badge?: number | string;
+    badgeColor?: 'red' | 'blue' | 'green' | 'orange';
+    strikethrough?: boolean;
+    className?: string;
+    /** Test ID for E2E testing */
+    testId?: string;
+}
+declare function IconButton({ icon, onClick, href, size, color, variant, active, disabled, status, tooltip, tooltipPosition, badge, badgeColor, strikethrough, className, testId, }: IconButtonProps): react_jsx_runtime.JSX.Element;
+interface CollapseButtonProps {
+    collapsed: boolean;
+    onToggle: () => void;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    tooltipPosition?: 'bottom' | 'bottom-left' | 'left' | 'right' | 'top' | 'top-left' | 'top-right';
+}
+declare function CollapseButton({ collapsed, onToggle, size, tooltipPosition }: CollapseButtonProps): react_jsx_runtime.JSX.Element;
+
+type LabelColor = 'neutral' | 'green' | 'red' | 'blue' | 'yellow' | 'orange' | 'purple' | 'amber' | 'emerald' | 'cyan' | 'indigo' | 'teal' | 'violet' | 'pink';
+interface LabelProps {
+    text: string;
+    color: LabelColor;
+    /** Leading icon(s). Pass a single name or an array for multiple icons before text. */
+    icon?: IconName | IconName[];
+    /** Custom icon component. Takes precedence over icon. */
+    IconComponent?: React.ComponentType<{
+        className?: string;
+    }>;
+    tooltip: {
+        title?: string;
+        description: string;
+    };
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    textTransform?: 'capitalize' | 'lowercase' | 'uppercase';
+    onClick?: () => void;
+    className?: string;
+    testId?: string;
+}
+declare function Label({ text, color, icon, IconComponent: CustomIcon, tooltip, size, textTransform, onClick, className, testId, }: LabelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Badge - Outline-styled pill badge for displaying counts or short labels
+ *
+ * Used by:
+ * - TabBar, BottomPanelHeader - tab count badges
+ * - NavCard - card count badges
+ * - Any UI that needs a small inline indicator
+ *
+ * Features:
+ * - Outline variant matching IconButton outline style (border + text, no fill)
+ * - Accepts numbers (auto-caps at 99+) or short strings ("New")
+ * - 13 color variants
+ * - 5 size variants (xss, xs, sm, md, lg)
+ */
+type BadgeColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky';
+interface BadgeProps {
+    value: number | string;
+    color?: BadgeColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+    testId?: string;
+}
+declare function Badge({ value, color, size, className, testId, }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ConfirmBadge - Outline-styled check badge for indicating selection/confirmation
+ *
+ * Used by:
+ * - SelectionGrid - selected state indicator on cards
+ * - Any UI that needs a small check/confirmed indicator
+ *
+ * Features:
+ * - Outline variant matching IconButton outline style (border + text, no fill)
+ * - 13 color variants
+ * - 5 size variants (xss, xs, sm, md, lg)
+ */
+type ConfirmBadgeColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky';
+interface ConfirmBadgeProps {
+    color?: ConfirmBadgeColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+    testId?: string;
+}
+declare function ConfirmBadge({ color, size, className, testId, }: ConfirmBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Checkbox - Controlled checkbox input with check icon
+ *
+ * Used by:
+ * - Settings forms - boolean preference toggles
+ * - Filter panels - multi-select filters
+ * - List items - selection state
+ */
+type CheckboxSize = 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+type CheckboxColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky' | 'pink' | 'teal';
+type CheckboxVariant = 'outline' | 'filled';
+interface CheckboxProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    size?: CheckboxSize;
+    color?: CheckboxColor;
+    variant?: CheckboxVariant;
+    className?: string;
+    /** Test ID for E2E testing */
+    testId?: string;
+}
+declare function Checkbox({ checked, onChange, disabled, size, color, variant, className, testId, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Toggle - iOS-style switch toggle
+ *
+ * Used by:
+ * - Settings pages - boolean preferences
+ * - Feature flags - enable/disable features
+ * - List items - inline toggle controls
+ */
+type ToggleColor = 'blue' | 'green' | 'red' | 'orange' | 'cyan' | 'yellow' | 'purple' | 'indigo' | 'emerald' | 'amber' | 'violet' | 'neutral' | 'sky' | 'pink' | 'teal';
+type ToggleSize = 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+type ToggleVariant = 'outline' | 'filled';
+interface ToggleProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    size?: ToggleSize;
+    className?: string;
+    color?: ToggleColor;
+    variant?: ToggleVariant;
+    /** Test ID for E2E testing */
+    testId?: string;
+}
+declare function Toggle({ checked, onChange, disabled, size, className, color, testId, }: ToggleProps): react_jsx_runtime.JSX.Element;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'size' | 'type'> {
+    value: string;
+    onChange: (value: string) => void;
+    type?: 'text' | 'search' | 'password';
+    debounceMs?: number;
+    error?: boolean | string;
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    mono?: boolean;
+    /** Test ID for E2E testing */
+    testId?: string;
+    /** Element rendered inside the input (right side), visible on hover/focus. Use IconButton size="xss". */
+    actionSlot?: ReactNode;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface NumberInputProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    className?: string;
+}
+declare function NumberInput({ value, onChange, min, max, step, variant, color, size, disabled, className, }: NumberInputProps): react_jsx_runtime.JSX.Element;
+
+type ScopeType = 'user' | 'project' | 'local' | 'read-only';
+interface ScopeBadgeProps {
+    scope: ScopeType;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+}
+declare function ScopeBadge({ scope, size }: ScopeBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface SegmentedToggleOption<T extends string> {
+    value: T;
+    icon: ReactNode;
+    tooltip: TooltipContent;
+}
+interface SegmentedToggleProps<T extends string> {
+    options: SegmentedToggleOption<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    accentColor?: 'blue' | 'purple' | 'orange' | 'green' | 'pink' | 'amber' | 'emerald' | 'teal' | 'sky';
+    /** Visual style: 'filled' (default) has a container background, 'outline' is transparent */
+    variant?: 'filled' | 'outline';
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    tooltipPosition?: TooltipPosition;
+    testId?: string;
+    disabled?: boolean;
+    /** Tooltip shown on the entire toggle when disabled */
+    disabledTooltip?: TooltipContent;
+}
+declare function SegmentedToggle<T extends string>({ options, value, onChange, accentColor, variant, size, tooltipPosition, testId, disabled, disabledTooltip, }: SegmentedToggleProps<T>): react_jsx_runtime.JSX.Element;
+
+interface ResizableTextareaBaseProps {
+    wrapperClassName?: string;
+    resizable?: boolean;
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+}
+interface ResizableTextareaFieldProps extends ResizableTextareaBaseProps, Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'color'> {
+    mode?: never;
+    language?: never;
+    children?: never;
+    minHeight?: never;
+    onHeightChange?: never;
+}
+interface ResizableTextareaCodeProps extends ResizableTextareaBaseProps {
+    mode: 'code';
+    language?: string;
+    value?: string;
+    onChange?: (value: string) => void;
+    readOnly?: boolean;
+    minHeight?: number;
+    onHeightChange?: (height: number) => void;
+    children?: never;
+}
+interface ResizableTextareaChildrenProps extends ResizableTextareaBaseProps {
+    mode?: never;
+    language?: never;
+    children: React.ReactNode;
+    minHeight?: number;
+    onHeightChange?: (height: number) => void;
+}
+type ResizableTextareaProps = ResizableTextareaFieldProps | ResizableTextareaCodeProps | ResizableTextareaChildrenProps;
+declare function ResizableTextarea(props: ResizableTextareaProps): react_jsx_runtime.JSX.Element;
+
+interface SelectOption<T extends string | number = string> {
+    value: T;
+    label: string;
+    icon?: ReactNode;
+}
+interface SelectProps<T extends string | number = string> {
+    value: T;
+    options: SelectOption<T>[];
+    onChange: (value: T) => void;
+    placeholder?: string;
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    align?: 'left' | 'right';
+    disabled?: boolean;
+    className?: string;
+}
+declare function Select<T extends string | number = string>({ value, options, onChange, placeholder, variant, color, size, align, disabled, className, }: SelectProps<T>): react_jsx_runtime.JSX.Element;
+
+interface FilterDropdownProps {
+    value: string;
+    onChange: (value: string) => void;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    allLabel: string;
+    labelExtra?: ReactNode;
+    clearable?: boolean;
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+}
+declare function FilterDropdown({ value, onChange, options, allLabel, labelExtra, clearable, variant, color, }: FilterDropdownProps): react_jsx_runtime.JSX.Element;
+
+interface SortField {
+    value: string;
+    label: string;
+    /** Label suffix when ascending (default: "↑") */
+    ascLabel?: string;
+    /** Label suffix when descending (default: "↓") */
+    descLabel?: string;
+}
+interface SortDropdownProps {
+    field: string;
+    ascending: boolean;
+    onFieldChange: (field: string) => void;
+    onToggleDirection: () => void;
+    fields: SortField[];
+    variant?: 'filled' | 'outline';
+    color?: FormColor;
+}
+declare function SortDropdown({ field, ascending, onFieldChange, onToggleDirection, fields, variant, color, }: SortDropdownProps): react_jsx_runtime.JSX.Element;
+
+interface FormActionsProps {
+    /** Cancel handler — renders X button. Optional (e.g. AlertModal has no cancel). */
+    onCancel?: () => void;
+    cancelTooltip?: string;
+    /** Back handler — optional, renders left-arrow on the left side */
+    onBack?: () => void;
+    backTooltip?: string;
+    /** Minimize handler — optional, renders minimize icon before Cancel */
+    onMinimize?: () => void;
+    minimizeTooltip?: string;
+    /** Confirm handler — optional, renders between Cancel and Next */
+    onConfirm?: () => void;
+    confirmTooltip?: string;
+    confirmIcon?: IconName;
+    confirmColor?: IconButtonProps['color'];
+    confirmDisabled?: boolean;
+    confirmStatus?: IconButtonStatus;
+    /** Next handler — optional, renders right-arrow for wizard navigation */
+    onNext?: () => void;
+    nextTooltip?: string;
+    /** Status text shown on the left side of the footer */
+    statusText?: string;
+    border?: boolean;
+    padding?: 'compact' | 'normal' | 'modal';
+}
+declare function FormActions({ onCancel, cancelTooltip, onBack, backTooltip, onMinimize, minimizeTooltip, onConfirm, confirmTooltip, confirmIcon, confirmColor, confirmDisabled, confirmStatus, onNext, nextTooltip, statusText, border, padding, }: FormActionsProps): react_jsx_runtime.JSX.Element;
+
+type ModalKind = 'info' | 'warning' | 'error' | 'orange' | 'success';
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl';
+interface ConfirmModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void | Promise<void>;
+    title: string;
+    message: string;
+    warning?: string;
+    warningItems?: string[];
+    kind?: ModalKind;
+    confirmColor?: 'red' | 'blue' | 'orange' | 'yellow';
+    isLoading?: boolean;
+    confirmDisabled?: boolean;
+}
+declare function ConfirmModal({ isOpen, onClose, onConfirm, title, message, warning, warningItems, kind, confirmColor, isLoading, confirmDisabled, }: ConfirmModalProps): react_jsx_runtime.JSX.Element;
+interface AlertModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    message: string;
+    kind?: ModalKind;
+}
+declare function AlertModal({ isOpen, onClose, title, message, kind, }: AlertModalProps): react_jsx_runtime.JSX.Element;
+
+type IconProps = {
+    className?: string;
+    style?: React.CSSProperties;
+};
+type CodingToolId = 'claude-code' | 'github-copilot' | 'codex-cli' | 'gemini-cli' | 'opencode';
+type CodingToolPresetConfig = CodingToolId | {
+    id: CodingToolId;
+    description?: string;
+    disabled?: boolean;
+};
+interface SelectionCardItem {
+    id: string;
+    icon?: IconName;
+    /** Custom SVG icon component. Receives className and style. Takes precedence over `icon`. */
+    IconComponent?: React.ComponentType<IconProps>;
+    name: string;
+    description?: string;
+    /** Accent color for selected state border/bg. CSS color string like '#a78bfa' */
+    color?: string;
+    /** Named color for the confirm badge. Defaults to 'blue'. */
+    badgeColor?: ConfirmBadgeColor;
+    disabled?: boolean;
+}
+interface SelectionGridProps {
+    /** Custom items with manual icon/name/color configuration */
+    items?: SelectionCardItem[];
+    /** Built-in coding tool presets. Pass tool IDs or config objects. Ignored when `items` is provided. */
+    presets?: CodingToolPresetConfig[];
+    selectedIds: string[];
+    onSelect: (ids: string[]) => void;
+    /** Single selection or multiple */
+    mode?: 'single' | 'multiple';
+    /** Grid (icon-top cards) or list (icon-left rows) */
+    layout?: 'grid' | 'list';
+    /** Number of columns for grid layout (auto if not set) */
+    columns?: number;
+    className?: string;
+}
+declare function SelectionGrid({ items: itemsProp, presets, selectedIds, onSelect, mode, layout, columns, className, }: SelectionGridProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ExecutionDetailsPanel - Shows AI execution configuration before running actions
+ *
+ * Displays tool, permissions, output format, CLI flags, and change handling.
+ * Optional "Allow direct edits" toggle with warning message.
+ * Used inside ActionDialog as the mandatory execution details section.
+ */
+interface ExecutionDetailRow {
+    label: string;
+    value: string;
+    mono?: boolean;
+}
+interface ExecutionDetailsPanelProps {
+    details: ExecutionDetailRow[];
+    /** Show the "Allow direct edits" toggle */
+    allowDirectEdits?: boolean;
+    onAllowDirectEditsChange?: (value: boolean) => void;
+    /** Warning message shown below the toggle */
+    warningMessage?: string;
+    className?: string;
+}
+declare function ExecutionDetailsPanel({ details, allowDirectEdits, onAllowDirectEditsChange, warningMessage, className, }: ExecutionDetailsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface ActionDialogProps {
+    /** Dialog title */
+    title: string;
+    /** Subtitle text next to title */
+    subtitle?: string;
+    /** Icon displayed before title */
+    icon?: IconName;
+    /** Icon color */
+    iconColor?: string;
+    /** Settings gear button callback */
+    onSettings?: () => void;
+    /** Cancel/close callback */
+    onCancel?: () => void;
+    /** Submit/action callback */
+    onSubmit?: () => void;
+    /** Submit button label (shown in tooltip) */
+    submitLabel?: string;
+    /** Submit button icon */
+    submitIcon?: IconName;
+    /** Submit button color variant */
+    submitColor?: string;
+    /** Disable submit button */
+    submitDisabled?: boolean;
+    /** Status text shown in footer left */
+    statusText?: string;
+    /** Label above the selection grid (e.g. "AI Tool:") */
+    selectionLabel?: string;
+    /** Custom selection items - renders SelectionGrid when provided */
+    items?: SelectionCardItem[];
+    /** Built-in AI tool presets. Ignored when `items` is provided. */
+    presets?: CodingToolPresetConfig[];
+    /** Currently selected item IDs */
+    selectedIds?: string[];
+    /** Selection change handler */
+    onSelect?: (ids: string[]) => void;
+    /** Single or multiple selection */
+    selectionMode?: 'single' | 'multiple';
+    /** Grid (icon-top cards) or list (icon-left rows) */
+    selectionLayout?: 'grid' | 'list';
+    /** Grid column count (auto if not set) */
+    selectionColumns?: number;
+    /** Label above scenarios (e.g. "Select scenarios to run:") */
+    scenarioLabel?: string;
+    /** Scenario items - renders second SelectionGrid when provided */
+    scenarios?: SelectionCardItem[];
+    /** Currently selected scenario IDs */
+    selectedScenarioIds?: string[];
+    /** Scenario selection change handler */
+    onSelectScenarios?: (ids: string[]) => void;
+    /** Scenario grid layout */
+    scenarioLayout?: 'grid' | 'list';
+    /** Scenario grid column count */
+    scenarioColumns?: number;
+    /** Execution detail rows (Tool, Permissions, Output, CLI Flags, Changes) */
+    executionDetails: ExecutionDetailRow[];
+    /** Whether direct file edits are allowed */
+    allowDirectEdits?: boolean;
+    /** Callback to toggle direct edits - shows the toggle when provided */
+    onAllowDirectEditsChange?: (value: boolean) => void;
+    /** Warning message shown in the execution details section */
+    executionWarning?: string;
+    /** Additional content rendered between scenarios and execution details */
+    children?: React.ReactNode;
+    /** Additional className */
+    className?: string;
+}
+declare function ActionDialog({ title, subtitle, icon, iconColor, onSettings, onCancel, onSubmit, submitLabel, submitIcon, submitColor, submitDisabled, statusText, selectionLabel, items, presets, selectedIds, onSelect, selectionMode, selectionLayout, selectionColumns, scenarioLabel, scenarios, selectedScenarioIds, onSelectScenarios, scenarioLayout, scenarioColumns, executionDetails, allowDirectEdits, onAllowDirectEditsChange, executionWarning, children, className, }: ActionDialogProps): react.ReactPortal;
+
+interface SettingRowBase {
+    label: string;
+    description?: string;
+    disabled?: boolean;
+    className?: string;
+}
+interface SettingRowToggle extends SettingRowBase {
+    type: 'toggle';
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    color?: ToggleColor;
+    size?: ToggleSize;
+    variant?: ToggleVariant;
+}
+interface SettingRowSelect extends SettingRowBase {
+    type: 'select';
+    value: string;
+    options: SelectOption[];
+    onChange: (value: string) => void;
+    selectSize?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    selectVariant?: 'filled' | 'outline';
+}
+interface SettingRowInput extends SettingRowBase {
+    type: 'input';
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    inputSize?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    inputVariant?: 'filled' | 'outline';
+}
+type SettingRowProps = SettingRowToggle | SettingRowSelect | SettingRowInput;
+declare function SettingRow(props: SettingRowProps): react_jsx_runtime.JSX.Element;
+
+interface FileTreeNode {
+    name: string;
+    type: 'file' | 'directory';
+    children?: FileTreeNode[];
+}
+interface FileTreeProps {
+    nodes: FileTreeNode[];
+    rootName?: string;
+    selectedPath: string | null;
+    onSelectFile: (path: string) => void;
+    prefix?: string;
+    expandedPaths: Set<string>;
+    onTogglePath: (path: string) => void;
+    accentColor?: string;
+}
+/** Collect all directory paths that would be rendered in the tree */
+declare function collectDirPaths(nodes: FileTreeNode[], rootName?: string, prefix?: string): Set<string>;
+declare function FileTree({ nodes, rootName, selectedPath, onSelectFile, prefix, expandedPaths, onTogglePath, accentColor }: FileTreeProps): react_jsx_runtime.JSX.Element;
+
+interface EditorToolbarProps {
+    /** Whether content has unsaved changes */
+    isDirty: boolean;
+    /** Whether save operation is in progress */
+    isSaving?: boolean;
+    /** Called when save button is clicked */
+    onSave: () => void;
+    /** Optional: Whether reset is available */
+    canReset?: boolean;
+    /** Optional: Called when reset button is clicked */
+    onReset?: () => void;
+    /** Optional: Tooltip for reset button */
+    resetTooltip?: {
+        title: string;
+        description: string;
+    };
+    /** Optional: Whether editor is read-only */
+    isReadOnly?: boolean;
+    /** Optional: Validation error preventing save */
+    hasError?: boolean;
+    /** Optional: Additional action buttons on the left side */
+    leftActions?: ActionItem[];
+    /** Optional: Additional action buttons on the right side (before save) */
+    rightActions?: ActionItem[];
+}
+declare function EditorToolbar({ isDirty, isSaving, onSave, canReset, onReset, resetTooltip, isReadOnly, hasError, leftActions, rightActions, }: EditorToolbarProps): react_jsx_runtime.JSX.Element | null;
+
+/** Status banner configuration for outdated/info messages */
+interface StatusBanner {
+    /** Message to display */
+    message: string;
+    /** Banner type affects styling */
+    type: 'warning' | 'info';
+    /** Optional action button label */
+    actionLabel?: string;
+    /** Optional action callback */
+    onAction?: () => void;
+}
+interface PanelTab<T extends string = string> {
+    /** Unique identifier for the tab */
+    id: T;
+    /** Display label */
+    label: string;
+    /** Icon name from iconMap */
+    icon?: IconName;
+    /** Custom icon component (should accept className for sizing) */
+    IconComponent?: React.ComponentType<{
+        className?: string;
+        style?: React.CSSProperties;
+    }>;
+    /** Optional count badge */
+    count?: number;
+    /** Color for the count badge */
+    countColor?: BadgeColor;
+    /** Tailwind classes for active text/border color (e.g., 'text-orange-400') */
+    activeTextClass?: string;
+    /** Tailwind classes for active border color (e.g., 'border-orange-400'). Defaults to 'border-current' */
+    activeBorderClass?: string;
+    /** Hide label on small screens */
+    hideLabel?: boolean;
+    /** Test ID for E2E testing */
+    testId?: string;
+}
+interface BottomPanelHeaderProps<T extends string = string> {
+    /** Array of tab configurations */
+    tabs: PanelTab<T>[];
+    /** Currently active tab ID */
+    activeTab: T;
+    /** Callback when tab changes */
+    onTabChange: (tabId: T) => void;
+    /** Action buttons to render (right side, before collapse button) */
+    actions?: ActionItem[];
+    /** Escape hatch: arbitrary ReactNode actions (e.g. AiActionButton) */
+    customActions?: ReactNode;
+    /** Custom class name for the header container */
+    className?: string;
+    /** Custom left content to replace tabs (e.g., for "ignored" mode) */
+    customLeftContent?: ReactNode;
+    /** Optional status banner (e.g., "Results may be outdated") */
+    statusBanner?: StatusBanner;
+    /** Callback when collapse button is clicked */
+    onCollapse?: () => void;
+}
+declare function BottomPanelHeader<T extends string = string>({ tabs, activeTab, onTabChange, actions, customActions, className, customLeftContent, statusBanner, onCollapse, }: BottomPanelHeaderProps<T>): react_jsx_runtime.JSX.Element;
+
+interface FrontmatterFormHeaderProps {
+    collapsed: boolean;
+    onToggle: () => void;
+    /** Summary text shown when collapsed */
+    renderSummary: () => string;
+    children: ReactNode;
+    /** Whether frontmatter is currently enabled (content has ---) */
+    frontmatterEnabled?: boolean;
+    /** Toggle frontmatter on/off */
+    onFrontmatterToggle?: (enabled: boolean) => void;
+    readOnly?: boolean;
+}
+declare function FrontmatterFormHeader({ collapsed, onToggle, renderSummary, children, frontmatterEnabled, onFrontmatterToggle, readOnly, }: FrontmatterFormHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface EditorPlaceholderCardProps {
+    /** Placeholder name (without braces) */
+    name: string;
+    /** Description text */
+    description: string;
+    /** Value/example content */
+    value?: string;
+    /** Whether this placeholder is required */
+    required?: boolean;
+    /** Label for the value section (default: "Value:") */
+    valueLabel?: string;
+    /** Color scheme */
+    accentColor?: 'purple' | 'blue' | 'neutral' | 'sky';
+    /** Action buttons to show on the right (e.g., edit/delete for settings) */
+    actions?: ActionItem[];
+    /** Show copy button that copies the {{PLACEHOLDER}} syntax */
+    showCopyPlaceholder?: boolean;
+    /** Show copy button that copies the actual value */
+    showCopyValue?: boolean;
+    /** Hide the value behind ****** with a toggle to reveal */
+    hideValue?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+declare function EditorPlaceholderCard({ name, description, value, required, valueLabel, accentColor, actions, showCopyPlaceholder, showCopyValue, hideValue, className, }: EditorPlaceholderCardProps): react_jsx_runtime.JSX.Element;
+
+interface DetailViewWrapperProps {
+    /** Main editor content */
+    editorContent?: ReactNode;
+    /** Action buttons rendered in navigation bar */
+    actions?: ReactNode;
+    /** Optional bottom panel */
+    bottomPanel?: ReactNode;
+    /** Optional right sidebar */
+    rightSidebar?: ReactNode;
+    showRightSidebar?: boolean;
+}
+declare function DetailViewWrapper({ editorContent, actions, bottomPanel, rightSidebar, showRightSidebar, }: DetailViewWrapperProps): react_jsx_runtime.JSX.Element;
+
+type RegistryItemType = 'skill' | 'hook' | 'agent' | 'command' | 'plugin' | 'mcp' | 'settings';
+type ExtensionSource = 'project' | 'plugin' | 'user' | 'local';
+declare function formatCategory(category: string): string;
+interface SeedrItemStatus {
+    updateAvailable: boolean;
+    modified: boolean;
+}
+interface RegistryCardBase {
+    onClick: () => void;
+    flash?: 'success' | 'error' | 'warning' | null;
+    name: string;
+    type: string;
+    description?: string;
+    errorMessage?: string;
+    onInstall: () => void;
+    isInstalling?: boolean;
+    updatedAt?: string;
+    onDateClick?: () => void;
+}
+interface SeedrVariant extends RegistryCardBase {
+    variant: 'seedr';
+    author: string;
+    sourceType: string;
+    pluginType?: string;
+    wrapper?: string;
+    installedScopes?: ReadonlySet<ExtensionSource>;
+    viewScope?: 'user' | 'project';
+    status?: SeedrItemStatus;
+    compatibility: string[];
+    packageCounts?: Record<string, number>;
+    isDisabled?: boolean;
+    onActivate?: () => void;
+    onRemove?: (scope: ExtensionSource) => void;
+    onFilterSource?: () => void;
+    onFilterPluginType?: (pluginType: string) => void;
+    /** Render scope confirmation modal */
+    renderScopeConfirm?: (props: {
+        isOpen: boolean;
+        onClose: () => void;
+        onConfirm: () => void;
+        name: string;
+    }) => ReactNode;
+}
+interface ClaudePluginsVariant extends RegistryCardBase {
+    variant: 'claude-plugins';
+    author: string;
+    category?: string;
+    stars?: number;
+    downloads?: number;
+    installedScopes?: ReadonlySet<ExtensionSource>;
+    viewScope?: 'user' | 'project';
+    onRemove?: () => void;
+    onSortBy?: (field: string) => void;
+    onFilterCategory?: (category: string) => void;
+    /** Tool keys compatible with this item type */
+    compatibleTools?: string[];
+    /** Render scope confirmation modal */
+    renderScopeConfirm?: (props: {
+        isOpen: boolean;
+        onClose: () => void;
+        onConfirm: () => void;
+        name: string;
+    }) => ReactNode;
+}
+interface AitmplVariant extends RegistryCardBase {
+    variant: 'aitmpl';
+    category: string;
+    installedScopes?: ReadonlySet<ExtensionSource>;
+    viewScope?: 'user' | 'project';
+    onRemove?: () => void;
+    onFilterCategory?: (category: string) => void;
+    /** Render scope confirmation modal */
+    renderScopeConfirm?: (props: {
+        isOpen: boolean;
+        onClose: () => void;
+        onConfirm: () => void;
+        name: string;
+    }) => ReactNode;
+}
+interface SkillsShVariant extends RegistryCardBase {
+    variant: 'skills-sh';
+    author: string;
+    installs?: number;
+    installedScopes?: ReadonlySet<ExtensionSource>;
+    viewScope?: 'user' | 'project';
+    onRemove?: () => void;
+    /** All tool keys to show in bottom row */
+    allToolKeys?: string[];
+    /** Render scope confirmation modal */
+    renderScopeConfirm?: (props: {
+        isOpen: boolean;
+        onClose: () => void;
+        onConfirm: () => void;
+        name: string;
+    }) => ReactNode;
+}
+type RegistryCardProps = SeedrVariant | ClaudePluginsVariant | AitmplVariant | SkillsShVariant;
+declare function RegistryCard(props: RegistryCardProps): react_jsx_runtime.JSX.Element;
+
+type PreviewMode = 'format' | 'language' | 'plain';
+type AccentColor = 'blue' | 'purple' | 'orange' | 'green' | 'pink' | 'amber' | 'emerald' | 'teal' | 'sky';
+interface FileStructureSectionProps {
+    files: FileTreeNode[] | null;
+    rootName: string;
+    isLoading?: boolean;
+    error?: string | null;
+    onFetchContent: (relativePath: string) => Promise<string>;
+    /** Enable the Format option in the mode toggle (renders markdown). */
+    format?: boolean;
+    /** Enable the Language option in the mode toggle (syntax highlighting). */
+    language?: boolean;
+    /**
+     * Default active mode when multiple options are enabled.
+     * Only relevant when both `format` and `language` are true.
+     * Defaults to `'format'` when both are set.
+     */
+    default?: PreviewMode;
+    /** Accent color applied to icons, selected state, and the mode toggle. Defaults to 'blue'. */
+    accentColor?: AccentColor;
+    /** Custom renderer called when mode is 'language'. Receives the resolved language as third arg. */
+    renderPreview?: (content: string, filePath: string, language: string) => ReactNode;
+}
+declare function getLanguageFromPath(filePath: string): string;
+declare function FileStructureSection({ files, rootName, isLoading, error, onFetchContent, format, language, default: defaultMode, accentColor, renderPreview, }: FileStructureSectionProps): react_jsx_runtime.JSX.Element | null;
+
+interface RegistryDetailProps {
+    icon: LucideIcon;
+    iconColor: string;
+    title: string;
+    titleExtra?: ReactNode;
+    subtitle: ReactNode;
+    actionButton?: ReactNode;
+    labels?: LabelProps[];
+    description?: string;
+    longDescription?: string;
+    integration?: boolean;
+    compatibleTools?: string[];
+    files?: FileStructureSectionProps['files'];
+    rootName?: string;
+    onFetchContent?: FileStructureSectionProps['onFetchContent'];
+    aboveHeader?: ReactNode;
+    maxWidth?: string;
+    children?: ReactNode;
+}
+declare function RegistryDetail({ icon: Icon, iconColor, title, titleExtra, subtitle, actionButton, labels, description, longDescription, integration, compatibleTools, files, rootName, onFetchContent, aboveHeader, maxWidth, children, }: RegistryDetailProps): react_jsx_runtime.JSX.Element;
+
+interface RegistryBrowserProps {
+    isLoading: boolean;
+    loadingMessage?: string;
+    error: string | null;
+    isEmpty: boolean;
+    emptyMessage?: string;
+    onRetry?: () => void;
+    searchQuery: string;
+    onSearchChange: (q: string) => void;
+    onSearchSubmit?: () => void;
+    searchPlaceholder?: string;
+    debounceKey?: number;
+    debounceDurationMs?: number;
+    toolbarCenter?: ReactNode;
+    toolbarEnd?: ReactNode;
+    onRefresh?: () => void;
+    refreshTooltip?: {
+        title?: string;
+        description: string;
+    };
+    aboveGrid?: ReactNode;
+    hasActiveFilters?: boolean;
+    onResetFilters?: () => void;
+    initialScrollTop?: number;
+    onScrollChange?: (scrollTop: number) => void;
+    maxWidth?: string;
+    items: RegistryCardProps[];
+}
+declare function RegistryBrowser({ isLoading, loadingMessage, error, isEmpty, emptyMessage, onRetry, searchQuery, onSearchChange, onSearchSubmit, searchPlaceholder, debounceKey, debounceDurationMs, toolbarCenter, toolbarEnd, onRefresh, refreshTooltip, aboveGrid, hasActiveFilters, onResetFilters, initialScrollTop, onScrollChange, maxWidth, items, }: RegistryBrowserProps): react_jsx_runtime.JSX.Element;
+
+type AiActionStatus = 'idle' | 'running' | 'completed';
+type AiCompletionResult = 'success' | 'partial' | 'error';
+interface AiActionButtonProps {
+    /** Current execution status */
+    status?: AiActionStatus;
+    /** Result when status is 'completed' */
+    completionResult?: AiCompletionResult;
+    /** Icon shown in default state */
+    icon: IconName;
+    /** Icon shown when running (defaults to 'loader') */
+    runningIcon?: IconName;
+    /** Icon shown when completed successfully (defaults to 'check-circle') */
+    completedIcon?: IconName;
+    /** Base tooltip (title/description modified based on state) */
+    tooltip: {
+        title: string;
+        description: string;
+    };
+    /** Tooltip title when running (defaults to "Show {title} Progress") */
+    runningTooltipTitle?: string;
+    /** Tooltip title when completed (defaults to "View {title} Results") */
+    completedTooltipTitle?: string;
+    onClick?: () => void;
+    /** Force disabled state (in addition to automatic running state) */
+    disabled?: boolean;
+    /** Custom reason when force-disabled */
+    disabledReason?: string;
+    /** Color in default state */
+    color?: IconButtonProps['color'];
+    /** Color when completed successfully (defaults to 'green') */
+    completedColor?: IconButtonProps['color'];
+    size?: IconButtonProps['size'];
+    className?: string;
+    testId?: string;
+}
+declare function AiActionButton({ status, completionResult, icon, runningIcon, completedIcon, tooltip, runningTooltipTitle, completedTooltipTitle, onClick, disabled: forceDisabled, disabledReason, color, completedColor, size, className, testId, }: AiActionButtonProps): react_jsx_runtime.JSX.Element;
+
+type ExecutionStatus = 'running' | 'success' | 'partial' | 'error';
+interface AiExecutionActionButtonsProps {
+    /** Whether execution is currently running */
+    isRunning: boolean;
+    /** Whether all execution is complete */
+    allDone: boolean;
+    /** Called when minimize/pin button clicked - hide modal, continue process */
+    onMinimize: () => void;
+    /** Called when cancel/stop button clicked - kill process. If not provided, cancel button is hidden */
+    onCancel?: () => void;
+    /** Called when done/close button clicked */
+    onClose: () => void;
+    /** Completion status - affects done button icon/color */
+    status?: ExecutionStatus;
+    /** Prefix for test IDs (e.g., 'scan-modal' results in 'scan-modal-minimize-btn') */
+    testIdPrefix?: string;
+}
+declare function AiExecutionActionButtons({ isRunning, allDone, onMinimize, onCancel, onClose, status, testIdPrefix, }: AiExecutionActionButtonsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Issue Reporter API — Types and submission client
+ *
+ * Part of: Sections > Report a Bug
+ *
+ * This module defines the shared types for issue reporting and provides
+ * the HTTP client that submits reports to a Cloudflare Worker endpoint.
+ * The worker creates Linear issues with optional screenshot uploads and
+ * duplicate detection.
+ *
+ * AI agent notes:
+ * - workerUrl is passed per-call so different apps can use different endpoints
+ * - linearTeamId/linearProjectId are sent in the request body, allowing one
+ *   worker to serve multiple apps (the worker must read these from the body)
+ * - The worker source lives at /reviewr/workers/issue-reporter/
+ * - ScreenshotAttachment.data is base64-encoded (no data URL prefix)
+ * - SystemInfo must be provided by the consuming app (e.g. via Tauri invoke,
+ *   navigator.userAgent, or a custom endpoint)
+ */
+type IssueType = 'bug' | 'feature' | 'question' | 'improvement' | 'documentation';
+declare const ISSUE_TYPES: {
+    value: IssueType;
+    label: string;
+}[];
+interface SystemInfo {
+    os: string;
+    osVersion: string;
+    appVersion: string;
+    arch: string;
+}
+interface ScreenshotAttachment {
+    filename: string;
+    data: string;
+    contentType: string;
+}
+interface IssueReport {
+    title: string;
+    description: string;
+    type: IssueType;
+    stackTrace?: string;
+    errorFingerprint?: string;
+    systemInfo: SystemInfo;
+    userEmail?: string;
+    screenshots?: ScreenshotAttachment[];
+    /** Target Linear team — allows one worker to serve multiple apps */
+    linearTeamId?: string;
+    /** Target Linear project (optional) */
+    linearProjectId?: string;
+}
+interface IssueReportResult {
+    success: boolean;
+    issueId?: string;
+    message: string;
+    isDuplicate?: boolean;
+    url?: string;
+}
+declare function submitIssueReport(workerUrl: string, report: IssueReport): Promise<IssueReportResult>;
+
+/**
+ * Error Logger — Automatic console error capture for issue reporting
+ *
+ * Part of: Sections > Report a Bug
+ *
+ * Provides a factory function to create app-specific error loggers.
+ * Each logger instance has its own localStorage namespace and in-memory state.
+ *
+ * Usage:
+ *   const logger = createErrorLogger('myapp')
+ *   logger.init()  // Call early in app startup to begin capturing
+ *   // Later, pass captured data to ReportBugForm:
+ *   <ReportBugForm
+ *     errorReport={logger.getFormattedReport()}
+ *     errorCount={logger.getErrorCount()}
+ *     warnCount={logger.getWarnCount()}
+ *     onErrorsSubmitted={() => { logger.markAsSubmitted(); logger.clearLogs() }}
+ *   />
+ *
+ * AI agent notes:
+ * - createErrorLogger returns an isolated instance with its own storage prefix
+ * - Three-list architecture: Current (active) -> Submitted (reported) | Dismissed (ignored)
+ * - Errors are deduplicated by fingerprint (djb2 hash of first error line)
+ * - init() intercepts console.error, console.warn, and window error events
+ * - subscribe/getSnapshot are for React's useSyncExternalStore
+ * - The form component (ReportBugForm) does NOT depend on this directly;
+ *   it accepts errorReport/errorCount as props, keeping the two decoupled
+ */
+interface TrackedError {
+    fingerprint: string;
+    firstMessage: string;
+    count: number;
+    firstSeen: string;
+    lastSeen: string;
+    stack?: string;
+}
+interface ErrorLogger {
+    /** Start capturing console.error, console.warn, and unhandled errors */
+    init(): void;
+    /** Number of unique current (unreported) errors */
+    getErrorCount(): number;
+    /** Number of warnings in the log buffer */
+    getWarnCount(): number;
+    /** Current errors not yet submitted or dismissed */
+    getCurrentErrors(): TrackedError[];
+    /** Previously submitted errors */
+    getSubmittedErrors(): TrackedError[];
+    /** Markdown-formatted error report for Linear issue submission */
+    getFormattedReport(): string;
+    /** Combined fingerprint of all current errors (for duplicate detection) */
+    getErrorFingerprint(): string;
+    /** Raw log output as a string */
+    getLogs(): string;
+    /** Move all current errors to the submitted list */
+    markAsSubmitted(): void;
+    /** Move all current errors to the dismissed list */
+    markAsDismissed(): void;
+    /** Clear the in-memory log buffer (does not affect tracked errors) */
+    clearLogs(): void;
+    /** For React useSyncExternalStore */
+    subscribe(listener: () => void): () => void;
+    /** For React useSyncExternalStore */
+    getSnapshot(): number;
+}
+declare function createErrorLogger(storagePrefix: string): ErrorLogger;
+
+interface ReportBugFormProps {
+    /** URL of the issue reporter worker endpoint */
+    workerUrl: string;
+    /** Function that returns system info. Each app provides its own implementation. */
+    getSystemInfo: () => Promise<SystemInfo>;
+    /** Linear team ID — routes issues to the correct team */
+    linearTeamId?: string;
+    /** Linear project ID — associates issues with a project */
+    linearProjectId?: string;
+    /** Pre-formatted error report to optionally include (from error logger) */
+    errorReport?: string;
+    /** Error fingerprint for duplicate detection */
+    errorFingerprint?: string;
+    /** Number of captured errors (shown in checkbox label) */
+    errorCount?: number;
+    /** Number of captured warnings */
+    warnCount?: number;
+    /** Captured error entries to display when "include logs" is checked */
+    capturedErrors?: TrackedError[];
+    /** Called after successful submission */
+    onSuccess?: (result: IssueReportResult) => void;
+    /** Called on submission failure */
+    onError?: (message: string) => void;
+    /** Called when user clicks cancel (hidden if not provided) */
+    onCancel?: () => void;
+    /** Called when error logs are included in a successful submission */
+    onErrorsSubmitted?: () => void;
+    /** Override default API submission (for testing/mocking) */
+    submitFn?: (report: IssueReport) => Promise<IssueReportResult>;
+    className?: string;
+}
+declare function ReportBugForm({ workerUrl, getSystemInfo, linearTeamId, linearProjectId, errorReport, errorFingerprint, errorCount, warnCount, capturedErrors, onSuccess, onError, onCancel, onErrorsSubmitted, submitFn, className, }: ReportBugFormProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ScreenshotUploader — Drag & drop multi-image upload
+ *
+ * Part of: Sections > Report a Bug
+ * Also usable standalone for any image upload scenario.
+ *
+ * Features:
+ * - Drag & drop or click to select images
+ * - Base64 encoding for API submission
+ * - Preview thumbnails in a 3-column grid
+ * - Total size limit enforcement (default 20MB)
+ * - Individual screenshot removal
+ *
+ * AI agent notes:
+ * - Fully controlled component: parent owns the screenshots array
+ * - Screenshot.data is base64 without the data URL prefix
+ * - The Screenshot type (with id, size) is for UI management;
+ *   ScreenshotAttachment (without id, size) is what gets sent to the API
+ * - Used by ReportBugForm but exported independently
+ */
+interface Screenshot {
+    id: string;
+    filename: string;
+    data: string;
+    contentType: string;
+    size: number;
+}
+interface ScreenshotUploaderProps {
+    screenshots: Screenshot[];
+    onChange: (screenshots: Screenshot[]) => void;
+    maxTotalSize?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare function ScreenshotUploader({ screenshots, onChange, maxTotalSize, disabled, className, }: ScreenshotUploaderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useReportBug — Form state and submission hook
+ *
+ * Part of: Sections > Report a Bug
+ *
+ * Manages all form state (issue type, title, description, email, screenshots,
+ * include-logs toggle) and the async submission flow with status updates.
+ *
+ * AI agent notes:
+ * - This hook is used internally by ReportBugForm but can also be used
+ *   standalone for custom form UIs
+ * - Uses callbacks (onSuccess/onError) instead of alert modals for flexibility
+ * - Error data (errorReport, errorFingerprint) comes as options, not from
+ *   an imported error logger — keeps the hook decoupled
+ * - The hook resets the form on successful submission
+ * - submitFn can override the default API call (useful for testing/mocking)
+ */
+
+interface UseReportBugOptions {
+    /** Issue reporter worker endpoint URL */
+    workerUrl: string;
+    /** Returns system info (OS, version, etc.) — each app provides its own */
+    getSystemInfo: () => Promise<SystemInfo>;
+    /** Linear team to route issues to */
+    linearTeamId?: string;
+    /** Linear project to associate issues with */
+    linearProjectId?: string;
+    /** Pre-formatted error report string (from error logger or custom source) */
+    errorReport?: string;
+    /** Combined error fingerprint for duplicate detection */
+    errorFingerprint?: string;
+    /** Called after successful submission */
+    onSuccess?: (result: IssueReportResult) => void;
+    /** Called on submission failure */
+    onError?: (message: string) => void;
+    /** Called when error logs are included in a successful submission */
+    onErrorsSubmitted?: () => void;
+    /** Override default API submission (useful for testing/mocking) */
+    submitFn?: (report: IssueReport) => Promise<IssueReportResult>;
+}
+interface UseReportBugReturn {
+    issueType: IssueType;
+    setIssueType: (type: IssueType) => void;
+    title: string;
+    setTitle: (title: string) => void;
+    description: string;
+    setDescription: (desc: string) => void;
+    email: string;
+    setEmail: (email: string) => void;
+    screenshots: Screenshot[];
+    setScreenshots: (screenshots: Screenshot[]) => void;
+    includeLogs: boolean;
+    setIncludeLogs: (include: boolean) => void;
+    isSubmitting: boolean;
+    submissionStatus: string;
+    emailHasError: boolean;
+    canSubmit: boolean;
+    handleSubmit: () => Promise<void>;
+}
+declare function useReportBug(options: UseReportBugOptions): UseReportBugReturn;
+
+/**
+ * Golden Snapshots — Shared type definitions
+ *
+ * Part of: Sections > Golden Snapshots
+ *
+ * These types define the CONTRACT between the UI layer (this package) and
+ * the Rust/Tauri backend that each app must implement. Every type here has
+ * a 1:1 mapping to a Rust struct returned by Tauri commands.
+ *
+ * IMPORTANT FOR AI AGENTS:
+ * When adding a new field here, the corresponding Rust struct must also be
+ * updated (and vice versa). The serde rename attributes in Rust use camelCase
+ * to match these TypeScript interfaces.
+ *
+ * Generic design:
+ * - Components are keyed by string name (not hardcoded to specific apps)
+ * - Configr uses: "runtime", "verifier", "simulator", "generator"
+ * - Reviewr uses: "runtime", plus app-specific components
+ * - The UI renders whatever components the backend returns
+ */
+/** Version info for a single component (runtime, verifier, etc.) */
+interface ComponentVersion {
+    version: string;
+    description?: string;
+    updatedAt?: string;
+    hash?: string;
+}
+/**
+ * Golden metadata — describes the state of a golden (reference) or live (working) copy.
+ *
+ * Rust equivalent: `GoldenMeta` in mod.rs
+ * Returned by: `get_status`, `get_golden_meta`
+ *
+ * `components` is a flat map of component name → version info.
+ * Each app defines its own component names.
+ */
+interface GoldenMeta {
+    version: string;
+    createdAt: string;
+    description?: string;
+    components: Record<string, ComponentVersion>;
+}
+/** Filesystem status of a directory (golden, live, snapshots, etc.) */
+interface DirectoryStatus {
+    exists: boolean;
+    path: string;
+    fileCount: number;
+    totalSizeBytes: number;
+}
+/** Info about the bundled seed archive */
+interface SeedInfo {
+    exists: boolean;
+    path: string;
+    sizeBytes: number;
+    modifiedAt?: string;
+    meta?: GoldenMeta;
+    fileCount: number;
+    fileList: string[];
+}
+/**
+ * Overall status of the golden/live system.
+ *
+ * Rust equivalent: `ConfigrStatus` in mod.rs (generalize the name per app)
+ * Returned by: `get_status` command
+ *
+ * Contains metadata for both golden and live copies, directory statuses,
+ * and seed info. The UI uses this to render the Status Overview panel.
+ *
+ * `directories` is a flat map so apps can have any number of tracked directories.
+ * Convention: keys are "{component}Golden" and "{component}Live".
+ */
+interface GoldenStatus {
+    goldenMeta?: GoldenMeta;
+    liveMeta?: GoldenMeta;
+    directories: Record<string, DirectoryStatus>;
+    seed: SeedInfo;
+}
+type FileDiffStatus = 'added' | 'removed' | 'modified' | 'unchanged';
+/** A single file's diff info between golden and live */
+interface FileDiffInfo {
+    /** Relative path within the component directory */
+    path: string;
+    /** Which component this file belongs to (e.g. "runtime", "verifier") */
+    component: string;
+    status: FileDiffStatus;
+    goldenSize: number;
+    liveSize: number;
+}
+interface DiffSummary {
+    added: number;
+    removed: number;
+    modified: number;
+    unchanged: number;
+    total: number;
+}
+/** Which components have changes between golden and live */
+type ChangedComponents = Record<string, boolean>;
+/**
+ * Full diff result between golden and live directories.
+ *
+ * Rust equivalent: `GoldenLiveDiff` in mod.rs
+ * Returned by: `get_golden_live_diff` command
+ */
+interface GoldenLiveDiff {
+    files: FileDiffInfo[];
+    summary: DiffSummary;
+    componentChanges: ChangedComponents;
+}
+/** A single snapshot entry in the manifest */
+interface SnapshotInfo {
+    version: number;
+    filename: string;
+    createdAt: string;
+    description?: string;
+    pinned: boolean;
+    metaVersion?: string;
+}
+/**
+ * Manifest listing all snapshots.
+ *
+ * Rust equivalent: `SnapshotsManifest` in mod.rs
+ * Returned by: `list_golden_snapshots` command
+ */
+interface SnapshotsManifest {
+    activeVersion: number;
+    pinnedVersion?: number;
+    snapshots: SnapshotInfo[];
+}
+/** Result from creating a new snapshot */
+interface CreateSnapshotResult {
+    version: number;
+    filename: string;
+    seedUpdated: boolean;
+    changedComponents: ChangedComponents;
+    newMeta: GoldenMeta;
+}
+/** Result from resetting files */
+interface ResetResult {
+    filesReset: number;
+}
+/**
+ * GoldenSnapshotsApi — The callback interface that each app must implement.
+ *
+ * This is the bridge between the shared UI and the app-specific backend.
+ * Each function maps to a Tauri command (or any other backend).
+ *
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │ RUST BACKEND IMPLEMENTATION GUIDE                                   │
+ * │                                                                     │
+ * │ Each method below corresponds to a Tauri #[tauri::command].         │
+ * │ The Rust reference implementation lives in:                         │
+ * │   configr/development/src-tauri/src/commands/snapshots/             │
+ * │     ├── mod.rs          — Types + helpers                           │
+ * │     ├── lifecycle.rs    — All command implementations               │
+ * │     ├── runtime_init.rs — Bootstrap (seed → golden → live)          │
+ * │     └── zip_ops.rs      — Zip archive utilities                     │
+ * │                                                                     │
+ * │ REQUIRED Tauri commands for full functionality:                      │
+ * │                                                                     │
+ * │ STATUS & METADATA:                                                  │
+ * │   get_status()              → GoldenStatus                          │
+ * │   get_golden_meta()         → GoldenMeta | null                     │
+ * │   get_golden_live_diff()    → GoldenLiveDiff                        │
+ * │                                                                     │
+ * │ FILE OPERATIONS:                                                    │
+ * │   get_file_content_for_diff(component, path, source) → string|null  │
+ * │   save_live_file_content(component, path, content) → void           │
+ * │   reset_golden_file_to_live(component, path) → void                 │
+ * │   reset_golden_component_to_live(component) → ResetResult           │
+ * │                                                                     │
+ * │ SNAPSHOT MANAGEMENT (devtools only):                                 │
+ * │   create_golden_snapshot(description?) → CreateSnapshotResult        │
+ * │   list_golden_snapshots() → SnapshotsManifest                       │
+ * │   restore_golden_snapshot(version, resetLive) → void                 │
+ * │   pin_golden_snapshot(version, pinned) → void                        │
+ * │   delete_golden_snapshot(version) → void                             │
+ * │                                                                     │
+ * │ VERSION MANAGEMENT:                                                  │
+ * │   update_component_version(component, version, desc?) → void         │
+ * │   bump_golden_version(newVersion, desc?) → void                      │
+ * │                                                                     │
+ * │ DIRECTORY STRUCTURE (Rust backend must maintain):                    │
+ * │   {app_data_dir}/                                                    │
+ * │   ├── golden/              — Reference copy (overwritten on update)  │
+ * │   │   ├── .meta/meta.json  — GoldenMeta serialized                  │
+ * │   │   └── {components}/    — One dir per component                  │
+ * │   ├── live/                — Working copy (user edits preserved)     │
+ * │   │   ├── .meta/meta.json                                           │
+ * │   │   └── {components}/                                             │
+ * │   └── snapshots/           — Versioned zip archives                 │
+ * │       ├── manifest.json    — SnapshotsManifest                      │
+ * │       └── snapshot_v001_YYYY-MM-DD.zip                              │
+ * │                                                                     │
+ * │ KEY BEHAVIORS the Rust backend must implement:                      │
+ * │ 1. Hash-based change detection between golden and live files        │
+ * │ 2. Semver auto-bump per component on snapshot creation              │
+ * │ 3. Selective sync: only update components without user changes      │
+ * │ 4. Snapshot pruning: keep N most recent + all pinned                │
+ * │ 5. Snapshot = zip of live dirs + meta.json                          │
+ * │ 6. create_snapshot copies live → golden after archiving             │
+ * └─────────────────────────────────────────────────────────────────────┘
+ */
+interface GoldenSnapshotsApi {
+    /** Get overall system status (golden/live metadata, directory info, seed) */
+    getStatus: () => Promise<GoldenStatus>;
+    /** Get golden metadata only (lighter than full status) */
+    getGoldenMeta: () => Promise<GoldenMeta | null>;
+    /** Get file-level diff between golden and live directories */
+    getDiff: () => Promise<GoldenLiveDiff>;
+    /** Get content of a single file from golden or live */
+    getFileContent: (component: string, path: string, source: 'golden' | 'live') => Promise<string | null>;
+    /** Save edited content to a live file (devtools only) */
+    saveFile: (component: string, path: string, content: string) => Promise<void>;
+    /** Reset a single file: copy golden → live */
+    resetFile: (component: string, path: string) => Promise<void>;
+    /** Reset an entire component (or 'all'): copy golden → live */
+    resetComponent: (component: string) => Promise<ResetResult>;
+    /** Create a new snapshot from current live state */
+    createSnapshot: (description?: string) => Promise<CreateSnapshotResult>;
+    /** List all snapshots */
+    listSnapshots: () => Promise<SnapshotsManifest>;
+    /** Restore a snapshot by version number */
+    restoreSnapshot: (version: number, resetLive: boolean) => Promise<void>;
+    /** Pin/unpin a snapshot (pinned snapshots are never auto-pruned) */
+    pinSnapshot: (version: number, pinned: boolean) => Promise<void>;
+    /** Delete a snapshot */
+    deleteSnapshot: (version: number) => Promise<void>;
+    /** Update version for a single component */
+    updateComponentVersion: (component: string, version: string, description?: string) => Promise<void>;
+    /** Bump the overall golden version */
+    bumpVersion: (newVersion: string, description?: string) => Promise<void>;
+}
+
+interface DiffTreeNode {
+    files: FileDiffInfo[];
+    children: Record<string, DiffTreeNode>;
+}
+interface UseGoldenSyncOptions {
+    api: GoldenSnapshotsApi;
+    devtools: boolean;
+}
+declare function useGoldenSync({ api, devtools }: UseGoldenSyncOptions): {
+    status: GoldenStatus | null;
+    loading: boolean;
+    error: string | null;
+    lastAction: string | null;
+    loadStatus: () => Promise<void>;
+    diff: GoldenLiveDiff | null;
+    diffLoading: boolean;
+    loadDiff: () => Promise<void>;
+    selectedDiffFile: FileDiffInfo | null;
+    goldenContent: string | null;
+    liveContent: string | null;
+    editedLiveContent: string | null;
+    setEditedLiveContent: react.Dispatch<react.SetStateAction<string | null>>;
+    diffFilter: "all" | FileDiffStatus;
+    setDiffFilter: react.Dispatch<react.SetStateAction<"all" | FileDiffStatus>>;
+    diffSideBySide: boolean;
+    setDiffSideBySide: react.Dispatch<react.SetStateAction<boolean>>;
+    saving: boolean;
+    hasUnsavedChanges: boolean;
+    handleSelectDiffFile: (file: FileDiffInfo) => Promise<void>;
+    handleSaveLiveFile: () => Promise<void>;
+    resettingFile: string | null;
+    resettingComponent: string | null;
+    resettingAll: boolean;
+    showResetAllDialog: boolean;
+    setShowResetAllDialog: react.Dispatch<react.SetStateAction<boolean>>;
+    handleResetFile: (file: FileDiffInfo) => Promise<void>;
+    handleResetComponent: (component: string) => Promise<void>;
+    handleResetAll: () => Promise<void>;
+    groupedFiles: Map<string, DiffTreeNode>;
+    collapsedCategories: Set<string>;
+    toggleCategory: (category: string) => void;
+    countFiles: (node: DiffTreeNode) => number;
+    allCategoryKeys: string[];
+    allExpanded: boolean;
+    handleExpandAll: () => void;
+    handleCollapseAll: () => void;
+    manifest: SnapshotsManifest | null;
+    manifestLoading: boolean;
+    snapshotBusy: boolean;
+    loadManifest: () => Promise<void>;
+    handleCreateSnapshot: (description?: string) => Promise<void>;
+    handleRestoreSnapshot: (version: number, resetLive: boolean) => Promise<void>;
+    handlePinSnapshot: (version: number, pinned: boolean) => Promise<void>;
+    handleDeleteSnapshot: (version: number) => Promise<void>;
+    handleUpdateComponentVersion: (component: string, version: string, description?: string) => Promise<void>;
+    handleBumpVersion: (newVersion: string, description?: string) => Promise<void>;
+    refresh: () => Promise<void>;
+    devtools: boolean;
+};
+type UseGoldenSyncReturn = ReturnType<typeof useGoldenSync>;
+declare function formatDate(isoString: string): string;
+declare function formatBytes(bytes: number): string;
+declare function getLanguage(path: string): string;
+
+type TabId = 'status' | 'diff' | 'snapshots' | 'versions';
+interface GoldenSyncPanelProps {
+    api: GoldenSnapshotsApi;
+    components: string[];
+    devtools?: boolean;
+    componentLabels?: Record<string, string>;
+    monacoTheme?: string;
+    renderFileIcon?: (filename: string, component: string) => ReactNode;
+    onTabChange?: (tab: TabId) => void;
+}
+declare function GoldenSyncPanel({ api, components, devtools, componentLabels, monacoTheme, renderFileIcon, onTabChange, }: GoldenSyncPanelProps): react_jsx_runtime.JSX.Element;
+
+interface StatusOverviewProps {
+    status: GoldenStatus | null;
+    components: string[];
+    componentLabels?: Record<string, string>;
+    devtools: boolean;
+    manifest?: SnapshotsManifest | null;
+    resettingComponent: string | null;
+    resettingAll: boolean;
+    onResetComponent: (component: string) => void;
+    onResetAll: () => void;
+}
+declare function StatusOverview({ status, components, componentLabels, devtools, manifest, resettingComponent, resettingAll, onResetComponent, onResetAll, }: StatusOverviewProps): react_jsx_runtime.JSX.Element;
+
+interface FileDiffViewerProps {
+    sync: UseGoldenSyncReturn;
+    componentLabels?: Record<string, string>;
+    monacoTheme?: string;
+    renderFileIcon?: (filename: string, component: string) => ReactNode;
+}
+declare function FileDiffViewer({ sync, componentLabels, monacoTheme, renderFileIcon }: FileDiffViewerProps): react_jsx_runtime.JSX.Element;
+
+interface SnapshotManagerProps {
+    sync: UseGoldenSyncReturn;
+}
+declare function SnapshotManager({ sync }: SnapshotManagerProps): react_jsx_runtime.JSX.Element;
+
+interface VersionManagerProps {
+    sync: UseGoldenSyncReturn;
+    components: string[];
+    componentLabels?: Record<string, string>;
+}
+declare function VersionManager({ sync, components, componentLabels }: VersionManagerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * AI Tools Paths — Shared type definitions
+ *
+ * Part of: Sections > AI Tools Paths
+ *
+ * These types define the CONTRACT between the UI layer (this package) and
+ * the Rust/Tauri backend that each app must implement. Every type here has
+ * a 1:1 mapping to a Rust struct returned by Tauri commands.
+ *
+ * IMPORTANT FOR AI AGENTS:
+ * When adding a new field here, the corresponding Rust struct must also be
+ * updated (and vice versa). The serde rename attributes in Rust use camelCase
+ * to match these TypeScript interfaces.
+ *
+ * Generic design:
+ * - Tools are keyed by string ID (not hardcoded to specific tools)
+ * - Configr uses: "claude", "gemini", "copilot", "codex", "opencode"
+ * - Other apps can define their own tool sets
+ * - The UI renders whatever tools the consumer provides
+ */
+/** Per-tool configuration state */
+interface AiToolConfig {
+    /** Unique identifier for the tool (e.g. "claude", "gemini") */
+    id: string;
+    /** Display name (e.g. "Claude Code", "Gemini CLI") */
+    name: string;
+    /** Whether the tool is enabled for use */
+    enabled: boolean;
+    /** User-configured or auto-detected binary path */
+    binaryPath: string;
+    /** Whether the tool was found during detection */
+    detected: boolean;
+    /** Path found by auto-detection (may differ from binaryPath if user overrode it) */
+    detectedPath?: string;
+}
+/** Result of detecting a single tool's binary */
+interface ToolDetectionResult {
+    /** Whether the binary was found */
+    detected: boolean;
+    /** Resolved path to the binary, if found */
+    path?: string;
+}
+/**
+ * ToolsPathsApi — The callback interface that each app must implement.
+ *
+ * This is the bridge between the shared UI and the app-specific backend.
+ * Each function maps to a Tauri command (or any other backend).
+ *
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │ RUST BACKEND IMPLEMENTATION GUIDE                                   │
+ * │                                                                     │
+ * │ Each method below corresponds to a Tauri #[tauri::command].         │
+ * │ The Rust reference implementation lives in:                         │
+ * │   configr/main/src-tauri/src/commands/tools/                        │
+ * │     ├── mod.rs          — Types + helpers                           │
+ * │     └── detection.rs    — Binary detection logic                    │
+ * │                                                                     │
+ * │ REQUIRED Tauri commands for full functionality:                      │
+ * │                                                                     │
+ * │ DETECTION:                                                          │
+ * │   detect_all_tools() → Record<string, ToolDetectionResult>          │
+ * │     Scans PATH and known install locations for all tool binaries.    │
+ * │     Returns a map of tool ID → detection result.                    │
+ * │                                                                     │
+ * │   detect_tool(toolId) → ToolDetectionResult                         │
+ * │     Scans for a single tool binary. Used for per-tool refresh.      │
+ * │                                                                     │
+ * │ VALIDATION:                                                         │
+ * │   validate_binary_path(path) → bool                                 │
+ * │     Checks if a given path points to a valid executable.            │
+ * │     Typically: fs::metadata(path).is_ok() && is_executable(path)    │
+ * │                                                                     │
+ * │ DETECTION STRATEGY (Rust backend should implement):                 │
+ * │ 1. Check PATH environment variable (which <tool-binary>)            │
+ * │ 2. Check common install locations:                                  │
+ * │    - /usr/local/bin/<binary>                                        │
+ * │    - /opt/homebrew/bin/<binary>                                      │
+ * │    - ~/.local/bin/<binary>                                           │
+ * │    - ~/.cargo/bin/<binary> (for Rust-based tools)                    │
+ * │    - ~/.npm/bin/<binary> (for npm-based tools)                       │
+ * │ 3. Check tool-specific locations:                                   │
+ * │    - Claude: ~/.claude/bin/claude                                    │
+ * │    - Copilot: gh extension path                                     │
+ * │ 4. Return first valid path found, or detected: false                │
+ * └─────────────────────────────────────────────────────────────────────┘
+ */
+interface ToolsPathsApi {
+    /** Scan all tools and return detection results keyed by tool ID */
+    detectAll: () => Promise<Record<string, ToolDetectionResult>>;
+    /** Scan a single tool and return its detection result */
+    detectTool: (toolId: string) => Promise<ToolDetectionResult>;
+    /** Check if a given binary path is valid (exists and is executable) */
+    validatePath: (path: string) => Promise<boolean>;
+}
+
+interface ToolsPathsPanelProps {
+    /** API adapter for backend operations (detection, validation) */
+    api: ToolsPathsApi;
+    /** Current tool configurations */
+    tools: AiToolConfig[];
+    /** Called when a tool's config changes. Consumer updates their state. */
+    onToolConfigChange: (toolId: string, config: Partial<AiToolConfig>) => void;
+    /** Optional render function for tool icons. Receives tool ID, returns ReactNode. */
+    renderToolIcon?: (toolId: string) => ReactNode;
+    className?: string;
+}
+declare function ToolsPathsPanel({ api, tools, onToolConfigChange, renderToolIcon, className, }: ToolsPathsPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useToolsPaths — Tool detection and configuration state hook
+ *
+ * Part of: Sections > AI Tools Paths
+ *
+ * Manages tool detection state, per-tool refresh tracking, and path validation.
+ * Used internally by ToolsPathsPanel but can also be used standalone for
+ * custom UIs.
+ *
+ * AI agent notes:
+ * - This hook does NOT store tool configs — the consumer owns that state.
+ *   It only manages detection/scanning ephemeral state.
+ * - The hook tracks which tools have been scanned, which are currently
+ *   refreshing, and whether a full scan has completed.
+ * - Path validation is debounced by the consumer (typically on blur or
+ *   after typing stops).
+ */
+
+interface UseToolsPathsOptions {
+    api: ToolsPathsApi;
+    tools: AiToolConfig[];
+    onToolConfigChange: (toolId: string, config: Partial<AiToolConfig>) => void;
+}
+interface UseToolsPathsReturn {
+    /** Whether a full scan is in progress */
+    isDetecting: boolean;
+    /** Whether a full scan has completed at least once */
+    hasScanned: boolean;
+    /** Set of tool IDs currently being individually refreshed */
+    refreshingTools: Set<string>;
+    /** Set of tool IDs that were found during the last scan */
+    scannedTools: Set<string>;
+    /** Run detection for all tools */
+    detectAll: () => Promise<void>;
+    /** Run detection for a single tool */
+    detectTool: (toolId: string) => Promise<void>;
+    /** Validate and update a tool's binary path */
+    validateAndUpdatePath: (toolId: string, path: string) => Promise<void>;
+    /** Toggle a tool's enabled state */
+    toggleEnabled: (toolId: string) => void;
+}
+declare function useToolsPaths({ api, tools, onToolConfigChange }: UseToolsPathsOptions): UseToolsPathsReturn;
+
+/**
+ * Captured Issues — Shared type definitions
+ *
+ * Part of: Sections > Captured Issues
+ *
+ * These types define the CONTRACT between the UI layer (this package) and
+ * the backend that each app must implement. Each type maps to a backend
+ * data structure (Rust struct, API response, etc.).
+ *
+ * IMPORTANT FOR AI AGENTS:
+ * When adding a new field here, the corresponding backend type must also be
+ * updated. Rust backends use serde rename with camelCase to match these
+ * TypeScript interfaces.
+ */
+/** A captured error or warning entry from the error logger */
+interface CapturedError {
+    /** Unique hash identifying this error (djb2 of message + stack) */
+    fingerprint: string;
+    /** First occurrence message text */
+    message: string;
+    /** Number of times this error has been seen */
+    count: number;
+    /** Severity level */
+    level: 'error' | 'warning';
+    /** ISO-8601 timestamp of first occurrence */
+    firstSeen: string;
+    /** ISO-8601 timestamp of most recent occurrence */
+    lastSeen: string;
+}
+/** A previously reported error that was submitted with an issue */
+interface SubmittedError {
+    /** Unique hash identifying this error */
+    fingerprint: string;
+    /** Error message text */
+    message: string;
+    /** Number of new occurrences since submission */
+    count: number;
+    /** ISO-8601 timestamp of when this error was submitted */
+    submittedAt: string;
+}
+/**
+ * CapturedIssuesApi — The callback interface that each app must implement.
+ *
+ * This is the bridge between the shared UI and the app-specific backend.
+ * Each function maps to a backend command (Tauri command, API endpoint, etc.).
+ *
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │ RUST BACKEND IMPLEMENTATION GUIDE                                   │
+ * │                                                                     │
+ * │ Each method below corresponds to a Tauri #[tauri::command].         │
+ * │ The Rust reference implementation lives in:                         │
+ * │   configr/main/src-tauri/src/commands/support.rs                    │
+ * │                                                                     │
+ * │ REQUIRED Tauri commands:                                            │
+ * │                                                                     │
+ * │   get_system_info() → SystemInfo                                    │
+ * │     Returns { os, osVersion, appVersion, arch }                     │
+ * │     Used to include environment details in issue reports.           │
+ * │                                                                     │
+ * │   submit_issue(title, description, email, errors) → SubmitResult    │
+ * │     Sends the issue to your issue tracker (Linear, GitHub, etc.)    │
+ * │     Returns { success: bool, issue_id: Option<String> }             │
+ * │                                                                     │
+ * │   dismiss_errors() → ()                                             │
+ * │     Clears the current error log without submitting.                │
+ * │     Typically calls error_logger.clear_logs().                      │
+ * │                                                                     │
+ * │   get_submitted_errors() → Vec<SubmittedError>                      │
+ * │     Returns previously reported errors from local storage/DB.       │
+ * │     Used to show the "Previously Reported" section.                 │
+ * │                                                                     │
+ * │ Tauri adapter example:                                              │
+ * │                                                                     │
+ * │   import { invoke } from '@tauri-apps/api/core'                     │
+ * │   import type { CapturedIssuesApi } from '@toolr/ui-design'         │
+ * │                                                                     │
+ * │   const api: CapturedIssuesApi = {                                  │
+ * │     getSystemInfo: () => invoke('get_system_info'),                  │
+ * │     submitIssue: (data) => invoke('submit_issue', data),            │
+ * │     dismissErrors: () => invoke('dismiss_errors'),                  │
+ * │     getSubmittedErrors: () => invoke('get_submitted_errors'),       │
+ * │   }                                                                 │
+ * └─────────────────────────────────────────────────────────────────────┘
+ */
+interface CapturedIssuesApi {
+    /** Get system environment info to include in issue reports */
+    getSystemInfo: () => Promise<{
+        os: string;
+        osVersion: string;
+        appVersion: string;
+        arch: string;
+    }>;
+    /** Submit an issue with captured errors to the issue tracker */
+    submitIssue: (data: {
+        title: string;
+        description: string;
+        email: string;
+        errors: CapturedError[];
+    }) => Promise<{
+        success: boolean;
+        issueId?: string;
+    }>;
+    /** Dismiss/clear current errors without submitting */
+    dismissErrors: () => Promise<void>;
+    /** Get list of previously submitted errors */
+    getSubmittedErrors: () => Promise<SubmittedError[]>;
+}
+
+interface CapturedIssuesPanelProps {
+    /** Backend API implementation */
+    api: CapturedIssuesApi;
+    /** Current captured errors to display */
+    errors: CapturedError[];
+    /** Called after errors are dismissed */
+    onDismiss?: () => void;
+    /** Called after successful submission */
+    onSubmitSuccess?: (issueId?: string) => void;
+    className?: string;
+}
+declare function CapturedIssuesPanel({ api, errors, onDismiss, onSubmitSuccess, className, }: CapturedIssuesPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useCapturedIssues — State management hook for captured issues panel
+ *
+ * Part of: Sections > Captured Issues
+ *
+ * Manages form state (title, description, email), submission flow,
+ * dismiss functionality, and previously reported errors loading.
+ *
+ * AI agent notes:
+ * - This hook is used internally by CapturedIssuesPanel but can also
+ *   be used standalone for custom UIs
+ * - All backend calls go through the CapturedIssuesApi interface
+ * - The hook resets form fields on successful submission
+ * - Previously reported errors are loaded once on mount
+ */
+
+interface UseCapturedIssuesOptions {
+    api: CapturedIssuesApi;
+    errors: CapturedError[];
+    onDismiss?: () => void;
+    onSubmitSuccess?: (issueId?: string) => void;
+}
+interface UseCapturedIssuesReturn {
+    errorCount: number;
+    warnCount: number;
+    title: string;
+    setTitle: (title: string) => void;
+    description: string;
+    setDescription: (desc: string) => void;
+    email: string;
+    setEmail: (email: string) => void;
+    isSubmitting: boolean;
+    submitError: string | null;
+    submittedErrors: SubmittedError[];
+    handleSubmit: () => Promise<void>;
+    handleDismiss: () => Promise<void>;
+}
+declare function useCapturedIssues(options: UseCapturedIssuesOptions): UseCapturedIssuesReturn;
+
+/**
+ * Snapshot Browser — Shared type definitions
+ *
+ * Part of: Sections > Snapshot Browser
+ *
+ * These types define the CONTRACT between the UI layer (this package) and
+ * the Rust/Tauri backend that each app must implement. Every type here has
+ * a 1:1 mapping to a Rust struct returned by Tauri commands.
+ *
+ * IMPORTANT FOR AI AGENTS:
+ * When adding a new field here, the corresponding Rust struct must also be
+ * updated (and vice versa). The serde rename attributes in Rust use camelCase
+ * to match these TypeScript interfaces.
+ *
+ * Data hierarchy:
+ *   SnapshotScope → SnapshotCategory → SnapshotItem → SnapshotEntry
+ *
+ * Example:
+ *   Scope: "Settings (Prompts)"
+ *     Category: "Verifier Prompts"
+ *       Item: "system-prompt"
+ *         Entry: { content: "You are a...", savedAt: "2026-02-25T10:00:00Z" }
+ */
+/** A single snapshot — one saved version of content */
+interface SnapshotEntry {
+    id: string;
+    content: string;
+    savedAt: string;
+    label?: string;
+}
+/** An item containing snapshots (e.g. a specific prompt or file) */
+interface SnapshotItem {
+    id: string;
+    name: string;
+    snapshots: SnapshotEntry[];
+}
+/** A category containing items (e.g. "Verifier Prompts", "Skills") */
+interface SnapshotCategory {
+    id: string;
+    name: string;
+    icon?: string;
+    items: SnapshotItem[];
+}
+/** A top-level scope containing categories (e.g. "Settings", "Extensions") */
+interface SnapshotScope {
+    id: string;
+    name: string;
+    categories: SnapshotCategory[];
+}
+/**
+ * SnapshotBrowserApi — The callback interface that each app must implement.
+ *
+ * This is the bridge between the shared UI and the app-specific backend.
+ * Each function maps to a Tauri command (or any other backend).
+ *
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │ RUST BACKEND IMPLEMENTATION GUIDE                                   │
+ * │                                                                     │
+ * │ Each method below corresponds to a Tauri #[tauri::command].         │
+ * │ The Rust reference implementation lives in:                         │
+ * │   configr/main/src-tauri/src/commands/snapshots/                    │
+ * │                                                                     │
+ * │ REQUIRED Tauri commands:                                            │
+ * │                                                                     │
+ * │   delete_snapshot(scope, category, item, snapshot) → void           │
+ * │     Deletes a single snapshot entry by its composite key.           │
+ * │     The four IDs form a unique path to the snapshot.                │
+ * │                                                                     │
+ * │   clear_all_snapshots() → void                                      │
+ * │     Removes all snapshots across all scopes.                        │
+ * │     Should clear the backing store completely.                      │
+ * │                                                                     │
+ * │ STORAGE STRUCTURE (Rust backend must maintain):                     │
+ * │   Snapshots are stored as JSON in the app data directory:           │
+ * │   {app_data_dir}/                                                    │
+ * │   └── snapshots/                                                     │
+ * │       └── {scope}/                                                   │
+ * │           └── {category}/                                            │
+ * │               └── {item}.json  — SnapshotEntry[] serialized         │
+ * │                                                                     │
+ * │ KEY BEHAVIORS the Rust backend must implement:                      │
+ * │ 1. Pruning: when snapshot limit is reached, remove oldest entry     │
+ * │ 2. Atomic writes: use temp file + rename for crash safety           │
+ * │ 3. IDs should be stable (UUID or timestamp-based)                   │
+ * └─────────────────────────────────────────────────────────────────────┘
+ */
+interface SnapshotBrowserApi {
+    /** Delete a single snapshot by its composite key */
+    deleteSnapshot: (scopeId: string, categoryId: string, itemId: string, snapshotId: string) => Promise<void>;
+    /** Clear all snapshots across all scopes */
+    clearAllSnapshots: () => Promise<void>;
+}
+
+interface SnapshotBrowserPanelProps {
+    api: SnapshotBrowserApi;
+    scopes: SnapshotScope[];
+    snapshotLimit: number;
+    onSnapshotLimitChange: (limit: number) => void;
+    onClearAll?: () => void;
+    className?: string;
+}
+declare function SnapshotBrowserPanel({ api, scopes, snapshotLimit, onSnapshotLimitChange, onClearAll, className, }: SnapshotBrowserPanelProps): react_jsx_runtime.JSX.Element;
+
+interface SnapshotTreeProps {
+    scopes: SnapshotScope[];
+    searchQuery: string;
+    onSearchChange: (query: string) => void;
+    expandedPaths: Set<string>;
+    onToggleExpand: (path: string) => void;
+    onExpandAll: () => void;
+    onCollapseAll: () => void;
+    allExpanded: boolean;
+    allExpandablePaths: string[];
+    onDeleteSnapshot: (scopeId: string, categoryId: string, itemId: string, snapshotId: string) => void;
+    deletingSnapshotId: string | null;
+    className?: string;
+}
+declare function SnapshotTree({ scopes, searchQuery, onSearchChange, expandedPaths, onToggleExpand, onExpandAll, onCollapseAll, allExpanded, allExpandablePaths, onDeleteSnapshot, deletingSnapshotId, className, }: SnapshotTreeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useSnapshotBrowser — State management hook for the snapshot tree browser
+ *
+ * Part of: Sections > Snapshot Browser
+ *
+ * Manages:
+ * - Tree expansion state (expanded scopes, categories, items)
+ * - Search filter with auto-expand on search
+ * - Expand all / collapse all
+ * - Total snapshot count computation
+ * - Delete operations with loading state
+ */
+
+interface UseSnapshotBrowserOptions {
+    scopes: SnapshotScope[];
+    api: SnapshotBrowserApi;
+}
+interface UseSnapshotBrowserReturn {
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    expandedPaths: Set<string>;
+    toggleExpand: (path: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    allExpanded: boolean;
+    totalSnapshotCount: number;
+    allExpandablePaths: string[];
+    deleteSnapshot: (scopeId: string, categoryId: string, itemId: string, snapshotId: string) => Promise<void>;
+    deletingSnapshotId: string | null;
+}
+declare function useSnapshotBrowser({ scopes, api }: UseSnapshotBrowserOptions): UseSnapshotBrowserReturn;
+
+/**
+ * Snippets Editor — Shared type definitions
+ *
+ * Part of: Sections > Snippets Editor
+ *
+ * Snippets are reusable text blocks that can be referenced in prompts
+ * using the {{SNIPPET_NAME}} syntax. Each snippet has a name (uppercase
+ * with underscores), a description, and a value that gets substituted
+ * at render time.
+ *
+ * Example usage in a prompt:
+ *   "Follow the coding standards defined in {{CODE_STYLE}}"
+ *
+ * The consuming app is responsible for the actual template substitution.
+ * This UI only manages CRUD operations via the provided API.
+ */
+/** A single snippet definition */
+interface SnippetData {
+    /** Snippet name — must match SNIPPET_NAME_REGEX (e.g., PROJECT_CONTEXT) */
+    name: string;
+    /** Human-readable description of what this snippet contains */
+    description: string;
+    /** The actual snippet content that gets substituted for {{NAME}} */
+    value: string;
+}
+/**
+ * Validation regex for snippet names.
+ * Must start with an uppercase letter, followed by uppercase letters, digits, or underscores.
+ * Examples: MY_SNIPPET, CODE_STYLE, ERROR_HANDLING_V2
+ */
+declare const SNIPPET_NAME_REGEX: RegExp;
+/**
+ * SnippetsEditorApi — The callback interface that consuming apps must implement.
+ *
+ * Each method maps to a backend operation (Tauri command, API call, etc.).
+ * The UI calls these methods and awaits their completion before updating state.
+ */
+interface SnippetsEditorApi {
+    /** Add a new snippet. Rejects if a snippet with the same name already exists. */
+    addSnippet: (snippet: SnippetData) => Promise<void>;
+    /** Update an existing snippet. originalName is used to find the snippet to replace. */
+    updateSnippet: (originalName: string, snippet: SnippetData) => Promise<void>;
+    /** Remove a snippet by name. */
+    removeSnippet: (name: string) => Promise<void>;
+}
+
+interface SnippetsEditorProps {
+    api: SnippetsEditorApi;
+    snippets: SnippetData[];
+    /** Section title, e.g. "Skills Snippets" */
+    title?: string;
+    /** Section description, e.g. "Define snippets to reuse in skills prompts..." */
+    description?: string;
+    className?: string;
+}
+declare function SnippetsEditor({ api, snippets, title, description, className, }: SnippetsEditorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useSnippetsEditor — Form state and CRUD hook for the snippets editor
+ *
+ * Part of: Sections > Snippets Editor
+ *
+ * Manages selected snippet, form data, edit/add mode, validation, search,
+ * and CRUD operations via the provided API.
+ *
+ * AI agent notes:
+ * - This hook is used internally by SnippetsEditor but can also be used
+ *   standalone for custom UIs
+ * - Validation checks: required fields, SNIPPET_NAME_REGEX, duplicate names
+ * - The hook does NOT hold the snippets array — it receives it as a param
+ *   so the consuming app owns the source of truth
+ */
+
+interface SnippetFormData {
+    name: string;
+    description: string;
+    value: string;
+}
+interface UseSnippetsEditorOptions {
+    api: SnippetsEditorApi;
+    snippets: SnippetData[];
+}
+interface UseSnippetsEditorReturn {
+    selectedName: string | null;
+    selectSnippet: (name: string | null) => void;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    filteredSnippets: SnippetData[];
+    formData: SnippetFormData;
+    setFormField: (field: keyof SnippetFormData, value: string) => void;
+    formError: string | null;
+    isEditing: boolean;
+    isAdding: boolean;
+    startAdd: () => void;
+    startEdit: (snippet: SnippetData) => void;
+    cancelForm: () => void;
+    save: () => Promise<void>;
+    remove: (name: string) => Promise<void>;
+    resetForm: () => void;
+    isSaving: boolean;
+}
+declare function useSnippetsEditor({ api, snippets }: UseSnippetsEditorOptions): UseSnippetsEditorReturn;
+
+/**
+ * Prompt Editor — Shared type definitions
+ *
+ * Part of: Sections > Prompt Editor
+ *
+ * These types define the shape of prompt data and the API contract
+ * between the UI layer and whatever backend stores prompts.
+ */
+
+/** A tool tab shown in the editor (e.g. Claude, Gemini, Copilot) */
+interface ToolTab {
+    id: string;
+    name: string;
+    icon?: ReactNode;
+    /** Short name for narrow layouts */
+    shortName?: string;
+    /** Tailwind text color class for the active state (e.g. "text-orange-400") */
+    activeColor?: string;
+}
+/** A template variable available for insertion into prompts */
+interface PromptPlaceholder {
+    name: string;
+    description: string;
+    example?: string;
+    required?: boolean;
+    /** Label for the value display (default: "Value:") */
+    valueLabel?: string;
+}
+/** A saved snapshot of a prompt for version history */
+interface PromptSnapshot {
+    content: string;
+    savedAt: string;
+}
+/**
+ * PromptEditorApi — optional callback interface for persistence.
+ *
+ * When provided, the editor can save, reset, and manage snapshots.
+ * When omitted, the editor works in "controlled" mode where the
+ * parent manages all state via props.
+ */
+interface PromptEditorApi {
+    /** Save the current prompt */
+    savePrompt: (prompt: string) => Promise<void>;
+    /** Get the default/reset value */
+    getDefaultPrompt?: () => Promise<string>;
+    /** Save a snapshot */
+    saveSnapshot?: (content: string) => Promise<void>;
+    /** Get saved snapshots */
+    getSnapshots?: () => Promise<PromptSnapshot[]>;
+    /** Delete a snapshot by timestamp */
+    deleteSnapshot?: (savedAt: string) => Promise<void>;
+}
+/** A file type option in the sidebar selector */
+interface FileTypeOption {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: ReactNode;
+}
+/** A scenario with child steps for the tree sidebar */
+interface ScenarioOption {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: ReactNode;
+    steps: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+
+/**
+ * usePromptEditor — Hook managing prompt editor state
+ *
+ * Part of: Sections > Prompt Editor
+ *
+ * Handles:
+ * - Local content state (separate from saved content for dirty detection)
+ * - Dirty state detection
+ * - Save with Ctrl/Cmd+S keyboard shortcut
+ * - Variable search/filter
+ * - Active tab state
+ */
+
+interface UsePromptEditorOptions {
+    /** Prompt content keyed by tool id */
+    prompts: Record<string, string>;
+    /** Called when saving (all modified prompts at once) */
+    onPromptChange: (tool: string, value: string) => void;
+    /** Available tool tabs */
+    tools: ToolTab[];
+    /** Available template variables */
+    variables?: PromptPlaceholder[];
+}
+interface UsePromptEditorReturn {
+    /** Currently active tool tab id */
+    activeTab: string;
+    setActiveTab: (tab: string) => void;
+    /** Local editor content (may differ from saved prompts) */
+    localContent: Record<string, string>;
+    /** Current prompt for the active tab */
+    currentPrompt: string;
+    /** Whether any tab has unsaved changes */
+    isDirty: boolean;
+    /** Handle editor content change */
+    handleEditorChange: (value: string | undefined) => void;
+    /** Save all modified prompts */
+    handleSave: () => void;
+    /** Variable search state */
+    variableSearch: string;
+    setVariableSearch: (search: string) => void;
+    /** Filtered variables based on search */
+    filteredVariables: PromptPlaceholder[];
+}
+declare function usePromptEditor({ prompts, onPromptChange, tools, variables, }: UsePromptEditorOptions): UsePromptEditorReturn;
+
+interface TabbedPromptEditorProps {
+    /** Prompt content keyed by tool id */
+    prompts: Record<string, string>;
+    /** Called when a prompt is saved */
+    onPromptChange: (tool: string, value: string) => void;
+    /** Tool tabs to display */
+    tools: ToolTab[];
+    /** Default/reset prompts keyed by tool id */
+    defaultPrompts?: Record<string, string>;
+    /** Available template variables */
+    variables?: PromptPlaceholder[];
+    /** Called when reset is triggered */
+    onReset?: (tool: string) => void;
+    /** Called when save is triggered */
+    onSave?: (tool: string, content: string) => void;
+    /** When true, validates that prompt contains "## Verification Checklist" */
+    validateChecklist?: boolean;
+    /** When true, adds border and rounding for standalone usage */
+    standalone?: boolean;
+    className?: string;
+}
+declare function TabbedPromptEditor({ prompts, onPromptChange, tools, defaultPrompts, variables, onReset, onSave, validateChecklist, standalone, className, }: TabbedPromptEditorProps): react_jsx_runtime.JSX.Element;
+
+interface FileTypeTabbedPromptEditorProps {
+    /** Nested prompts: fileType -> tool -> prompt */
+    prompts: Record<string, Record<string, string>>;
+    /** Called when a prompt changes */
+    onPromptChange: (fileType: string, tool: string, value: string) => void;
+    /** Available file types for the sidebar */
+    fileTypes: FileTypeOption[];
+    /** Tool tabs to display */
+    tools: ToolTab[];
+    /** Default prompts for reset: fileType -> tool -> prompt */
+    defaultPrompts?: Record<string, Record<string, string>>;
+    /** Variables per file type */
+    variables?: Record<string, PromptPlaceholder[]>;
+    /** Called when reset is triggered */
+    onReset?: (fileType: string, tool: string) => void;
+    /** Called when save is triggered */
+    onSave?: (fileType: string, tool: string, content: string) => void;
+    /** Custom label for sidebar header (default: "Target") */
+    selectorLabel?: string;
+    /** Custom sublabel for sidebar header (default: "Select target file type") */
+    selectorSublabel?: string;
+    /** When true, validates "## Verification Checklist" section */
+    validateChecklist?: boolean;
+    className?: string;
+}
+declare function FileTypeTabbedPromptEditor({ prompts, onPromptChange, fileTypes, tools, defaultPrompts, variables, onReset, onSave, selectorLabel, selectorSublabel, validateChecklist, className, }: FileTypeTabbedPromptEditorProps): react_jsx_runtime.JSX.Element;
+
+interface SimulatorPromptEditorProps {
+    /** Nested prompts: scenario -> step -> tool -> prompt */
+    prompts: Record<string, Record<string, Record<string, string>>>;
+    /** Called when a prompt changes */
+    onPromptChange: (scenario: string, step: string, tool: string, value: string) => void;
+    /** Available scenarios with their steps */
+    scenarios: ScenarioOption[];
+    /** Tool tabs to display */
+    tools: ToolTab[];
+    /** Default prompts for reset: scenario -> step -> tool -> prompt */
+    defaultPrompts?: Record<string, Record<string, Record<string, string>>>;
+    /** Variables per scenario/step (key format: "scenario:step") */
+    variables?: Record<string, PromptPlaceholder[]>;
+    /** Called when reset is triggered */
+    onReset?: (scenario: string, step: string, tool: string) => void;
+    /** Called when save is triggered */
+    onSave?: (scenario: string, step: string, tool: string, content: string) => void;
+    /** When true, validates "## Verification Checklist" section */
+    validateChecklist?: boolean;
+    className?: string;
+}
+declare function SimulatorPromptEditor({ prompts, onPromptChange, scenarios, tools, defaultPrompts, variables, onReset, onSave, validateChecklist, className, }: SimulatorPromptEditorProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleSectionProps {
+    title: string;
+    icon?: IconName;
+    iconColor?: string;
+    defaultOpen?: boolean;
+    badge?: string | number;
+    badgeColor?: BadgeColor;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function CollapsibleSection({ title, icon, iconColor, defaultOpen, badge, badgeColor, children, className, }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
+
+interface FileEntry {
+    path: string;
+    name: string;
+    type: 'file' | 'folder';
+    icon?: IconName;
+    color?: string;
+    badge?: string;
+    children?: FileEntry[];
+}
+interface FilesPanelProps {
+    files: FileEntry[];
+    selectedPath?: string;
+    onSelect?: (path: string) => void;
+    onAction?: (action: string, path: string) => void;
+    showSearch?: boolean;
+    className?: string;
+}
+declare function FilesPanel({ files, selectedPath, onSelect, onAction, showSearch, className, }: FilesPanelProps): react_jsx_runtime.JSX.Element;
+
+/** Searchable panel for browsing, copying, and inserting code snippets. */
+interface Snippet {
+    id: string;
+    label: string;
+    language?: string;
+    description?: string;
+    code: string;
+    tags?: string[];
+}
+interface SnippetsPanelProps {
+    snippets: Snippet[];
+    onInsert?: (id: string) => void;
+    onCopy?: (id: string) => void;
+    showSearch?: boolean;
+    className?: string;
+}
+declare function SnippetsPanel({ snippets, onInsert, onCopy, showSearch, className, }: SnippetsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbSegment {
+    id: string;
+    label: string;
+    icon?: IconName;
+    color?: string;
+    onClick?: () => void;
+}
+interface BreadcrumbProps {
+    segments: BreadcrumbSegment[];
+    separator?: 'chevron' | 'slash' | 'dot';
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare function Breadcrumb({ segments, separator, size, className, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+interface NavigationBarProps {
+    segments: BreadcrumbSegment[];
+    canGoBack?: boolean;
+    canGoForward?: boolean;
+    onBack?: () => void;
+    onForward?: () => void;
+    showHistory?: boolean;
+    historyEntries?: BreadcrumbSegment[][];
+    onHistorySelect?: (index: number) => void;
+    leadingAction?: {
+        icon: IconName;
+        onClick?: () => void;
+    };
+    separator?: 'chevron' | 'slash' | 'dot';
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare function NavigationBar({ segments, canGoBack, canGoForward, onBack, onForward, showHistory, historyEntries, onHistorySelect, leadingAction, separator, size, className, }: NavigationBarProps): react_jsx_runtime.JSX.Element;
+
+interface Tab {
+    id: string;
+    label: string;
+    icon?: IconName;
+    color?: string;
+    closable?: boolean;
+    badge?: number | string;
+    badgeColor?: BadgeColor;
+}
+interface TabBarProps {
+    tabs: Tab[];
+    activeId: string;
+    onSelect: (id: string) => void;
+    onClose?: (id: string) => void;
+    variant?: 'underline' | 'pill' | 'card';
+    size?: 'xss' | 'xs' | 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare function TabBar({ tabs, activeId, onSelect, onClose, variant, size, className, }: TabBarProps): react_jsx_runtime.JSX.Element;
+
+interface LayoutTab {
+    id: string;
+    title: string;
+    subtitle?: string;
+    subtitleIcon?: ReactNode;
+    icon?: ReactNode;
+    color?: string;
+    selectedColor?: string;
+    titleColor?: string;
+    iconColor?: string;
+    subtitleColor?: string;
+    subtitleIconColor?: string;
+    closable?: boolean;
+}
+interface LayoutTabBarProps {
+    tabs: LayoutTab[];
+    activeId: string | null;
+    onSelect: (id: string) => void;
+    onClose?: (id: string) => void;
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    className?: string;
+}
+declare function LayoutTabBar({ tabs, activeId, onSelect, onClose, onReorder, className }: LayoutTabBarProps): react_jsx_runtime.JSX.Element;
+
+interface NavCardProps {
+    title: string;
+    description?: string;
+    icon?: IconName;
+    iconColor?: string;
+    badge?: number | string;
+    badgeColor?: BadgeColor;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare function NavCard({ title, description, icon, iconColor, badge, badgeColor, onClick, disabled, className, }: NavCardProps): react_jsx_runtime.JSX.Element;
+
+interface ExtensionListCardProps {
+    /** Lucide icon component */
+    icon: ElementType;
+    /** Tailwind color class for icon (e.g. 'text-teal-400') */
+    iconColor: string;
+    /** Tailwind color class for left border (e.g. 'border-l-teal-400') */
+    borderColor: string;
+    /** Card title */
+    title: string;
+    /** Custom title class (defaults to 'text-white') */
+    titleClassName?: string;
+    /** Badges rendered after the title */
+    badges?: ReactNode;
+    /** Description text or node (can be string or ReactNode for custom formatting) */
+    description?: ReactNode;
+    /** Action buttons (shown on hover) */
+    actions?: ReactNode;
+    /** Metadata row at bottom. Can be a render function receiving hover state. */
+    metadata?: ReactNode | ((isHovered: boolean) => ReactNode);
+    /** Whether card is inactive/dimmed */
+    isInactive?: boolean;
+    /** Test ID for E2E testing */
+    testId?: string;
+}
+declare const ExtensionListCard: react.NamedExoticComponent<ExtensionListCardProps>;
+
+type StatusType = 'success' | 'warning' | 'error' | 'info' | 'neutral';
+interface StatusItem {
+    label: string;
+    value: string | number;
+    status: StatusType;
+}
+interface StatusCardProps {
+    title: string;
+    icon?: IconName;
+    iconColor?: string;
+    items: StatusItem[];
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    className?: string;
+}
+declare function StatusCard({ title, icon, iconColor, items, action, className, }: StatusCardProps): react_jsx_runtime.JSX.Element;
+
+/** Snapshot card with status stripe, stats grid, and sync/view actions. */
+type SnapshotStatus = 'synced' | 'pending' | 'conflict' | 'outdated';
+interface SnapshotCardProps {
+    title: string;
+    timestamp?: string;
+    status: SnapshotStatus;
+    description?: string;
+    stats?: {
+        label: string;
+        value: string | number;
+    }[];
+    onSync?: () => void;
+    onView?: () => void;
+    className?: string;
+}
+declare function SnapshotCard({ title, timestamp, status, description, stats, onSync, onView, className, }: SnapshotCardProps): react_jsx_runtime.JSX.Element;
+
+interface DetailRow {
+    label: string;
+    value: string;
+    mono?: boolean;
+}
+interface DetailSectionProps {
+    /** Section title (e.g., "Execution Details") */
+    title: string;
+    /** Icon before the title */
+    icon?: IconName;
+    /** Detail rows to display */
+    rows: DetailRow[];
+    className?: string;
+}
+declare function DetailSection({ title, icon, rows, className }: DetailSectionProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Close a menu/dropdown when clicking outside its ref element.
+ * If ref is null, closes on any mousedown event.
+ */
+declare function useClickOutside(ref: RefObject<HTMLElement | null> | null, isOpen: boolean, onClose: () => void): void;
+
+/**
+ * Constrains a dropdown menu's height to fit within the viewport.
+ * Sets max-height = viewport bottom - element top - margin, and enables vertical scrolling.
+ */
+declare function useDropdownMaxHeight<T extends HTMLElement>(isOpen: boolean, margin?: number): react.RefObject<T | null>;
+
+/** Hook for managing back/forward navigation history with a breadcrumb segment stack. */
+
+interface UseNavigationHistoryReturn {
+    current: BreadcrumbSegment[] | null;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    push: (segments: BreadcrumbSegment[]) => void;
+    goBack: () => void;
+    goForward: () => void;
+    goTo: (index: number) => void;
+    history: BreadcrumbSegment[][];
+}
+declare function useNavigationHistory(initial?: BreadcrumbSegment[], maxEntries?: number): UseNavigationHistoryReturn;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { ACCENT_DEFS, AI_TOOL_LOGOS, AI_TOOL_NAMES, type AccentColor, type AccentDef, ActionDialog, type ActionDialogProps, type ActionItem, AiActionButton, type AiActionButtonProps, type AiActionStatus, type AiCompletionResult, AiExecutionActionButtons, type AiExecutionActionButtonsProps, type AiToolConfig, AiToolIcon, type AiToolKey, AlertModal, type AlertModalProps, BASE_THEMES, Badge, type BadgeColor, type BadgeProps, BottomPanelHeader, type BottomPanelHeaderProps, Breadcrumb, type BreadcrumbProps, type BreadcrumbSegment, type CapturedError, type CapturedIssuesApi, CapturedIssuesPanel, type CapturedIssuesPanelProps, type ChangedComponents, Checkbox, type CheckboxColor, type CheckboxProps, type CheckboxSize, type CheckboxVariant, type CodingToolId, type CodingToolPresetConfig, CollapseButton, type CollapseButtonProps, CollapsibleSection, type CollapsibleSectionProps, type ComponentVersion, ConfirmBadge, type ConfirmBadgeColor, type ConfirmBadgeProps, ConfirmModal, type ConfirmModalProps, type CreateSnapshotResult, DARK_THEMES, type DetailRow, DetailSection, type DetailSectionProps, DetailViewWrapper, type DetailViewWrapperProps, type DiffSummary, type DiffTreeNode, type DirectoryStatus, EditorPlaceholderCard, type EditorPlaceholderCardProps, EditorToolbar, type EditorToolbarProps, type ErrorLogger, type ExecutionDetailRow, ExecutionDetailsPanel, type ExecutionDetailsPanelProps, type ExecutionStatus, ExtensionListCard, type ExtensionListCardProps, type ExtensionSource, type FileDiffInfo, type FileDiffStatus, FileDiffViewer, type FileDiffViewerProps, type FileEntry, FileStructureSection, type FileStructureSectionProps, FileTree, type FileTreeNode, type FileTreeProps, type FileTypeOption, FileTypeTabbedPromptEditor, type FileTypeTabbedPromptEditorProps, FilesPanel, type FilesPanelProps, FilterDropdown, type FilterDropdownProps, FormActions, type FormActionsProps, type FormColor, FrontmatterFormHeader, type FrontmatterFormHeaderProps, type GoldenLiveDiff, type GoldenMeta, type GoldenSnapshotsApi, type GoldenStatus, GoldenSyncPanel, type GoldenSyncPanelProps, ISSUE_TYPES, IconButton, type IconButtonColor, type IconButtonProps, type IconButtonStatus, type IconButtonVariant, type IconName, Input, type InputProps, type IssueReport, type IssueReportResult, type IssueType, LIGHT_THEMES, Label, type LabelColor, type LabelProps, type LayoutTab, LayoutTabBar, type LayoutTabBarProps, type ModalKind, type ModalSize, NavCard, type NavCardProps, NavigationBar, type NavigationBarProps, NumberInput, type NumberInputProps, type PanelTab, type PreviewMode, type PromptEditorApi, type PromptPlaceholder, type PromptSnapshot, RegistryBrowser, type RegistryBrowserProps, RegistryCard, type RegistryCardProps, RegistryDetail, type RegistryDetailProps, type RegistryItemType, ReportBugForm, type ReportBugFormProps, type ResetResult, ResizableTextarea, type ResizableTextareaProps, SCALE_KEYS, SNIPPET_NAME_REGEX, type ScaleKey, type ScenarioOption, ScopeBadge, type ScopeType, type Screenshot, type ScreenshotAttachment, ScreenshotUploader, type ScreenshotUploaderProps, type SeedInfo, type SeedrItemStatus, SegmentedToggle, type SegmentedToggleOption, type SegmentedToggleProps, Select, type SelectOption, type SelectProps, type SelectionCardItem, SelectionGrid, type SelectionGridProps, SettingRow, type SettingRowProps, SimulatorPromptEditor, type SimulatorPromptEditorProps, type SnapshotBrowserApi, SnapshotBrowserPanel, type SnapshotBrowserPanelProps, SnapshotCard, type SnapshotCardProps, type SnapshotCategory, type SnapshotEntry, type SnapshotInfo, type SnapshotItem, SnapshotManager, type SnapshotManagerProps, type SnapshotScope, SnapshotTree, type SnapshotTreeProps, type SnapshotsManifest, type Snippet, type SnippetData, SnippetsEditor, type SnippetsEditorApi, type SnippetsEditorProps, SnippetsPanel, type SnippetsPanelProps, SortDropdown, type SortDropdownProps, type SortField, type StatusBanner, StatusCard, type StatusCardProps, type StatusItem, StatusOverview, type StatusOverviewProps, type SubmittedError, type SystemInfo, TOOLR_APPS, type Tab, TabBar, type TabBarProps, TabbedPromptEditor, type TabbedPromptEditorProps, type ThemeId, Toggle, type ToggleColor, type ToggleProps, type ToggleSize, type ToggleVariant, type ToolDetectionResult, type ToolTab, type ToolrAppId, ToolrAppLogo, type ToolsPathsApi, ToolsPathsPanel, type ToolsPathsPanelProps, Tooltip, type TooltipAlign, TooltipButton, type TooltipContent, type TooltipPosition, type TrackedError, type UseCapturedIssuesOptions, type UseCapturedIssuesReturn, type UseGoldenSyncOptions, type UseGoldenSyncReturn, type UseNavigationHistoryReturn, type UsePromptEditorOptions, type UsePromptEditorReturn, type UseReportBugOptions, type UseReportBugReturn, type UseSnapshotBrowserOptions, type UseSnapshotBrowserReturn, type UseSnippetsEditorOptions, type UseSnippetsEditorReturn, type UseToolsPathsOptions, type UseToolsPathsReturn, VersionManager, type VersionManagerProps, applyTheme, cn, collectDirPaths, createErrorLogger, formatBytes, formatCategory, formatDate, generateScale, getLanguage, getLanguageFromPath, hslToHex, iconMap, isLightTheme, satCurve, submitIssueReport, useCapturedIssues, useClickOutside, useDropdownMaxHeight, useGoldenSync, useNavigationHistory, usePromptEditor, useReportBug, useSnapshotBrowser, useSnippetsEditor, useToolsPaths };