@sdvf23rvfa43f/stealth-glass 1.3.0

package/dist/components/index.d.ts

@@ -0,0 +1,2032 @@
+import * as React$1 from 'react';
+import React__default, { HTMLAttributes, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { LucideIcon } from 'lucide-react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { ToasterProps } from 'sonner';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { Drawer as Drawer$1 } from 'vaul';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import { TooltipProps } from 'recharts';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+
+type GlowColor = 'blue' | 'indigo' | 'purple' | 'success' | 'warning' | 'danger' | 'none';
+type TileVariant = 'default' | 'elevated' | 'inner';
+type TilePadding = 'none' | 'sm' | 'md' | 'lg';
+interface GlassTileProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /** Surface depth variant */
+    variant?: TileVariant;
+    /** Padding size */
+    padding?: TilePadding;
+    /** Enable hover state */
+    hover?: boolean;
+    /** Ambient glow color (positioned top-right) */
+    glow?: GlowColor;
+    /** Additional className */
+    className?: string;
+}
+declare const GlassTile: React$1.ForwardRefExoticComponent<GlassTileProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface HudLabelProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+    /** Brightness level */
+    brightness?: 'muted' | 'secondary' | 'primary';
+}
+declare function HudLabel({ children, brightness, className, ...rest }: HudLabelProps): react_jsx_runtime.JSX.Element;
+interface DataValueProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+    /** Text size (Tailwind text-* without the "text-" prefix) */
+    size?: 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+    /** Color override */
+    color?: 'primary' | 'secondary' | 'muted' | 'success' | 'warning' | 'danger';
+}
+declare function DataValue({ children, size, color, className, ...rest }: DataValueProps): react_jsx_runtime.JSX.Element;
+declare function SectionDot({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+type StatusType = 'online' | 'offline' | 'warning' | 'processing' | 'neutral';
+type DotSize = 'sm' | 'md' | 'lg';
+interface StatusDotProps {
+    status: StatusType;
+    size?: DotSize;
+    /** Show pulse animation */
+    pulse?: boolean;
+    className?: string;
+}
+declare function StatusDot({ status, size, pulse, className }: StatusDotProps): react_jsx_runtime.JSX.Element;
+type BadgeStatus = 'active' | 'inactive' | 'warning' | 'error' | 'processing' | 'neutral' | 'new';
+interface StatusBadgeProps {
+    status: BadgeStatus;
+    children: ReactNode;
+    className?: string;
+}
+declare function StatusBadge({ status, children, className }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+declare function StatusIndicator({ status, label }: {
+    status: string;
+    label: string;
+}): react_jsx_runtime.JSX.Element;
+
+type GlowPreset = 'blue' | 'indigo' | 'purple' | 'emerald' | 'amber';
+interface AmbientBackgroundProps {
+    /** Which glow colors to render. Default: ['blue', 'indigo'] */
+    colors?: [GlowPreset, GlowPreset];
+    /** Intensity (opacity multiplier). Default: 10 (maps to /10) */
+    intensity?: 5 | 10 | 15 | 20;
+}
+declare function AmbientBackground({ colors, intensity }: AmbientBackgroundProps): react_jsx_runtime.JSX.Element;
+
+interface RevealGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+declare function RevealGroup({ children, className, ...rest }: RevealGroupProps): react_jsx_runtime.JSX.Element;
+interface RevealActionProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /** Animation direction */
+    from?: 'right' | 'bottom' | 'left' | 'fade';
+}
+declare function RevealAction({ children, from, className, ...rest }: RevealActionProps): react_jsx_runtime.JSX.Element;
+
+interface BentoGridProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /** Number of columns at desktop (mobile is always 1). Default: 3 */
+    cols?: 1 | 2 | 3 | 4;
+    /** Max container width. Default: 1600px */
+    maxWidth?: string;
+}
+declare function BentoGrid({ children, cols, maxWidth, className, ...rest }: BentoGridProps): react_jsx_runtime.JSX.Element;
+interface BentoCellProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /** How many columns this cell spans at desktop. Default: 1 */
+    span?: 1 | 2 | 3 | 4;
+    /** How many rows this cell spans. Default: 1 */
+    rowSpan?: 1 | 2 | 3;
+}
+declare function BentoCell({ children, span, rowSpan, className, ...rest }: BentoCellProps): react_jsx_runtime.JSX.Element;
+interface BentoCardProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /** Columns to span */
+    colSpan?: 1 | 2 | 3 | 4;
+    /** Rows to span */
+    rowSpan?: 1 | 2 | 3;
+    /** Optional title */
+    title?: string;
+    /** Optional icon component */
+    icon?: React.ElementType;
+    /** Content padding */
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+}
+declare function BentoCard({ children, colSpan, rowSpan, title, icon: Icon, padding, className, ...rest }: BentoCardProps): react_jsx_runtime.JSX.Element;
+
+interface PageShellProps {
+    children: ReactNode;
+    /** Page title (optional — for header area) */
+    title?: string;
+    /** Page subtitle */
+    subtitle?: string;
+    /** Right-aligned actions rendered next to the title */
+    actions?: ReactNode;
+    /** Additional className for the content area */
+    className?: string;
+}
+declare function PageShell({ children, title, subtitle, actions, className }: PageShellProps): react_jsx_runtime.JSX.Element;
+interface AnimatedSectionProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function AnimatedSection({ children, className }: AnimatedSectionProps): react_jsx_runtime.JSX.Element;
+
+interface SidebarNavItem {
+    /** Unique identifier for this nav item */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Lucide icon component */
+    icon: LucideIcon;
+    /** Optional badge text (count, "NEW", "SOON", etc.) */
+    badge?: string | null;
+    /** Disable this item */
+    disabled?: boolean;
+}
+interface SidebarNavSection {
+    /** Section heading */
+    category: string;
+    /** Navigation items in this section */
+    items: SidebarNavItem[];
+}
+interface SidebarSubmenuConfig {
+    /** Parent item ID that triggers the submenu */
+    parentId: string;
+    /** Parent display label */
+    parentLabel: string;
+    /** Parent icon */
+    parentIcon: LucideIcon;
+    /** Submenu items — matched by id prefix (e.g. "settings-password") */
+    items: SidebarNavItem[];
+}
+interface SidebarLogo {
+    /** Logo image URL */
+    src: string;
+    /** Alt text */
+    alt?: string;
+    /** Brand name text shown next to logo */
+    title?: string;
+}
+interface SidebarWallet {
+    /** Current balance */
+    balance: number;
+    /** Currency symbol (default: '€') */
+    currency?: string;
+    /** Add funds callback */
+    onAddFunds?: () => void;
+    /** Show loading skeleton */
+    isLoading?: boolean;
+}
+interface SidebarUser {
+    /** Display name */
+    name: string;
+    /** Email address */
+    email?: string;
+    /** Loading state */
+    isLoading?: boolean;
+}
+interface SidebarCTAButton {
+    /** Button label */
+    label: string;
+    /** Lucide icon */
+    icon: LucideIcon;
+    /** Click handler */
+    onClick: () => void;
+}
+interface StealthSidebarProps {
+    /** Logo and brand config */
+    logo: SidebarLogo;
+    /** Navigation sections */
+    navigation: SidebarNavSection[];
+    /** Currently active item ID */
+    currentId: string;
+    /** Navigate to an item */
+    onNavigate: (id: string) => void;
+    /** Sign out callback */
+    onSignOut: () => void;
+    /** Is user authenticated */
+    isAuthenticated?: boolean;
+    /** User info for profile footer */
+    user?: SidebarUser;
+    /** Wallet widget config */
+    wallet?: SidebarWallet;
+    /** Primary CTA button (mobile) */
+    ctaButton?: SidebarCTAButton;
+    /** Unauthenticated CTA fallback */
+    ctaButtonUnauth?: SidebarCTAButton;
+    /** Optional submenu (e.g. Settings) */
+    submenu?: SidebarSubmenuConfig;
+    /** Collapsed state (controlled) */
+    isCollapsed?: boolean;
+    /** Toggle collapse callback */
+    onToggleCollapse?: () => void;
+    /** Extra content below nav (slot) */
+    footerSlot?: ReactNode;
+}
+declare function StealthSidebar({ logo, navigation, currentId, onNavigate, onSignOut, isAuthenticated, user, wallet, ctaButton, ctaButtonUnauth, submenu, isCollapsed, onToggleCollapse, footerSlot, }: StealthSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface HeaderCTAButton {
+    /** Button label */
+    label: string;
+    /** Lucide icon */
+    icon: LucideIcon;
+    /** Click handler */
+    onClick: () => void;
+}
+interface HeaderWallet {
+    /** Current balance */
+    balance: number;
+    /** Currency symbol (default: '€') */
+    currency?: string;
+    /** Add funds callback */
+    onAddFunds?: () => void;
+    /** Loading state */
+    isLoading?: boolean;
+}
+interface HeaderUser {
+    /** Display name */
+    name: string;
+    /** Loading state */
+    isLoading?: boolean;
+}
+interface StealthHeaderProps {
+    /** Primary CTA button */
+    ctaButton?: HeaderCTAButton;
+    /** Unauthenticated CTA fallback */
+    ctaButtonUnauth?: HeaderCTAButton;
+    /** Wallet widget */
+    wallet?: HeaderWallet;
+    /** User profile info */
+    user?: HeaderUser;
+    /** Sign out callback */
+    onSignOut: () => void;
+    /** Whether user is authenticated */
+    isAuthenticated?: boolean;
+    /** Whether sidebar is collapsed (adjusts left offset) */
+    isSidebarCollapsed?: boolean;
+    /** Custom left slot (e.g. breadcrumbs) */
+    leftSlot?: ReactNode;
+    /** Custom right slot (extra actions before user) */
+    rightSlot?: ReactNode;
+}
+declare function StealthHeader({ ctaButton, ctaButtonUnauth, wallet, user, onSignOut, isAuthenticated, isSidebarCollapsed, leftSlot, rightSlot, }: StealthHeaderProps): react_jsx_runtime.JSX.Element;
+
+type AmbientColor = 'blue' | 'indigo' | 'purple' | 'emerald' | 'amber';
+interface AppShellProps extends Omit<StealthSidebarProps, 'isCollapsed' | 'onToggleCollapse'> {
+    /** Page content */
+    children: ReactNode;
+    /** Ambient background glow colors. Set to null to disable. Default: ['blue', 'indigo'] */
+    ambientColors?: [AmbientColor, AmbientColor] | null;
+    /** Ambient intensity */
+    ambientIntensity?: 5 | 10 | 15 | 20;
+    /** Header left slot (e.g. breadcrumbs) */
+    headerLeftSlot?: ReactNode;
+    /** Header right slot (extra actions) */
+    headerRightSlot?: ReactNode;
+    /** Loading skeleton for content area */
+    loadingFallback?: ReactNode;
+    /** Whether to show loading skeleton */
+    isLoading?: boolean;
+    /** Max content width (default: 1600px) */
+    contentMaxWidth?: string;
+}
+declare function AuthLoadingSkeleton(): react_jsx_runtime.JSX.Element;
+declare function AppShell({ children, logo, navigation, currentId, onNavigate, onSignOut, isAuthenticated, user, wallet, ctaButton, ctaButtonUnauth, submenu, footerSlot, ambientColors, ambientIntensity, headerLeftSlot, headerRightSlot, loadingFallback, isLoading, contentMaxWidth, }: AppShellProps): react_jsx_runtime.JSX.Element;
+declare namespace AppShell {
+    var AuthSkeleton: typeof AuthLoadingSkeleton;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "success" | "secondary" | "primary" | "outline" | "ghost" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    loading?: boolean;
+    leftIcon?: LucideIcon;
+    rightIcon?: LucideIcon;
+    asChild?: boolean;
+}
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const badgeVariants: {
+    default: string;
+    brand: string;
+    success: string;
+    warning: string;
+    danger: string;
+    outline: string;
+};
+interface BadgeProps {
+    variant?: keyof typeof badgeVariants;
+    size?: 'sm' | 'md';
+    dot?: boolean;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function Badge({ variant, size, dot, children, className, }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+interface DividerProps {
+    orientation?: 'horizontal' | 'vertical';
+    label?: string;
+    className?: string;
+}
+declare function Divider({ orientation, label, className }: DividerProps): react_jsx_runtime.JSX.Element;
+
+interface KbdProps {
+    keys: string | string[];
+    className?: string;
+}
+declare function Kbd({ keys, className }: KbdProps): react_jsx_runtime.JSX.Element;
+
+declare const roundedMap: {
+    none: string;
+    sm: string;
+    md: string;
+    lg: string;
+    full: string;
+};
+interface SkeletonProps {
+    width?: string;
+    height?: string;
+    rounded?: keyof typeof roundedMap;
+    className?: string;
+}
+declare function Skeleton({ width, height, rounded, className, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+interface SkeletonTextProps {
+    lines?: number;
+    lastLineWidth?: string;
+    gap?: string;
+    className?: string;
+}
+declare function SkeletonText({ lines, lastLineWidth, gap, className, }: SkeletonTextProps): react_jsx_runtime.JSX.Element;
+interface SkeletonCircleProps {
+    size?: number | string;
+    className?: string;
+}
+declare function SkeletonCircle({ size, className, }: SkeletonCircleProps): react_jsx_runtime.JSX.Element;
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToggleProps extends React__default.ComponentPropsWithoutRef<typeof TogglePrimitive.Root>, VariantProps<typeof toggleVariants> {
+    className?: string;
+}
+declare function Toggle({ variant, size, className, ...props }: ToggleProps): react_jsx_runtime.JSX.Element;
+type ToggleGroupProps = React__default.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> & {
+    variant?: 'default' | 'outline';
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    children?: React__default.ReactNode;
+};
+declare function ToggleGroup({ variant, size, className, children, ...props }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
+interface ToggleGroupItemProps extends React__default.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item> {
+    variant?: 'default' | 'outline';
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+}
+declare function ToggleGroupItem({ variant, size, className, ...props }: ToggleGroupItemProps): react_jsx_runtime.JSX.Element;
+
+interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    leftIcon?: LucideIcon;
+    rightIcon?: LucideIcon;
+    leftAddon?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+}
+declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;
+interface SearchInputProps extends Omit<InputProps, 'leftIcon' | 'rightIcon' | 'leftAddon'> {
+    onClear?: () => void;
+}
+declare const SearchInput: React__default.ForwardRefExoticComponent<SearchInputProps & React__default.RefAttributes<HTMLInputElement>>;
+interface TextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    maxLength?: number;
+    autoResize?: boolean;
+}
+declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+interface CheckboxProps {
+    checked?: boolean | 'indeterminate';
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+}
+declare function Checkbox({ checked, onCheckedChange, label, description, disabled, className, id, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface RadioGroupProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function RadioGroup({ value, onValueChange, orientation, children, className }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+interface RadioItemProps {
+    value: string;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+}
+declare function RadioItem({ value, label, description, disabled, className, id }: RadioItemProps): react_jsx_runtime.JSX.Element;
+
+interface SwitchProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    id?: string;
+}
+declare function Switch({ checked, onCheckedChange, label, description, disabled, size, className, id, }: SwitchProps): react_jsx_runtime.JSX.Element;
+
+interface SelectTriggerProps extends React__default.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> {
+    size?: 'sm' | 'md' | 'lg';
+    error?: string;
+    label?: string;
+}
+declare const SelectTrigger: React__default.ForwardRefExoticComponent<SelectTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React__default.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React__default.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const SelectGroup: React__default.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React__default.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare function SelectSeparator({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const Select: React__default.FC<SelectPrimitive.SelectProps>;
+declare const SelectValue: React__default.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+declare const colorMap$1: Record<string, {
+    range: string;
+    thumb: string;
+    glow: string;
+}>;
+interface SliderMark {
+    value: number;
+    label: string;
+}
+interface SliderProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    value: number;
+    onValueChange: (value: number) => void;
+    label?: string;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    size?: 'sm' | 'md';
+    color?: keyof typeof colorMap$1;
+    marks?: SliderMark[];
+    disabled?: boolean;
+    className?: string;
+}
+declare function Slider({ min, max, step, value, onValueChange, label, showValue, formatValue, size, color, marks, disabled, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+interface RangeSliderProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    value: [number, number];
+    onValueChange: (value: [number, number]) => void;
+    label?: string;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    size?: 'sm' | 'md';
+    color?: keyof typeof colorMap$1;
+    disabled?: boolean;
+    className?: string;
+}
+declare function RangeSlider({ min, max, step, value, onValueChange, label, showValue, formatValue, size, color, disabled, className, }: RangeSliderProps): react_jsx_runtime.JSX.Element;
+
+interface NumberInputProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    unit?: string;
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    className?: string;
+}
+declare function NumberInput({ value, onChange, min, max, step, label, helperText, error, unit, size, disabled, className, }: NumberInputProps): react_jsx_runtime.JSX.Element;
+
+declare const tagVariants: {
+    default: string;
+    brand: string;
+    success: string;
+    warning: string;
+    danger: string;
+};
+interface TagProps {
+    label: string;
+    onRemove?: () => void;
+    variant?: keyof typeof tagVariants;
+    size?: 'sm' | 'md';
+    className?: string;
+}
+declare function Tag({ label, onRemove, variant, size, className, }: TagProps): react_jsx_runtime.JSX.Element;
+interface TagInputProps {
+    value: string[];
+    onChange: (tags: string[]) => void;
+    placeholder?: string;
+    maxTags?: number;
+    suggestions?: string[];
+    label?: string;
+    error?: string;
+    disabled?: boolean;
+    allowDuplicates?: boolean;
+    validateTag?: (tag: string) => boolean | string;
+    className?: string;
+}
+declare function TagInput({ value, onChange, placeholder, maxTags, suggestions, label, error, disabled, allowDuplicates, validateTag, className, }: TagInputProps): react_jsx_runtime.JSX.Element;
+
+interface StealthToasterProps {
+    position?: ToasterProps['position'];
+}
+declare function StealthToaster({ position }: StealthToasterProps): react_jsx_runtime.JSX.Element;
+
+declare const Dialog: React__default.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React__default.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: React__default.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React__default.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogOverlay: React__default.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React__default.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & {
+    hideClose?: boolean;
+} & React__default.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare const DialogTitle: React__default.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React__default.RefAttributes<HTMLHeadingElement>, "ref"> & React__default.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React__default.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React__default.RefAttributes<HTMLParagraphElement>, "ref"> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare function DialogFooter({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: 'default' | 'destructive';
+    loading?: boolean;
+    onConfirm: () => void | Promise<void>;
+    onCancel?: () => void;
+}
+declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel, cancelLabel, variant, loading, onConfirm, onCancel, }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+declare const Popover: React__default.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React__default.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React__default.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React__default.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & {
+    showClose?: boolean;
+} & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: ({ children, ...props }: TooltipPrimitive.TooltipProviderProps) => react_jsx_runtime.JSX.Element;
+declare const Tooltip: React__default.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React__default.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React__default.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const DrawerTrigger: React__default.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const DrawerClose: React__default.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React__default.RefAttributes<HTMLButtonElement>>;
+type DrawerProps = React__default.ComponentPropsWithoutRef<typeof Drawer$1.Root> & {
+    direction?: 'top' | 'bottom' | 'left' | 'right';
+};
+declare function Drawer({ direction, ...props }: DrawerProps): react_jsx_runtime.JSX.Element;
+declare const sizeClasses: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    full: string;
+};
+interface DrawerContentProps extends React__default.ComponentPropsWithoutRef<typeof Drawer$1.Content> {
+    side?: 'right' | 'bottom' | 'left';
+    size?: keyof typeof sizeClasses;
+    showHandle?: boolean;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function DrawerContent({ side, size, showHandle, children, className, ...props }: DrawerContentProps): react_jsx_runtime.JSX.Element;
+interface DrawerHeaderProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function DrawerHeader({ children, className }: DrawerHeaderProps): react_jsx_runtime.JSX.Element;
+interface DrawerTitleProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function DrawerTitle({ children, className }: DrawerTitleProps): react_jsx_runtime.JSX.Element;
+interface DrawerDescriptionProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function DrawerDescription({ children, className }: DrawerDescriptionProps): react_jsx_runtime.JSX.Element;
+interface DrawerFooterProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function DrawerFooter({ children, className }: DrawerFooterProps): react_jsx_runtime.JSX.Element;
+
+declare const Tabs: React__default.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React__default.RefAttributes<HTMLDivElement>>;
+interface TabsListProps extends React__default.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+    variant?: 'glass' | 'underline' | 'pills';
+}
+declare const TabsList: React__default.ForwardRefExoticComponent<TabsListProps & React__default.RefAttributes<HTMLDivElement>>;
+interface TabsTriggerProps extends React__default.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> {
+    icon?: LucideIcon;
+}
+declare const TabsTrigger: React__default.ForwardRefExoticComponent<TabsTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare function createTriggerClass(variant: 'glass' | 'underline' | 'pills'): string;
+declare const TabsContent: React__default.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare function Breadcrumb({ className, ...props }: React__default.HTMLAttributes<HTMLElement>): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React__default.HTMLAttributes<HTMLOListElement>): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React__default.HTMLAttributes<HTMLLIElement>): react_jsx_runtime.JSX.Element;
+interface BreadcrumbLinkProps {
+    href?: string;
+    onClick?: () => void;
+    icon?: LucideIcon;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function BreadcrumbLink({ href, onClick, icon: Icon, children, className }: BreadcrumbLinkProps): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React__default.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbSeparator({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+interface BreadcrumbTrailItem {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    icon?: LucideIcon;
+}
+declare function BreadcrumbTrail({ items, className, }: {
+    items: BreadcrumbTrailItem[];
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface PaginationProps {
+    currentPage: number;
+    totalPages: number;
+    totalItems?: number;
+    pageSize?: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+    pageSizeOptions?: number[];
+    showInfo?: boolean;
+    showPageSize?: boolean;
+    className?: string;
+}
+declare function Pagination({ currentPage, totalPages, totalItems, pageSize, onPageChange, onPageSizeChange, pageSizeOptions, showInfo, showPageSize, className, }: PaginationProps): react_jsx_runtime.JSX.Element | null;
+
+type AccordionVariant = 'default' | 'bordered' | 'ghost';
+type AccordionProps = React__default.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root> & {
+    variant?: AccordionVariant;
+    className?: string;
+};
+declare function Accordion({ variant, className, ...props }: AccordionProps): react_jsx_runtime.JSX.Element;
+interface AccordionItemProps extends React__default.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item> {
+    className?: string;
+}
+declare function AccordionItem({ className, ...props }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+interface AccordionTriggerProps extends React__default.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger> {
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function AccordionTrigger({ className, children, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+interface AccordionContentProps extends React__default.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content> {
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollAreaProps {
+    orientation?: 'vertical' | 'horizontal' | 'both';
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function ScrollArea({ orientation, className, children, }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+interface ScrollBarProps {
+    orientation?: 'vertical' | 'horizontal';
+    className?: string;
+}
+declare function ScrollBar({ orientation, className, }: ScrollBarProps): react_jsx_runtime.JSX.Element;
+
+interface AvatarProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    status?: 'online' | 'offline' | 'away' | 'busy';
+    shape?: 'circle' | 'rounded';
+    className?: string;
+}
+declare function Avatar({ src, alt, name, size, status, shape, className, }: AvatarProps): react_jsx_runtime.JSX.Element;
+interface AvatarGroupProps {
+    children: React__default.ReactNode;
+    max?: number;
+    size?: AvatarProps['size'];
+    className?: string;
+}
+declare function AvatarGroup({ children, max, size, className }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+interface StatCardProps {
+    label: string;
+    value: string | number;
+    unit?: string;
+    trend?: {
+        value: number;
+        direction: 'up' | 'down' | 'flat';
+    };
+    icon?: LucideIcon;
+    status?: 'success' | 'warning' | 'danger' | 'neutral';
+    footer?: React__default.ReactNode;
+    className?: string;
+}
+declare function StatCard({ label, value, unit, trend, icon: Icon, status, footer, className, }: StatCardProps): react_jsx_runtime.JSX.Element;
+interface StatGridProps {
+    cols?: 2 | 3 | 4;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function StatGrid({ cols, children, className }: StatGridProps): react_jsx_runtime.JSX.Element;
+
+interface AlertProps {
+    variant?: 'info' | 'success' | 'warning' | 'error' | 'neutral';
+    dismissable?: boolean;
+    onDismiss?: () => void;
+    icon?: LucideIcon;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function Alert({ variant, dismissable, onDismiss, icon, children, className, }: AlertProps): react_jsx_runtime.JSX.Element;
+declare function AlertTitle({ className, ...props }: React__default.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ className, ...props }: React__default.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+declare function AlertActions({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface ProgressProps {
+    value: number;
+    max?: number;
+    size?: 'sm' | 'md' | 'lg';
+    color?: 'blue' | 'indigo' | 'success' | 'warning' | 'danger' | 'auto';
+    animated?: boolean;
+    className?: string;
+}
+declare function Progress({ value, max, size, color, animated, className, }: ProgressProps): react_jsx_runtime.JSX.Element;
+interface UsageMeterProps {
+    label: string;
+    current: number;
+    max: number;
+    unit?: string;
+    showPercentage?: boolean;
+    size?: ProgressProps['size'];
+    className?: string;
+}
+declare function UsageMeter({ label, current, max, unit, showPercentage, size, className, }: UsageMeterProps): react_jsx_runtime.JSX.Element;
+
+interface CopyButtonProps {
+    text: string;
+    label?: string;
+    variant?: 'inline' | 'button';
+    size?: 'sm' | 'md';
+    className?: string;
+}
+declare function CopyButton({ text, label, variant, size, className, }: CopyButtonProps): react_jsx_runtime.JSX.Element;
+interface CopyFieldProps {
+    label?: string;
+    value: string;
+    mono?: boolean;
+    masked?: boolean;
+    className?: string;
+}
+declare function CopyField({ label, value, mono, masked, className, }: CopyFieldProps): react_jsx_runtime.JSX.Element;
+
+interface DescriptionListProps {
+    variant?: 'stacked' | 'inline' | 'grid';
+    dividers?: boolean;
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function DescriptionList({ variant, dividers, className, children, }: DescriptionListProps): react_jsx_runtime.JSX.Element;
+interface DescriptionItemProps {
+    label: string;
+    value: React__default.ReactNode;
+    mono?: boolean;
+    copyable?: boolean;
+    icon?: LucideIcon;
+    actions?: React__default.ReactNode;
+    className?: string;
+    /** @internal — injected by DescriptionList */
+    _variant?: 'stacked' | 'inline' | 'grid';
+    /** @internal — injected by DescriptionList */
+    _divider?: boolean;
+}
+declare function DescriptionItem({ label, value, mono, copyable, icon: Icon, actions, className, _variant, _divider, }: DescriptionItemProps): react_jsx_runtime.JSX.Element;
+
+type TimelineStatus = 'default' | 'success' | 'warning' | 'danger' | 'info';
+interface TimelineProps {
+    variant?: 'default' | 'compact';
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function Timeline({ variant, className, children, }: TimelineProps): react_jsx_runtime.JSX.Element;
+interface TimelineItemProps {
+    title: string;
+    description?: React__default.ReactNode;
+    timestamp: string | Date;
+    icon?: LucideIcon;
+    status?: TimelineStatus;
+    user?: {
+        name: string;
+        avatar?: string;
+    };
+    isLast?: boolean;
+    actions?: React__default.ReactNode;
+    className?: string;
+}
+declare function TimelineItem({ title, description, timestamp, icon: Icon, status, user, isLast, actions, className, }: TimelineItemProps): react_jsx_runtime.JSX.Element;
+
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    showLineNumbers?: boolean;
+    showCopy?: boolean;
+    maxHeight?: string;
+    wrap?: boolean;
+    title?: string;
+    highlightLines?: number[];
+    className?: string;
+}
+declare function CodeBlock({ code, language, showLineNumbers, showCopy, maxHeight, wrap, title, highlightLines, className, }: CodeBlockProps): react_jsx_runtime.JSX.Element;
+interface InlineCodeProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function InlineCode({ children, className }: InlineCodeProps): react_jsx_runtime.JSX.Element;
+
+type LogLevel$1 = 'info' | 'warn' | 'error' | 'debug';
+interface LogEntry$1 {
+    id: string;
+    timestamp: string;
+    level: LogLevel$1;
+    message: string;
+    source?: string;
+    requestId?: string;
+    duration?: number;
+    memory?: number;
+    metadata?: Record<string, string>;
+}
+interface LogColumn {
+    key: 'timestamp' | 'level' | 'source' | 'message' | 'requestId' | 'duration' | 'memory';
+    label: string;
+    width?: string;
+}
+interface LogLevelBadgeProps {
+    level: LogLevel$1;
+    className?: string;
+}
+declare function LogLevelBadge({ level, className }: LogLevelBadgeProps): react_jsx_runtime.JSX.Element;
+interface LogLineProps {
+    entry: LogEntry$1;
+    showSource?: boolean;
+    compact?: boolean;
+    highlighted?: boolean;
+    onClick?: () => void;
+    className?: string;
+    cardView?: boolean;
+}
+declare function LogLine({ entry, showSource, compact, highlighted, onClick, className, cardView, }: LogLineProps): react_jsx_runtime.JSX.Element;
+interface LogViewerProps {
+    entries: LogEntry$1[];
+    maxHeight?: string;
+    showHeader?: boolean;
+    headerColumns?: LogColumn[];
+    autoScroll?: boolean;
+    onEntryClick?: (entry: LogEntry$1) => void;
+    emptyMessage?: string;
+    showSource?: boolean;
+    compact?: boolean;
+    className?: string;
+}
+declare function LogViewer({ entries, maxHeight, showHeader, headerColumns, autoScroll, onEntryClick, emptyMessage, showSource, compact, className, }: LogViewerProps): react_jsx_runtime.JSX.Element;
+
+interface KeyValueItem {
+    id: string;
+    key: string;
+    value: string;
+    scope?: string;
+    isSecret?: boolean;
+    updatedAt?: string;
+}
+interface SecretFieldProps {
+    value: string;
+    revealed?: boolean;
+    onRevealToggle?: () => void;
+    copyable?: boolean;
+    className?: string;
+}
+declare function SecretField({ value, revealed, onRevealToggle, copyable, className, }: SecretFieldProps): react_jsx_runtime.JSX.Element;
+interface KeyValueRowProps {
+    item: KeyValueItem;
+    onEdit?: () => void;
+    onDelete?: () => void;
+    readOnly?: boolean;
+    className?: string;
+}
+declare function KeyValueRow({ item, onEdit, onDelete, readOnly, className, }: KeyValueRowProps): react_jsx_runtime.JSX.Element;
+interface KeyValueEditorProps {
+    items: KeyValueItem[];
+    onChange: (items: KeyValueItem[]) => void;
+    scopes?: string[];
+    allowSecrets?: boolean;
+    addLabel?: string;
+    emptyMessage?: string;
+    readOnly?: boolean;
+    className?: string;
+}
+declare function KeyValueEditor({ items, onChange, scopes, allowSecrets, addLabel, emptyMessage, readOnly, className, }: KeyValueEditorProps): react_jsx_runtime.JSX.Element;
+
+interface ChartConfig {
+    [key: string]: {
+        label: string;
+        color: string;
+        icon?: LucideIcon;
+    };
+}
+interface ChartContainerProps {
+    config: ChartConfig;
+    children: React__default.ReactNode;
+    className?: string;
+    aspect?: number;
+}
+declare function ChartContainer({ config, children, className, aspect, }: ChartContainerProps): react_jsx_runtime.JSX.Element;
+interface ChartTooltipContentProps {
+    active?: boolean;
+    payload?: TooltipProps<number, string>['payload'];
+    label?: string;
+    config?: ChartConfig;
+    labelFormatter?: (label: string) => string;
+    valueFormatter?: (value: number, key: string) => string;
+    className?: string;
+}
+declare function ChartTooltipContent({ active, payload, label, config, labelFormatter, valueFormatter, className, }: ChartTooltipContentProps): react_jsx_runtime.JSX.Element | null;
+interface ChartTooltipProps {
+    config?: ChartConfig;
+    labelFormatter?: (label: string) => string;
+    valueFormatter?: (value: number, key: string) => string;
+    cursor?: boolean | object;
+}
+declare function ChartTooltip({ config, labelFormatter, valueFormatter, cursor, }: ChartTooltipProps): react_jsx_runtime.JSX.Element;
+interface ChartLegendContentProps {
+    payload?: Array<{
+        value: string;
+        color: string;
+        dataKey?: string;
+    }>;
+    config?: ChartConfig;
+    className?: string;
+}
+declare function ChartLegendContent({ payload, config, className, }: ChartLegendContentProps): react_jsx_runtime.JSX.Element | null;
+interface ChartLegendProps {
+    config?: ChartConfig;
+}
+declare function ChartLegend({ config }: ChartLegendProps): react_jsx_runtime.JSX.Element;
+interface ChartGridProps {
+    horizontal?: boolean;
+    vertical?: boolean;
+    className?: string;
+}
+declare function ChartGrid({ horizontal, vertical, ...props }: ChartGridProps): react_jsx_runtime.JSX.Element;
+declare const chartAxisStyle: {
+    tick: {
+        fill: string;
+        fontSize: number;
+        fontFamily: string;
+    };
+    axisLine: {
+        stroke: string;
+    };
+    tickLine: false;
+};
+
+declare const DropdownMenu: React__default.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React__default.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React__default.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React__default.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React__default.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React__default.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends React__default.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    variant?: 'default' | 'destructive';
+    shortcut?: string;
+}
+declare const DropdownMenuItem: React__default.ForwardRefExoticComponent<DropdownMenuItemProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React__default.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+interface ColumnDef<T = Record<string, unknown>> {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    render?: (value: unknown, row: T) => React__default.ReactNode;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    /** Hide this column below the given breakpoint */
+    hiddenBelow?: 'sm' | 'md' | 'lg';
+}
+interface DataTableProps<T = Record<string, unknown>> {
+    columns: ColumnDef<T>[];
+    data: T[];
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    searchKeys?: string[];
+    rowNumbers?: boolean;
+    onRowClick?: (item: T) => void;
+    emptyMessage?: string;
+    loading?: boolean;
+    getRowId?: (item: T) => string;
+    /** Row selection */
+    selectable?: boolean;
+    selectedIds?: string[];
+    onSelectionChange?: (ids: string[]) => void;
+    /** Pagination */
+    paginated?: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    className?: string;
+}
+declare function DataTable<T extends Record<string, unknown>>({ columns, data, searchable, searchPlaceholder, searchKeys, rowNumbers, onRowClick, emptyMessage, loading, getRowId, paginated, pageSize: initialPageSize, pageSizeOptions, className, selectable, selectedIds, onSelectionChange, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    icon?: LucideIcon;
+    title?: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+        icon?: LucideIcon;
+    };
+    compact?: boolean;
+    className?: string;
+}
+declare function EmptyState({ icon: Icon, title, description, action, compact, className, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+interface ErrorStateProps {
+    icon?: LucideIcon;
+    title?: string;
+    description?: string;
+    onRetry?: () => void;
+    retrying?: boolean;
+    fullPage?: boolean;
+    className?: string;
+}
+declare function ErrorState({ icon: Icon, title, description, onRetry, retrying, fullPage, className, }: ErrorStateProps): react_jsx_runtime.JSX.Element;
+interface LoadingStateProps {
+    variant?: 'spinner' | 'skeleton' | 'dots';
+    message?: string;
+    extendedMessage?: string;
+    count?: number;
+    className?: string;
+}
+declare function LoadingState({ variant, message, extendedMessage, count, className, }: LoadingStateProps): react_jsx_runtime.JSX.Element;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: LucideIcon;
+    shortcut?: string;
+    keywords?: string[];
+    disabled?: boolean;
+}
+interface CommandGroup {
+    heading: string;
+    items: CommandItem[];
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    groups: CommandGroup[];
+    onSelect: (item: CommandItem) => void;
+    placeholder?: string;
+    emptyMessage?: string;
+}
+declare function CommandPalette({ open, onOpenChange, groups, onSelect, placeholder, emptyMessage, }: CommandPaletteProps): react_jsx_runtime.JSX.Element;
+declare function useCommandPalette(): {
+    open: boolean;
+    setOpen: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    toggle: () => void;
+};
+
+interface TimeRangePreset {
+    label: string;
+    value: string;
+    getRange: () => {
+        from: Date;
+        to: Date;
+    };
+}
+interface TimeRangeValue {
+    from: Date;
+    to: Date;
+}
+interface TimeRangePickerProps {
+    value?: TimeRangeValue;
+    onChange: (range: TimeRangeValue) => void;
+    presets?: TimeRangePreset[];
+    showCustom?: boolean;
+    placeholder?: string;
+    label?: string;
+    size?: 'sm' | 'md';
+    className?: string;
+}
+declare function TimeRangePicker({ value, onChange, presets, showCustom, placeholder, label, size, className, }: TimeRangePickerProps): react_jsx_runtime.JSX.Element;
+
+interface PricingFeature {
+    label: string;
+    included: boolean;
+    tooltip?: string;
+}
+interface PricingCardProps {
+    name: string;
+    description?: string;
+    price: {
+        amount: number | string;
+        period?: string;
+        currency?: string;
+    } | string;
+    features: PricingFeature[];
+    highlighted?: boolean;
+    current?: boolean;
+    ctaLabel?: string;
+    onSelect?: () => void;
+    icon?: LucideIcon;
+    badge?: string;
+    className?: string;
+}
+declare function PricingCard({ name, description, price, features, highlighted, current, ctaLabel, onSelect, icon: Icon, badge, className, }: PricingCardProps): react_jsx_runtime.JSX.Element;
+
+type Impact = 'high' | 'medium' | 'low';
+interface RecommendationCardProps {
+    title: string;
+    description: string;
+    impact: Impact;
+    savings?: string;
+    icon?: LucideIcon;
+    onApply?: () => void;
+    onDismiss?: () => void;
+    applyLabel?: string;
+    dismissLabel?: string;
+    applied?: boolean;
+    className?: string;
+}
+declare function RecommendationCard({ title, description, impact, savings, icon: Icon, onApply, onDismiss, applyLabel, dismissLabel, applied, className, }: RecommendationCardProps): react_jsx_runtime.JSX.Element;
+
+type CellValue = boolean | 'partial';
+interface PermissionRole {
+    id: string;
+    label: string;
+    description?: string;
+}
+interface Permission {
+    id: string;
+    label: string;
+    description?: string;
+    group?: string;
+}
+interface PermissionMatrixProps {
+    roles: PermissionRole[];
+    permissions: Permission[];
+    values: Record<string, Record<string, CellValue>>;
+    onChange?: (permissionId: string, roleId: string, value: boolean) => void;
+    readOnly?: boolean;
+    className?: string;
+}
+declare function PermissionMatrix({ roles, permissions, values, onChange, readOnly, className, }: PermissionMatrixProps): react_jsx_runtime.JSX.Element;
+
+interface CronPreset {
+    label: string;
+    value: string;
+}
+interface CronEditorProps {
+    value: string;
+    onChange: (expression: string) => void;
+    presets?: CronPreset[];
+    showPreview?: boolean;
+    showNextRuns?: boolean;
+    nextRunCount?: number;
+    label?: string;
+    error?: string;
+    className?: string;
+}
+declare function CronEditor({ value, onChange, presets, showPreview, showNextRuns, nextRunCount, label, error, className, }: CronEditorProps): react_jsx_runtime.JSX.Element;
+
+type StepStatus = 'pending' | 'active' | 'completed' | 'failed' | 'skipped';
+interface Step {
+    id: string;
+    label: string;
+    description?: string;
+    status: StepStatus;
+    duration?: string;
+    icon?: LucideIcon;
+}
+interface StepIndicatorProps {
+    steps: Step[];
+    orientation?: 'horizontal' | 'vertical';
+    size?: 'sm' | 'md';
+    onStepClick?: (step: Step) => void;
+    className?: string;
+}
+declare function StepIndicator({ steps, orientation: orientationProp, size, onStepClick, className, }: StepIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface TrafficSplit {
+    id: string;
+    label: string;
+    version?: string;
+    percentage: number;
+    color?: string;
+}
+interface TrafficSplitterProps {
+    splits: TrafficSplit[];
+    onChange: (splits: TrafficSplit[]) => void;
+    min?: number;
+    maxTargets?: number;
+    label?: string;
+    onAddTarget?: () => void;
+    addTargetLabel?: string;
+    className?: string;
+}
+declare function TrafficSplitter({ splits, onChange, min, maxTargets, label, onAddTarget, addTargetLabel, className, }: TrafficSplitterProps): react_jsx_runtime.JSX.Element;
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface RequestHeader {
+    id: string;
+    key: string;
+    value: string;
+}
+interface RequestConfig {
+    method: HttpMethod;
+    url: string;
+    headers: RequestHeader[];
+    body: string;
+}
+interface ResponseResult {
+    status: number;
+    statusText?: string;
+    headers?: Record<string, string>;
+    body: string;
+    duration?: number;
+}
+interface RequestBuilderProps {
+    method?: HttpMethod;
+    url?: string;
+    headers?: RequestHeader[];
+    body?: string;
+    onSend?: (request: RequestConfig) => Promise<ResponseResult>;
+    readOnlyUrl?: boolean;
+    label?: string;
+    className?: string;
+}
+declare function RequestBuilder({ method: initialMethod, url: initialUrl, headers: initialHeaders, body: initialBody, onSend, readOnlyUrl, label, className, }: RequestBuilderProps): react_jsx_runtime.JSX.Element;
+
+type SpanStatus = 'ok' | 'error' | 'timeout';
+interface TraceSpan {
+    id: string;
+    parentId?: string;
+    service: string;
+    operation: string;
+    startTime: number;
+    duration: number;
+    status: SpanStatus;
+    tags?: Record<string, string>;
+}
+interface TraceWaterfallProps {
+    spans: TraceSpan[];
+    totalDuration?: number;
+    onSpanClick?: (span: TraceSpan) => void;
+    className?: string;
+}
+declare function TraceWaterfall({ spans, totalDuration: totalDurationProp, onSpanClick, className, }: TraceWaterfallProps): react_jsx_runtime.JSX.Element;
+
+type NodeStatus = 'healthy' | 'degraded' | 'error' | 'unknown';
+type EdgeStatus = 'ok' | 'error' | 'slow';
+interface ServiceNode {
+    id: string;
+    label: string;
+    type?: string;
+    status: NodeStatus;
+    metrics?: {
+        rps?: number;
+        latency?: number;
+        errorRate?: number;
+    };
+}
+interface ServiceEdge {
+    from: string;
+    to: string;
+    label?: string;
+    status?: EdgeStatus;
+    metrics?: {
+        rps?: number;
+        latency?: number;
+    };
+}
+interface ServiceMapProps {
+    nodes: ServiceNode[];
+    edges: ServiceEdge[];
+    onNodeClick?: (node: ServiceNode) => void;
+    width?: number;
+    height?: number;
+    className?: string;
+}
+declare function ServiceMap({ nodes, edges, onNodeClick, width, height, className, }: ServiceMapProps): react_jsx_runtime.JSX.Element;
+
+type Operator = '>' | '>=' | '<' | '<=' | '==' | '!=';
+type Severity = 'critical' | 'warning' | 'info';
+interface MetricOption {
+    value: string;
+    label: string;
+    icon?: LucideIcon;
+}
+interface ChannelOption {
+    value: string;
+    label: string;
+    icon?: LucideIcon;
+}
+interface AlertRule {
+    id: string;
+    metric: string;
+    operator: Operator;
+    threshold: number;
+    window: string;
+    severity: Severity;
+    channels: string[];
+    enabled: boolean;
+}
+interface AlertRuleEditorProps {
+    rules: AlertRule[];
+    onChange: (rules: AlertRule[]) => void;
+    metrics: MetricOption[];
+    channels?: ChannelOption[];
+    severities?: Severity[];
+    label?: string;
+    className?: string;
+}
+declare function AlertRuleEditor({ rules, onChange, metrics, channels, severities, label, className, }: AlertRuleEditorProps): react_jsx_runtime.JSX.Element;
+
+interface FileItem {
+    id: string;
+    name: string;
+    type: 'file' | 'folder';
+    size?: number;
+    modified?: string;
+    children?: FileItem[];
+}
+interface FileBrowserActions {
+    onUpload?: () => void;
+    onDownload?: (ids: string[]) => void;
+    onDelete?: (ids: string[]) => void;
+    onCreateFolder?: () => void;
+}
+interface FileBrowserProps {
+    items: FileItem[];
+    currentPath?: string[];
+    onNavigate?: (path: string[]) => void;
+    selectedIds?: string[];
+    onSelect?: (ids: string[]) => void;
+    actions?: FileBrowserActions;
+    className?: string;
+}
+declare function FileBrowser({ items, currentPath, onNavigate, selectedIds, onSelect, actions, className, }: FileBrowserProps): react_jsx_runtime.JSX.Element;
+
+interface WizardStep {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: LucideIcon;
+}
+interface StepWizardProps {
+    steps: WizardStep[];
+    currentStep: number;
+    onStepChange: (step: number) => void;
+    onFinish?: () => void;
+    canProceed?: boolean;
+    children: (step: WizardStep, index: number) => React__default.ReactNode;
+    backLabel?: string;
+    nextLabel?: string;
+    finishLabel?: string;
+    className?: string;
+}
+declare function StepWizard({ steps, currentStep, onStepChange, onFinish, canProceed, children, backLabel, nextLabel, finishLabel, className, }: StepWizardProps): react_jsx_runtime.JSX.Element;
+interface ChecklistItem {
+    id: string;
+    label: string;
+    description?: string;
+    completed: boolean;
+    action?: {
+        label: string;
+        onClick: () => void;
+        icon?: LucideIcon;
+    };
+}
+interface ChecklistProps {
+    items: ChecklistItem[];
+    onChange?: (id: string, completed: boolean) => void;
+    title?: string;
+    className?: string;
+}
+declare function Checklist({ items, onChange, title, className, }: ChecklistProps): react_jsx_runtime.JSX.Element;
+
+interface FormFieldContextValue {
+    id: string;
+    hasError: boolean;
+}
+declare function useFormField(): FormFieldContextValue;
+interface FormFieldProps {
+    /** Field label */
+    label?: string;
+    /** Small description below the label */
+    description?: string;
+    /** Error message — shows red state when truthy */
+    error?: string;
+    /** Helper text below the input (hidden when error is shown) */
+    helperText?: string;
+    /** Show required asterisk */
+    required?: boolean;
+    /** Disable the entire field */
+    disabled?: boolean;
+    /** Horizontal layout (label left, input right) */
+    horizontal?: boolean;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormField({ label, description, error, helperText, required, disabled, horizontal, children, className, }: FormFieldProps): react_jsx_runtime.JSX.Element;
+interface FormGroupProps {
+    /** Section title */
+    title?: string;
+    /** Section description */
+    description?: string;
+    /** Collapsible */
+    collapsible?: boolean;
+    /** Default collapsed state */
+    defaultCollapsed?: boolean;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormGroup({ title, description, children, className, }: FormGroupProps): react_jsx_runtime.JSX.Element;
+interface FormActionsProps {
+    /** Align buttons */
+    align?: 'left' | 'right' | 'between';
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormActions({ align, children, className }: FormActionsProps): react_jsx_runtime.JSX.Element;
+interface FormLabelProps {
+    htmlFor?: string;
+    required?: boolean;
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormLabel({ htmlFor, required, children, className }: FormLabelProps): react_jsx_runtime.JSX.Element;
+interface FormErrorProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormError({ children, className }: FormErrorProps): react_jsx_runtime.JSX.Element;
+interface FormHelperTextProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function FormHelperText({ children, className }: FormHelperTextProps): react_jsx_runtime.JSX.Element;
+
+type NotificationType = 'info' | 'success' | 'warning' | 'error' | 'deploy' | 'alert' | 'system';
+interface NotificationAction {
+    label: string;
+    onClick: () => void;
+}
+interface NotificationItem {
+    id: string;
+    type: NotificationType;
+    title: string;
+    description?: string;
+    timestamp: Date;
+    read: boolean;
+    action?: NotificationAction;
+    /** Optional avatar/icon URL */
+    avatarUrl?: string;
+}
+interface NotificationCenterProps {
+    notifications: NotificationItem[];
+    onMarkRead?: (id: string) => void;
+    onMarkAllRead?: () => void;
+    onDismiss?: (id: string) => void;
+    /** Max notifications shown before "View all" */
+    maxVisible?: number;
+    onViewAll?: () => void;
+    className?: string;
+}
+declare function NotificationCenter({ notifications, onMarkRead, onMarkAllRead, onDismiss, maxVisible, onViewAll, className, }: NotificationCenterProps): react_jsx_runtime.JSX.Element;
+interface NotificationBellProps {
+    count?: number;
+    onClick?: () => void;
+    className?: string;
+}
+declare function NotificationBell({ count, onClick, className }: NotificationBellProps): react_jsx_runtime.JSX.Element;
+
+declare const colorMap: Record<string, {
+    stroke: string;
+    fill: string;
+}>;
+interface SparklineProps {
+    /** Array of numbers or objects with a `value` key */
+    data: number[] | Array<{
+        value: number;
+        [key: string]: unknown;
+    }>;
+    /** Chart variant */
+    variant?: 'area' | 'line' | 'bar';
+    /** Color theme */
+    color?: keyof typeof colorMap;
+    /** Width in pixels */
+    width?: number;
+    /** Height in pixels */
+    height?: number;
+    /** Show min/max Y range or auto-scale from 0 */
+    autoScale?: boolean;
+    /** Animate on mount */
+    animate?: boolean;
+    /** Accessible label for screen readers */
+    'aria-label'?: string;
+    className?: string;
+}
+declare function Sparkline({ data, variant, color, width, height, autoScale, animate, 'aria-label': ariaLabel, className, }: SparklineProps): react_jsx_runtime.JSX.Element;
+interface SparklineBarProps {
+    data: number[];
+    color?: keyof typeof colorMap;
+    width?: number;
+    height?: number;
+    className?: string;
+}
+declare function SparklineBar({ data, color, width, height, className, }: SparklineBarProps): react_jsx_runtime.JSX.Element;
+interface SparklineStatProps {
+    label: string;
+    value: string | number;
+    /** Trend percentage (positive = up, negative = down) */
+    trend?: number;
+    data: number[];
+    color?: keyof typeof colorMap;
+    variant?: 'area' | 'line' | 'bar';
+    className?: string;
+}
+declare function SparklineStat({ label, value, trend, data, color, variant, className, }: SparklineStatProps): react_jsx_runtime.JSX.Element;
+
+type DiffMode = 'unified' | 'split';
+interface DiffLine {
+    type: 'added' | 'removed' | 'unchanged' | 'header';
+    content: string;
+    oldLineNum?: number;
+    newLineNum?: number;
+}
+interface DiffViewerProps {
+    /** The original text */
+    oldValue: string;
+    /** The modified text */
+    newValue: string;
+    /** Label for the old version */
+    oldTitle?: string;
+    /** Label for the new version */
+    newTitle?: string;
+    /** Display mode */
+    mode?: DiffMode;
+    /** Allow toggling between modes */
+    showModeToggle?: boolean;
+    /** Language label (decorative) */
+    language?: string;
+    /** Max height before scroll */
+    maxHeight?: string;
+    className?: string;
+}
+declare function DiffViewer({ oldValue, newValue, oldTitle, newTitle, mode: initialMode, showModeToggle, language, maxHeight, className, }: DiffViewerProps): react_jsx_runtime.JSX.Element;
+
+type BannerVariant = 'info' | 'warning' | 'error' | 'success' | 'announcement';
+interface BannerAction {
+    label: string;
+    onClick: () => void;
+}
+interface BannerProps {
+    variant?: BannerVariant;
+    title: string;
+    description?: string;
+    action?: BannerAction;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    /** Sticky to top of viewport */
+    sticky?: boolean;
+    /** Icon override */
+    icon?: React__default.ElementType;
+    className?: string;
+}
+declare function Banner({ variant, title, description, action, dismissible, onDismiss, sticky, icon: IconOverride, className, }: BannerProps): react_jsx_runtime.JSX.Element | null;
+interface BannerStackProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare function BannerStack({ children, className }: BannerStackProps): react_jsx_runtime.JSX.Element;
+
+type TerminalLineType = 'stdout' | 'stderr' | 'system' | 'error' | 'success' | 'warning';
+interface TerminalLine {
+    text: string;
+    type?: TerminalLineType;
+    timestamp?: Date;
+}
+interface TerminalProps {
+    lines: TerminalLine[];
+    title?: string;
+    /** Show timestamps beside each line */
+    showTimestamps?: boolean;
+    /** Auto-scroll to bottom on new lines */
+    autoScroll?: boolean;
+    /** Max height */
+    maxHeight?: string;
+    /** Show line numbers */
+    lineNumbers?: boolean;
+    /** Allow pause/resume of auto-scroll */
+    showControls?: boolean;
+    /** On clear callback */
+    onClear?: () => void;
+    className?: string;
+}
+declare function Terminal({ lines, title, showTimestamps, autoScroll: initialAutoScroll, maxHeight, lineNumbers, showControls, onClear, className, }: TerminalProps): react_jsx_runtime.JSX.Element;
+
+interface DateTimePickerProps {
+    value?: Date | null;
+    onChange: (date: Date | null) => void;
+    /** Show time picker */
+    showTime?: boolean;
+    /** Min date */
+    minDate?: Date;
+    /** Max date */
+    maxDate?: Date;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Label above the picker */
+    label?: string;
+    /** Size variant */
+    size?: 'sm' | 'md';
+    /** Allow clearing the value */
+    clearable?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    className?: string;
+}
+declare function DateTimePicker({ value, onChange, showTime, minDate, maxDate, placeholder, label, size, clearable, disabled, className, }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
+
+type PipelineStepStatus = 'pending' | 'running' | 'success' | 'failed' | 'skipped' | 'cancelled';
+interface PipelineStep {
+    id: string;
+    name: string;
+    status: PipelineStepStatus;
+    duration?: string;
+    /** Log output preview */
+    logPreview?: string;
+}
+interface PipelineStage {
+    id: string;
+    name: string;
+    status: PipelineStepStatus;
+    duration?: string;
+    /** Steps within this stage */
+    steps?: PipelineStep[];
+    /** Are steps parallel? */
+    parallel?: boolean;
+}
+interface PipelineProps {
+    stages: PipelineStage[];
+    /** Compact mode (no step details) */
+    compact?: boolean;
+    /** Currently selected stage ID */
+    selectedStageId?: string;
+    onStageClick?: (stageId: string) => void;
+    className?: string;
+}
+declare function Pipeline({ stages, compact, selectedStageId, onStageClick, className, }: PipelineProps): react_jsx_runtime.JSX.Element;
+
+declare const ContextMenu: React__default.FC<ContextMenuPrimitive.ContextMenuProps>;
+declare const ContextMenuTrigger: React__default.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React__default.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React__default.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React__default.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React__default.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React__default.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+interface ContextMenuItemProps extends React__default.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> {
+    icon?: React__default.ElementType;
+    shortcut?: string;
+    destructive?: boolean;
+}
+declare const ContextMenuItem: React__default.ForwardRefExoticComponent<ContextMenuItemProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & {
+    icon?: React__default.ElementType;
+} & React__default.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React__default.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+interface FilterOption {
+    value: string;
+    label: string;
+    /** Optional color dot (e.g., for status) */
+    color?: string;
+    /** Count of matching items */
+    count?: number;
+}
+interface FilterDefinition {
+    id: string;
+    label: string;
+    type: 'select' | 'multi-select';
+    options: FilterOption[];
+    /** Icon for the filter */
+    icon?: React__default.ElementType;
+}
+interface ActiveFilter {
+    filterId: string;
+    values: string[];
+}
+interface FilterBarProps {
+    filters: FilterDefinition[];
+    activeFilters: ActiveFilter[];
+    onFiltersChange: (filters: ActiveFilter[]) => void;
+    /** Search input */
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchPlaceholder?: string;
+    /** Show filter count badges */
+    showCounts?: boolean;
+    className?: string;
+}
+declare function FilterBar({ filters, activeFilters, onFiltersChange, searchValue, onSearchChange, searchPlaceholder, showCounts, className, }: FilterBarProps): react_jsx_runtime.JSX.Element;
+
+type DropZoneFileStatus = 'pending' | 'uploading' | 'success' | 'error';
+interface DropZoneFile {
+    id: string;
+    file: File;
+    status: DropZoneFileStatus;
+    progress?: number;
+    error?: string;
+}
+interface DropZoneProps {
+    /** Accepted file types (e.g., ['.js', '.ts', 'image/*']) */
+    accept?: string[];
+    /** Max file size in bytes */
+    maxSize?: number;
+    /** Allow multiple files */
+    multiple?: boolean;
+    /** Max number of files */
+    maxFiles?: number;
+    /** Callback when files are dropped/selected */
+    onDrop: (files: File[]) => void;
+    /** Show file list below drop zone */
+    showFileList?: boolean;
+    /** Files currently in the list (for controlled mode) */
+    files?: DropZoneFile[];
+    /** Remove file callback */
+    onRemove?: (fileId: string) => void;
+    /** Custom label */
+    label?: string;
+    /** Custom description */
+    description?: string;
+    /** Compact mode */
+    compact?: boolean;
+    /** Disabled */
+    disabled?: boolean;
+    className?: string;
+}
+declare function DropZone({ accept, maxSize, multiple, maxFiles, onDrop, showFileList, files: controlledFiles, onRemove, label, description, compact, disabled, className, }: DropZoneProps): react_jsx_runtime.JSX.Element;
+
+type PodStatus = 'running' | 'pending' | 'failed' | 'warning' | 'terminating';
+interface PodNode {
+    id: string;
+    name: string;
+    status: PodStatus;
+    /** 0-100 representation of load */
+    load?: number;
+    /** Optional group/node identifier */
+    group?: string;
+}
+interface PodHoneycombProps {
+    pods: PodNode[];
+    /** Group pods by this field (e.g. 'group') */
+    groupBy?: keyof PodNode;
+    className?: string;
+    onPodClick?: (pod: PodNode) => void;
+}
+declare function PodHoneycomb({ pods, groupBy, className, onPodClick }: PodHoneycombProps): react_jsx_runtime.JSX.Element;
+
+type RegionStatus = 'online' | 'degraded' | 'offline';
+interface RegionPoint {
+    id: string;
+    name: string;
+    code: string;
+    latency: number;
+    status: RegionStatus;
+}
+interface LatencyRadarProps {
+    regions: RegionPoint[];
+    className?: string;
+    onRegionClick?: (region: RegionPoint) => void;
+}
+declare function LatencyRadar({ regions, className, onRegionClick }: LatencyRadarProps): react_jsx_runtime.JSX.Element;
+
+interface CostDataPoint {
+    date: string;
+    actual: number | null;
+    projected: number | null;
+}
+interface CostForecastProps {
+    data: CostDataPoint[];
+    currentSpend: number;
+    projectedSpend: number;
+    budget: number;
+    currency?: string;
+    className?: string;
+}
+declare function CostForecast({ data, currentSpend, projectedSpend, budget, currency, className }: CostForecastProps): react_jsx_runtime.JSX.Element;
+
+interface ResourceGaugeProps {
+    label: string;
+    value: number;
+    limit?: string;
+    unit?: string;
+    color?: 'blue' | 'purple' | 'emerald' | 'amber' | 'red';
+    size?: number;
+    className?: string;
+}
+declare function ResourceGauge({ label, value, limit, unit, color, size, className, }: ResourceGaugeProps): react_jsx_runtime.JSX.Element;
+
+type LogLevel = 'info' | 'warn' | 'error' | 'debug' | 'success';
+interface LogEntry {
+    id: string;
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    source?: string;
+}
+interface LogTerminalProps {
+    logs: LogEntry[];
+    title?: string;
+    isStreaming?: boolean;
+    className?: string;
+    onClear?: () => void;
+    onDownload?: () => void;
+    onToggleStream?: () => void;
+}
+declare function LogTerminal({ logs, title, isStreaming, className, onClear, onDownload, onToggleStream }: LogTerminalProps): react_jsx_runtime.JSX.Element;
+
+interface EnvVar {
+    id: string;
+    key: string;
+    value: string;
+    isSecret: boolean;
+    isSynced: boolean;
+}
+interface EnvManagerProps {
+    variables: EnvVar[];
+    className?: string;
+    onUpdate?: (vars: EnvVar[]) => void;
+    onDeploy?: () => void;
+}
+declare function EnvManager({ variables: initialVars, className, onUpdate, onDeploy }: EnvManagerProps): react_jsx_runtime.JSX.Element;
+
+interface GlobePoint {
+    id: string;
+    lat: number;
+    lng: number;
+    label: string;
+    status: 'active' | 'degraded' | 'offline';
+    pulse?: boolean;
+}
+interface GlobeTrackerProps {
+    points: GlobePoint[];
+    className?: string;
+    height?: number;
+}
+declare function GlobeTracker({ points, className, height }: GlobeTrackerProps): react_jsx_runtime.JSX.Element;
+
+interface DomainRecord {
+    id: string;
+    domain: string;
+    status: 'active' | 'pending' | 'error';
+    type: 'primary' | 'redirect' | 'alias';
+    dnsRecord?: {
+        type: 'CNAME' | 'A' | 'TXT';
+        name: string;
+        value: string;
+    };
+    errorMessage?: string;
+}
+interface DomainManagerProps {
+    domains: DomainRecord[];
+    onAddDomain?: () => void;
+    onVerify?: (id: string) => void;
+    onRemove?: (id: string) => void;
+    className?: string;
+}
+declare function DomainManager({ domains, onAddDomain, onVerify, onRemove, className }: DomainManagerProps): react_jsx_runtime.JSX.Element;
+
+interface ActivityDataPoint {
+    date: string;
+    count: number;
+    level?: 0 | 1 | 2 | 3 | 4;
+}
+interface ActivityHeatmapProps {
+    data: ActivityDataPoint[];
+    startDate?: Date;
+    days?: number;
+    className?: string;
+    colorScale?: 'blue' | 'green' | 'amber' | 'purple';
+}
+declare function ActivityHeatmap({ data, startDate, days, // 12 weeks * 7 days
+className, colorScale }: ActivityHeatmapProps): react_jsx_runtime.JSX.Element;
+
+type DeploymentStatus = 'queued' | 'building' | 'ready' | 'error' | 'cancelled';
+interface DeploymentItem {
+    id: string;
+    project: string;
+    branch: string;
+    commitHash: string;
+    commitMessage: string;
+    status: DeploymentStatus;
+    createdAt: string;
+    duration?: string;
+    authorName: string;
+    authorAvatar?: string;
+}
+interface DeploymentListProps {
+    deployments: DeploymentItem[];
+    className?: string;
+    onSelect?: (id: string) => void;
+    onRollback?: (id: string) => void;
+}
+declare function DeploymentList({ deployments, className, onSelect, onRollback }: DeploymentListProps): react_jsx_runtime.JSX.Element;
+
+interface AutoscaleConfig {
+    minReplicas: number;
+    maxReplicas: number;
+    cpuThreshold: number;
+    enabled: boolean;
+}
+interface AutoscaleControlProps {
+    config: AutoscaleConfig;
+    onChange: (config: AutoscaleConfig) => void;
+    className?: string;
+    maxLimit?: number;
+}
+declare function AutoscaleControl({ config, onChange, className, maxLimit }: AutoscaleControlProps): react_jsx_runtime.JSX.Element;
+
+interface CachePurgeRecord {
+    id: string;
+    path: string;
+    status: 'pending' | 'completed' | 'failed';
+    initiatedBy: string;
+    timestamp: string;
+}
+interface CacheManagerProps {
+    records: CachePurgeRecord[];
+    onPurge: (path: string, tags: string[]) => void;
+    className?: string;
+}
+declare function CacheManager({ records, onPurge, className }: CacheManagerProps): react_jsx_runtime.JSX.Element;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, type ActiveFilter, type ActivityDataPoint, ActivityHeatmap, type ActivityHeatmapProps, Alert, AlertActions, AlertDescription, type AlertProps, type AlertRule, AlertRuleEditor, type AlertRuleEditorProps, AlertTitle, AmbientBackground, AnimatedSection, AppShell, type AppShellProps, type AutoscaleConfig, AutoscaleControl, type AutoscaleControlProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeProps, Banner, type BannerAction, type BannerProps, BannerStack, type BannerStackProps, type BannerVariant, BentoCard, type BentoCardProps, BentoCell, type BentoCellProps, BentoGrid, type BentoGridProps, Breadcrumb, BreadcrumbItem, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbTrail, type BreadcrumbTrailItem, Button, type ButtonProps, CacheManager, type CacheManagerProps, type CachePurgeRecord, type ChannelOption, type ChartConfig, ChartContainer, type ChartContainerProps, ChartGrid, type ChartGridProps, ChartLegend, ChartLegendContent, type ChartLegendContentProps, type ChartLegendProps, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTooltipProps, Checkbox, type CheckboxProps, Checklist, type ChecklistItem, type ChecklistProps, CodeBlock, type CodeBlockProps, type ColumnDef, type CommandGroup, type CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, CopyButton, type CopyButtonProps, CopyField, type CopyFieldProps, type CostDataPoint, CostForecast, type CostForecastProps, CronEditor, type CronEditorProps, type CronPreset, DataTable, type DataTableProps, DataValue, DateTimePicker, type DateTimePickerProps, type DeploymentItem, DeploymentList, type DeploymentListProps, type DeploymentStatus, DescriptionItem, type DescriptionItemProps, DescriptionList, type DescriptionListProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, type DiffLine, type DiffMode, DiffViewer, type DiffViewerProps, Divider, type DividerProps, DomainManager, type DomainManagerProps, type DomainRecord, Drawer, DrawerClose, DrawerContent, type DrawerContentProps, DrawerDescription, type DrawerDescriptionProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerProps, DrawerTitle, type DrawerTitleProps, DrawerTrigger, DropZone, type DropZoneFile, type DropZoneFileStatus, type DropZoneProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, EnvManager, type EnvManagerProps, type EnvVar, ErrorState, type ErrorStateProps, FileBrowser, type FileBrowserActions, type FileBrowserProps, type FileItem, FilterBar, type FilterBarProps, type FilterDefinition, type FilterOption, FormActions, type FormActionsProps, FormError, type FormErrorProps, FormField, type FormFieldProps, FormGroup, type FormGroupProps, FormHelperText, type FormHelperTextProps, FormLabel, type FormLabelProps, GlassTile, type GlobePoint, GlobeTracker, type GlobeTrackerProps, type HeaderCTAButton, type HeaderUser, type HeaderWallet, HudLabel, InlineCode, type InlineCodeProps, Input, type InputProps, Kbd, type KbdProps, KeyValueEditor, type KeyValueEditorProps, type KeyValueItem, KeyValueRow, type KeyValueRowProps, LatencyRadar, type LatencyRadarProps, LoadingState, type LoadingStateProps, type LogColumn, type LogEntry$1 as LogEntry, type LogLevel$1 as LogLevel, LogLevelBadge, type LogLevelBadgeProps, LogLine, type LogLineProps, LogTerminal, type LogEntry as LogTerminalEntry, type LogLevel as LogTerminalLevel, type LogTerminalProps, LogViewer, type LogViewerProps, type MetricOption, type NotificationAction, NotificationBell, type NotificationBellProps, NotificationCenter, type NotificationCenterProps, type NotificationItem, type NotificationType, NumberInput, type NumberInputProps, PageShell, Pagination, type PaginationProps, type Permission as PermissionItem, PermissionMatrix, type PermissionMatrixProps, type PermissionRole, Pipeline, type PipelineProps, type PipelineStage, type PipelineStep, type PipelineStepStatus, PodHoneycomb, type PodHoneycombProps, type PodNode, type PodStatus, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PricingCard, type PricingCardProps, type PricingFeature, Progress, type ProgressProps, RadioGroup, type RadioGroupProps, RadioItem, type RadioItemProps, RangeSlider, type RangeSliderProps, RecommendationCard, type RecommendationCardProps, type RegionPoint, type RegionStatus, RequestBuilder, type RequestBuilderProps, type RequestConfig, type RequestHeader, ResourceGauge, type ResourceGaugeProps, type ResponseResult, RevealAction, RevealGroup, ScrollArea, type ScrollAreaProps, ScrollBar, type ScrollBarProps, SearchInput, type SearchInputProps, SecretField, type SecretFieldProps, SectionDot, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, type ServiceEdge, ServiceMap, type ServiceMapProps, type ServiceNode, type SidebarCTAButton, type SidebarLogo, type SidebarNavItem, type SidebarNavSection, type SidebarSubmenuConfig, type SidebarUser, type SidebarWallet, Skeleton, SkeletonCircle, type SkeletonCircleProps, type SkeletonProps, SkeletonText, type SkeletonTextProps, Slider, type SliderMark, type SliderProps, Sparkline, SparklineBar, type SparklineBarProps, type SparklineProps, SparklineStat, type SparklineStatProps, StatCard, type StatCardProps, StatGrid, type StatGridProps, StatusBadge, StatusDot, StatusIndicator, StealthHeader, type StealthHeaderProps, StealthSidebar, type StealthSidebarProps, StealthToaster, type StealthToasterProps, type Step, StepIndicator, type StepIndicatorProps, StepWizard, type StepWizardProps, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsListProps, TabsTrigger, type TabsTriggerProps, Tag, TagInput, type TagInputProps, type TagProps, Terminal, type TerminalLine, type TerminalLineType, type TerminalProps, Textarea, type TextareaProps, TimeRangePicker, type TimeRangePickerProps, type TimeRangePreset, type TimeRangeValue, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, Toggle, ToggleGroup, ToggleGroupItem, type ToggleGroupItemProps, type ToggleGroupProps, type ToggleProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TraceSpan, TraceWaterfall, type TraceWaterfallProps, type TrafficSplit, TrafficSplitter, type TrafficSplitterProps, UsageMeter, type UsageMeterProps, type WizardStep, buttonVariants, chartAxisStyle, createTriggerClass, useCommandPalette, useFormField };