@jerco/ui 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,416 @@
+import * as react from 'react';
+import { ReactNode, HTMLAttributes, ButtonHTMLAttributes, ComponentPropsWithoutRef, InputHTMLAttributes, LabelHTMLAttributes, TextareaHTMLAttributes, AnchorHTMLAttributes, ComponentProps } from 'react';
+import { ThemeName, Density } from '@jerco/tokens';
+import { ColumnDef, PaginationState, SortingState, Row } from '@tanstack/react-table';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { LucideIcon } from '@jerco/icons';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as DropdownPrimitive from '@radix-ui/react-dropdown-menu';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ToastPrimitive from '@radix-ui/react-toast';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+
+interface DesignSystemContextValue {
+    theme: ThemeName;
+    density: Density;
+}
+interface DesignSystemProviderProps {
+    children: ReactNode;
+    theme?: ThemeName;
+    density?: Density;
+    target?: HTMLElement | null;
+}
+declare function DesignSystemProvider({ children, theme, density, target }: DesignSystemProviderProps): react.JSX.Element;
+declare function useDesignSystem(): DesignSystemContextValue;
+
+type OperationalStatus = "online" | "offline" | "healthy" | "degraded" | "warning" | "error" | "unknown";
+
+type DataTableColumn<TData, TValue = unknown> = ColumnDef<TData, TValue>;
+interface DataTableFilter<TData> {
+    id: string;
+    label: string;
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    getValue: (row: TData) => string;
+}
+interface DataTableRequestState {
+    pagination: PaginationState;
+    sorting: SortingState;
+    query: string;
+    filters: Record<string, string>;
+}
+interface DataTableServerConfig {
+    rowCount: number;
+    pageCount: number;
+    state: DataTableRequestState;
+    onStateChange: (state: DataTableRequestState) => void;
+}
+interface DataTableVirtualizationOptions {
+    height?: number;
+    estimateRowHeight?: number;
+    overscan?: number;
+}
+interface DataTableProps<TData> {
+    data: TData[];
+    columns: Array<DataTableColumn<TData>>;
+    getRowId?: (row: TData, index: number) => string;
+    getSearchText?: (row: TData) => string;
+    searchPlaceholder?: string;
+    filters?: DataTableFilter<TData>[];
+    pageSize?: number;
+    paginate?: boolean;
+    server?: DataTableServerConfig;
+    virtualization?: DataTableVirtualizationOptions;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    bulkActions?: (selectedRows: Array<Row<TData>>) => ReactNode;
+    className?: string;
+}
+declare function DataTable<TData>({ data, columns, getRowId, getSearchText, searchPlaceholder, filters, pageSize, paginate, server, virtualization, loading, emptyState, bulkActions, className }: DataTableProps<TData>): react.JSX.Element;
+
+type DataTableHistoryMode = "push" | "replace";
+interface DataTableUrlCodecOptions {
+    prefix?: string;
+}
+interface DataTableUrlPort {
+    getSearch: () => string;
+    writeSearch: (search: string, mode: DataTableHistoryMode) => void;
+    subscribe: (listener: () => void) => () => void;
+}
+interface DataTableUrlStateAdapter {
+    read: (fallback: DataTableRequestState) => DataTableRequestState;
+    write: (state: DataTableRequestState, mode?: DataTableHistoryMode) => void;
+    subscribe: (listener: (state: DataTableRequestState) => void, fallback: DataTableRequestState) => () => void;
+}
+interface DataTableRequestContext {
+    requestId: number;
+    signal: AbortSignal;
+}
+type DataTableRequestResult<T> = {
+    status: "applied";
+    requestId: number;
+    value: T;
+} | {
+    status: "aborted" | "stale";
+    requestId: number;
+};
+interface DataTableRequestManager<T> {
+    run: (state: DataTableRequestState) => Promise<DataTableRequestResult<T>>;
+    cancel: () => void;
+    getActiveRequestId: () => number | undefined;
+}
+declare function parseDataTableUrlState(search: string, fallback: DataTableRequestState, options?: DataTableUrlCodecOptions): DataTableRequestState;
+declare function serializeDataTableUrlState(state: DataTableRequestState, currentSearch?: string, options?: DataTableUrlCodecOptions): string;
+declare function createDataTableUrlStateAdapter(port: DataTableUrlPort, options?: DataTableUrlCodecOptions): DataTableUrlStateAdapter;
+declare function createBrowserDataTableUrlStateAdapter(options?: DataTableUrlCodecOptions): DataTableUrlStateAdapter;
+declare function createDataTableRequestManager<T>(loader: (state: DataTableRequestState, context: DataTableRequestContext) => Promise<T>): DataTableRequestManager<T>;
+
+interface BooleanStateAdapter {
+    read: () => boolean | undefined;
+    write: (value: boolean) => void;
+    subscribe?: (listener: (value: boolean | undefined) => void) => () => void;
+}
+interface KeyValueStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+}
+interface StorageEventSource {
+    addEventListener: (type: "storage", listener: (event: StorageEvent) => void) => void;
+    removeEventListener: (type: "storage", listener: (event: StorageEvent) => void) => void;
+}
+interface BrowserBooleanStateAdapterOptions {
+    storage?: KeyValueStorage;
+    eventSource?: StorageEventSource;
+}
+declare function createBrowserBooleanStateAdapter(key: string, options?: BrowserBooleanStateAdapterOptions): BooleanStateAdapter;
+declare function matchNavigationPath(currentPath: string, targetPath: string, end?: boolean): boolean;
+
+declare const badgeVariants: (props?: ({
+    variant?: "warning" | "neutral" | "success" | "danger" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): react.JSX.Element;
+
+declare const AlertDialog: react.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: react.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: react.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogCancelProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogAction: react.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogActionProps & react.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogContent: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogTitle: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: react.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+declare function AlertDialogHeader({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function AlertDialogFooter({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+
+interface BrandLogoProps {
+    asset?: ReactNode;
+    name?: string;
+    className?: string;
+}
+declare function BrandLogo({ asset, name, className }: BrandLogoProps): react.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+interface IconButtonProps extends Omit<ButtonProps, "size"> {
+    label: string;
+    size?: "sm" | "md" | "lg";
+}
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): react.JSX.Element;
+declare function CardDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): react.JSX.Element;
+declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+declare const Checkbox: react.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+interface CheckboxFieldProps extends ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    label: ReactNode;
+    description?: ReactNode;
+}
+declare function CheckboxField({ label, description, id, ...props }: CheckboxFieldProps): react.JSX.Element;
+
+interface DeviceCardProps {
+    name: string;
+    type: string;
+    status: OperationalStatus;
+    address?: string;
+    latency?: string;
+    description?: string;
+    icon?: LucideIcon;
+    actions?: ReactNode;
+    loading?: boolean;
+    className?: string;
+}
+declare function DeviceCard({ name, type, status, address, latency, description, icon: Icon, actions, loading, className }: DeviceCardProps): react.JSX.Element;
+
+declare const Dialog: react.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: react.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: react.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DialogContent: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DialogTitle: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & react.RefAttributes<HTMLHeadingElement>, "ref"> & react.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: react.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & react.RefAttributes<HTMLParagraphElement>, "ref"> & react.RefAttributes<HTMLParagraphElement>>;
+declare function DialogHeader({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function DialogFooter({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+
+declare const DropdownMenu: react.FC<DropdownPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: react.ForwardRefExoticComponent<DropdownPrimitive.DropdownMenuTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: react.ForwardRefExoticComponent<DropdownPrimitive.DropdownMenuGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: react.FC<DropdownPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: react.FC<DropdownPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: react.ForwardRefExoticComponent<DropdownPrimitive.DropdownMenuRadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuCheckboxItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuRadioItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuSeparatorProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuSubTriggerProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: react.ForwardRefExoticComponent<Omit<DropdownPrimitive.DropdownMenuSubContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    invalid?: boolean;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    invalid?: boolean;
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+declare const Label: react.ForwardRefExoticComponent<LabelHTMLAttributes<HTMLLabelElement> & react.RefAttributes<HTMLLabelElement>>;
+declare function Separator({ className }: {
+    className?: string;
+}): react.JSX.Element;
+
+interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
+    defaultMobileOpen?: boolean;
+    defaultSidebarCollapsed?: boolean;
+    sidebarCollapsed?: boolean;
+    onSidebarCollapsedChange?: (collapsed: boolean) => void;
+    sidebarPersistence?: BooleanStateAdapter;
+}
+declare function AppShell({ className, defaultMobileOpen, defaultSidebarCollapsed, sidebarCollapsed: controlledSidebarCollapsed, onSidebarCollapsedChange, sidebarPersistence, ...props }: AppShellProps): react.JSX.Element;
+declare function Sidebar({ className, children, ...props }: HTMLAttributes<HTMLElement>): react.JSX.Element;
+declare function AppShellMenuButton({ className, label, ...props }: Omit<ComponentProps<typeof IconButton>, "label"> & {
+    label?: string;
+}): react.JSX.Element;
+declare function AppShellCollapseButton({ className, ...props }: Omit<ComponentProps<typeof IconButton>, "label">): react.JSX.Element;
+declare function Header({ className, ...props }: HTMLAttributes<HTMLElement>): react.JSX.Element;
+declare function MainContent({ className, ...props }: HTMLAttributes<HTMLElement>): react.JSX.Element;
+interface AppNavigationItem extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "children"> {
+    id?: string;
+    label: string;
+    icon?: LucideIcon;
+    badge?: ReactNode;
+    active?: boolean;
+    matchEnd?: boolean;
+    items?: AppNavigationItem[];
+    defaultExpanded?: boolean;
+}
+interface AppNavigationProps extends HTMLAttributes<HTMLElement> {
+    items: AppNavigationItem[];
+    label?: string;
+    footer?: ReactNode;
+    currentPath?: string;
+    isPathActive?: (currentPath: string, href: string, item: AppNavigationItem) => boolean;
+    onNavigate?: (item: AppNavigationItem, event: React.MouseEvent<HTMLAnchorElement>) => void;
+    renderLink?: (options: AppNavigationLinkRenderOptions) => ReactNode;
+}
+interface AppNavigationLinkRenderOptions {
+    item: AppNavigationItem;
+    active: boolean;
+    className: string;
+    children: ReactNode;
+    onClick: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+}
+declare function AppNavigation({ items, label, footer, currentPath, isPathActive, onNavigate, renderLink, className, ...props }: AppNavigationProps): react.JSX.Element;
+interface PageHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    title: string;
+    description?: string;
+    eyebrow?: string;
+    actions?: ReactNode;
+}
+declare function PageHeader({ title, description, eyebrow, actions, className, ...props }: PageHeaderProps): react.JSX.Element;
+
+interface MetricCardProps {
+    label: string;
+    value: ReactNode;
+    description?: string;
+    trend?: string;
+    status?: OperationalStatus;
+    icon?: LucideIcon;
+    loading?: boolean;
+    className?: string;
+}
+declare function MetricCard({ label, value, description, trend, status, icon: Icon, loading, className }: MetricCardProps): react.JSX.Element;
+
+interface OperationalStateProps {
+    title: string;
+    description: string;
+    icon?: LucideIcon;
+    action?: ReactNode;
+    compact?: boolean;
+    className?: string;
+}
+declare function EmptyState({ icon: Icon, title, description, action, compact, className }: OperationalStateProps): react.JSX.Element;
+interface ErrorStateProps extends OperationalStateProps {
+    onRetry?: () => void;
+    retryLabel?: string;
+}
+declare function ErrorState({ icon: Icon, title, description, action, onRetry, retryLabel, compact, className }: ErrorStateProps): react.JSX.Element;
+
+declare const RadioGroup: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare function RadioField({ id, label, description, value }: {
+    id: string;
+    label: ReactNode;
+    description?: ReactNode;
+    value: string;
+}): react.JSX.Element;
+
+interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface SelectProps {
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    label: string;
+    disabled?: boolean;
+}
+declare function Select({ options, label, placeholder, ...props }: SelectProps): react.JSX.Element;
+declare const SelectGroup: react.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & react.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: react.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & react.RefAttributes<HTMLSpanElement>>;
+declare const SelectLabel: react.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare function NativeSelect({ label, children, className, ...props }: ComponentPropsWithoutRef<"select"> & {
+    label: string;
+    children: ReactNode;
+}): react.JSX.Element;
+
+interface ServiceHealthProps {
+    name: string;
+    status: OperationalStatus;
+    endpoint?: string;
+    latency?: string;
+    description?: string;
+    meta?: ReactNode;
+    className?: string;
+}
+declare function ServiceHealth({ name, status, endpoint, latency, description, meta, className }: ServiceHealthProps): react.JSX.Element;
+
+declare function Skeleton({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+interface SpinnerProps {
+    label?: string;
+    className?: string;
+}
+declare function Spinner({ label, className }: SpinnerProps): react.JSX.Element;
+
+interface StatusIndicatorProps {
+    status: OperationalStatus;
+    label?: string;
+    showIcon?: boolean;
+    className?: string;
+}
+declare function StatusIndicator({ status, label, showIcon, className }: StatusIndicatorProps): react.JSX.Element;
+
+declare const Switch: react.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare function SwitchField({ id, label, description, ...props }: ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> & {
+    label: ReactNode;
+    description?: ReactNode;
+}): react.JSX.Element;
+
+declare const Tabs: react.ForwardRefExoticComponent<TabsPrimitive.TabsProps & react.RefAttributes<HTMLDivElement>>;
+declare const TabsList: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: react.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ToastProvider: react.FC<ToastPrimitive.ToastProviderProps>;
+declare const Toast: react.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastProps & react.RefAttributes<HTMLLIElement>, "ref"> & {
+    tone?: "neutral" | "success" | "warning" | "danger";
+} & react.RefAttributes<HTMLLIElement>>;
+declare const ToastTitle: react.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastTitleProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: react.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastDescriptionProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToastAction: react.ForwardRefExoticComponent<ToastPrimitive.ToastActionProps & react.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: react.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastCloseProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+declare const ToastViewport: react.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastViewportProps & react.RefAttributes<HTMLOListElement>, "ref"> & react.RefAttributes<HTMLOListElement>>;
+
+declare const TooltipProvider: react.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: react.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: react.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: react.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare function SimpleTooltip({ content, children }: {
+    content: ReactNode;
+    children: ReactNode;
+}): react.JSX.Element;
+
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, AppNavigation, type AppNavigationItem, type AppNavigationLinkRenderOptions, type AppNavigationProps, AppShell, AppShellCollapseButton, AppShellMenuButton, type AppShellProps, Badge, type BadgeProps, type BooleanStateAdapter, BrandLogo, type BrandLogoProps, type BrowserBooleanStateAdapterOptions, Button, type ButtonProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, CheckboxField, type CheckboxFieldProps, DataTable, type DataTableColumn, type DataTableFilter, type DataTableHistoryMode, type DataTableProps, type DataTableRequestContext, type DataTableRequestManager, type DataTableRequestResult, type DataTableRequestState, type DataTableServerConfig, type DataTableUrlCodecOptions, type DataTableUrlPort, type DataTableUrlStateAdapter, type DataTableVirtualizationOptions, DesignSystemProvider, type DesignSystemProviderProps, DeviceCard, type DeviceCardProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, ErrorState, type ErrorStateProps, Header, IconButton, type IconButtonProps, Input, type InputProps, type KeyValueStorage, Label, MainContent, MetricCard, type MetricCardProps, NativeSelect, type OperationalStateProps, type OperationalStatus, PageHeader, type PageHeaderProps, RadioField, RadioGroup, RadioGroupItem, Select, SelectGroup, SelectLabel, type SelectOption, type SelectProps, SelectValue, Separator, ServiceHealth, type ServiceHealthProps, Sidebar, SimpleTooltip, Skeleton, Spinner, type SpinnerProps, StatusIndicator, type StatusIndicatorProps, type StorageEventSource, Switch, SwitchField, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, type TextareaProps, Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, buttonVariants, createBrowserBooleanStateAdapter, createBrowserDataTableUrlStateAdapter, createDataTableRequestManager, createDataTableUrlStateAdapter, matchNavigationPath, parseDataTableUrlState, serializeDataTableUrlState, useDesignSystem };