@onnechat/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1540 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as NucleoFill from 'nucleo-ui-fill-18';
+import { IconProps as IconProps$1 } from 'nucleo-ui-fill-18';
+import * as React$1 from 'react';
+import React__default, { SVGProps, HTMLAttributes, ReactNode, ComponentProps } from 'react';
+import { motion } from 'motion/react';
+import * as NucleoDuo from 'nucleo-ui-fill-duo-18';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { Separator as Separator$1 } from '@base-ui/react/separator';
+import { Tooltip as Tooltip$1 } from '@base-ui/react/tooltip';
+import { Accordion as Accordion$2 } from '@base-ui/react/accordion';
+import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
+import { ColumnDef, Table as Table$1, Column } from '@tanstack/react-table';
+import * as zustand from 'zustand';
+import { Menu } from '@base-ui/react/menu';
+import { EmojiPicker as EmojiPicker$1 } from 'frimousse';
+import { PreviewCard } from '@base-ui/react/preview-card';
+import { MarqueeProps as MarqueeProps$1 } from 'react-fast-marquee';
+import { Popover as Popover$1 } from '@base-ui/react/popover';
+import { Progress as Progress$1 } from '@base-ui/react/progress';
+import { Radio } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
+import * as _base_ui_react from '@base-ui/react';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { Dialog as Dialog$2 } from '@base-ui/react/dialog';
+import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
+import { ToasterProps } from 'sonner';
+import { MediaController, MediaControlBar, MediaTimeRange, MediaTimeDisplay, MediaVolumeRange, MediaPlayButton, MediaSeekBackwardButton, MediaSeekForwardButton, MediaMuteButton } from 'media-chrome/react';
+import { DayPicker } from 'react-day-picker';
+import * as RechartsPrimitive from 'recharts';
+import { DefaultLegendContentProps, TooltipContentProps } from 'recharts';
+import { Command as Command$1 } from 'cmdk';
+import { Drawer as Drawer$1 } from 'vaul';
+
+declare const BrandIcon: {
+    Stripe: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+};
+type BrandIconProps = {
+    original?: boolean;
+} & SVGProps<SVGSVGElement>;
+
+declare const SocialIcon: {
+    Apple: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    Google: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    WhatsApp: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    Facebook: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    Instagram: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    Messenger: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    LinkedIn: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    X: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    YouTube: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+    Discord: ({ original, ...props }: SVGProps<SVGSVGElement> & {
+        original?: boolean;
+    }) => react_jsx_runtime.JSX.Element;
+};
+type SocialIconProps = {
+    original?: boolean;
+} & SVGProps<SVGSVGElement>;
+
+declare function SidebarToggled(props: React$1.ComponentProps<typeof motion.svg>): react_jsx_runtime.JSX.Element;
+
+declare function SidebarToggle(props: React$1.ComponentProps<typeof motion.svg>): react_jsx_runtime.JSX.Element;
+
+declare const customIcons: {
+    SidebarToggle: typeof SidebarToggle;
+    SidebarToggled: typeof SidebarToggled;
+};
+
+type NucleoExportToName<T extends string, TSuffix extends string> = T extends `Icon${infer Name}${TSuffix}` ? Name : never;
+
+declare const iconVariants: {
+    readonly fill: Record<string, React$1.ComponentType<NucleoFill.IconProps>>;
+    readonly duo: Record<string, React$1.ComponentType<NucleoFill.IconProps>>;
+    readonly brand: {
+        Stripe: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+    };
+    readonly social: {
+        Apple: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        Google: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        WhatsApp: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        Facebook: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        Instagram: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        Messenger: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        LinkedIn: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        X: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        YouTube: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+        Discord: ({ original, ...props }: React$1.SVGProps<SVGSVGElement> & {
+            original?: boolean;
+        }) => react_jsx_runtime.JSX.Element;
+    };
+    readonly custom: {
+        SidebarToggle: typeof SidebarToggle;
+        SidebarToggled: typeof SidebarToggled;
+    };
+};
+type IconVariant = keyof typeof iconVariants;
+type NucleoFillExports = keyof typeof NucleoFill;
+type NucleoDuoExports = keyof typeof NucleoDuo;
+type FillIconName = NucleoExportToName<Extract<NucleoFillExports, `Icon${string}Fill18`>, 'Fill18'>;
+type DuoIconName = NucleoExportToName<Extract<NucleoDuoExports, `Icon${string}FillDuo18`>, 'FillDuo18'>;
+type BrandIconName = keyof typeof BrandIcon;
+type SocialIconName = keyof typeof SocialIcon;
+type CustomIconName = keyof typeof customIcons;
+
+/** @deprecated Use `FillIconName` or variant-specific names */
+type IconType = FillIconName | CustomIconName;
+/** SVG props shared by all icon variants (excludes `name` and `variant`). */
+type IconSharedProps = Omit<IconProps$1, 'name' | 'variant'>;
+type ThemeIcon = FillIconName | CustomIconName | {
+    variant: 'brand';
+    name: BrandIconName;
+};
+type FillVariantProps = {
+    variant?: 'fill';
+    name: FillIconName | CustomIconName;
+} & IconProps$1;
+type DuoVariantProps = {
+    variant: 'duo';
+    name: DuoIconName;
+} & IconProps$1;
+type BrandVariantProps = {
+    variant: 'brand';
+    name: BrandIconName;
+} & BrandIconProps;
+type SocialVariantProps = {
+    variant: 'social';
+    name: SocialIconName;
+} & SocialIconProps;
+type CustomVariantProps = {
+    variant: 'custom';
+    name: CustomIconName;
+} & IconProps$1;
+type IconProps = FillVariantProps | DuoVariantProps | BrandVariantProps | SocialVariantProps | CustomVariantProps;
+declare function resolveThemeIcon(icon: ThemeIcon | IconType): IconProps;
+declare const Icon: (props: IconProps) => react_jsx_runtime.JSX.Element | null;
+
+declare const ANNOUNCEMENT_TYPES: {
+    readonly CRITICAL: "CRITICAL";
+    readonly ERROR: "ERROR";
+    readonly INFO: "INFO";
+    readonly MAINTENANCE: "MAINTENANCE";
+    readonly NEW: "NEW";
+    readonly SALE: "SALE";
+    readonly SUCCESS: "SUCCESS";
+    readonly UPDATE: "UPDATE";
+    readonly WARNING: "WARNING";
+};
+type AnnouncementType = (typeof ANNOUNCEMENT_TYPES)[keyof typeof ANNOUNCEMENT_TYPES];
+type AnnouncementBannerProps = {
+    /** Banner message. The banner is not rendered when empty. */
+    message?: string;
+    /** Semantic type; controls the color pair. Unknown values fall back to `NEW`. */
+    type?: AnnouncementType | (string & NonNullable<unknown>);
+    /** Chip label shown before the message on desktop. Defaults to the type itself — pass a translated label if needed. */
+    typeLabel?: string;
+    /** Hides the close button when `false`. */
+    dismissible?: boolean;
+    /** Called when the user dismisses the banner. */
+    onDismiss?: () => void;
+    /** Optional `id` for the close button (e.g. an analytics id). */
+    closeButtonId?: string;
+    className?: string;
+};
+/**
+ * Fixed top banner for product announcements. Sets the global
+ * `--announcement-height` CSS variable (used by `AppShell` to offset the
+ * viewport height) and auto-marquees messages that overflow the available
+ * width.
+ */
+declare function AnnouncementBanner({ message, type, typeLabel, dismissible, onDismiss, closeButtonId, className, }: AnnouncementBannerProps): react_jsx_runtime.JSX.Element | null;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "success" | "destructive" | "outline" | "primary" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon-sm" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InternalVariantProps = VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+    isLoading?: boolean;
+};
+type ButtonVariants = InternalVariantProps['variant'];
+declare const Button: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<(props?: ({
+    variant?: "default" | "link" | "success" | "destructive" | "outline" | "primary" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon-sm" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+    isLoading?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+type InputProps = React$1.ComponentProps<'input'>;
+declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare function Separator({ className, orientation, ...props }: Separator$1.Props): react_jsx_runtime.JSX.Element;
+
+declare function TooltipProvider({ delay, timeout, ...props }: Tooltip$1.Provider.Props): react_jsx_runtime.JSX.Element;
+declare function TooltipRoot({ ...props }: Tooltip$1.Root.Props): react_jsx_runtime.JSX.Element;
+declare function TooltipTrigger({ onClick, asChild, children, ...props }: Tooltip$1.Trigger.Props & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function TooltipContent({ className, side, align, sideOffset, children, ...props }: Omit<Tooltip$1.Popup.Props, 'className'> & Pick<Tooltip$1.Positioner.Props, 'side' | 'align' | 'sideOffset'> & {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const Tooltip: typeof TooltipRoot & {
+    Provider: typeof TooltipProvider;
+    Content: typeof TooltipContent;
+    Trigger: typeof TooltipTrigger;
+};
+
+declare const SIDEBAR_WIDTH = "18rem";
+type SidebarContextProps = {
+    state: 'expanded' | 'collapsed';
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+    sidebarWidth: string;
+    setSidebarWidth: (width: string) => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React$1.ComponentProps<'div'> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarRoot({ side, variant, collapsible, className, children, ...props }: React$1.ComponentProps<'div'> & {
+    side?: 'left' | 'right';
+    variant?: 'sidebar' | 'floating' | 'inset';
+    collapsible?: 'offcanvas' | 'icon' | 'none';
+}): react_jsx_runtime.JSX.Element;
+type SidebarTriggerIconProps = IconSharedProps;
+declare function SidebarTrigger({ className, onClick, isOutsideSidebar, iconProps, ...props }: React$1.ComponentProps<typeof Button> & {
+    isOutsideSidebar?: boolean;
+    iconProps?: SidebarTriggerIconProps;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarRail({ className, ...props }: React$1.ComponentProps<'button'>): react_jsx_runtime.JSX.Element;
+declare function SidebarInset({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarInput({ className, ...props }: React$1.ComponentProps<typeof Input>): react_jsx_runtime.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
+declare function SidebarContent({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React$1.ComponentProps<'div'> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React$1.ComponentProps<'button'> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React$1.ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React$1.ComponentProps<'button'> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React$1.ComponentProps<typeof Tooltip.Content>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React$1.ComponentProps<'button'> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React$1.ComponentProps<'div'> & {
+    showIcon?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React$1.ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React$1.ComponentProps<'a'> & {
+    asChild?: boolean;
+    size?: 'sm' | 'md';
+    isActive?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare const Sidebar: typeof SidebarRoot & {
+    Provider: typeof SidebarProvider;
+    Content: typeof SidebarContent;
+    Footer: typeof SidebarFooter;
+    Group: typeof SidebarGroup;
+    GroupAction: typeof SidebarGroupAction;
+    GroupContent: typeof SidebarGroupContent;
+    GroupLabel: typeof SidebarGroupLabel;
+    Header: typeof SidebarHeader;
+    Input: typeof SidebarInput;
+    Inset: typeof SidebarInset;
+    Menu: typeof SidebarMenu;
+    MenuAction: typeof SidebarMenuAction;
+    MenuBadge: typeof SidebarMenuBadge;
+    MenuButton: typeof SidebarMenuButton;
+    MenuItem: typeof SidebarMenuItem;
+    MenuSkeleton: typeof SidebarMenuSkeleton;
+    MenuSub: typeof SidebarMenuSub;
+    MenuSubButton: typeof SidebarMenuSubButton;
+    MenuSubItem: typeof SidebarMenuSubItem;
+    Rail: typeof SidebarRail;
+    Separator: typeof SidebarSeparator;
+    Trigger: typeof SidebarTrigger;
+};
+
+/**
+ * Application shell layout, composition-first. Encodes the structure of our
+ * dashboards — inset resizable sidebar, glass sticky header, floating mobile
+ * navbar, announcement-aware viewport — while leaving every region up to the
+ * consumer:
+ *
+ * ```tsx
+ * <AnnouncementBanner message="…" type="NEW" />
+ *
+ * <AppShell>
+ *   <AppShell.Sidebar>
+ *     <AppShell.SidebarHeader>…logo + actions…</AppShell.SidebarHeader>
+ *     <AppShell.SidebarSection>…workspace switcher…</AppShell.SidebarSection>
+ *     <AppShell.SidebarSection>
+ *       <AppShell.CommandButton>Pesquisar…</AppShell.CommandButton>
+ *     </AppShell.SidebarSection>
+ *     <AppShell.SidebarContent>
+ *       <AppShell.SidebarGroup title="Geral">
+ *         <AppShell.SidebarItem icon="House6" title="Visão Geral" href="/" active />
+ *       </AppShell.SidebarGroup>
+ *     </AppShell.SidebarContent>
+ *     <AppShell.SidebarFooter>…copyright + user…</AppShell.SidebarFooter>
+ *   </AppShell.Sidebar>
+ *
+ *   <AppShell.Navbar>…mobile items…</AppShell.Navbar>
+ *
+ *   <AppShell.Inset>
+ *     <AppShell.Header title={…} actions={…} user={…} logo={…} />
+ *     <MyPage />
+ *   </AppShell.Inset>
+ * </AppShell>
+ * ```
+ */
+declare function AppShellRoot({ className, children, ...props }: React$1.ComponentProps<typeof Sidebar.Provider>): react_jsx_runtime.JSX.Element;
+/**
+ * Inset sidebar with a drag-to-resize rail: click toggles, double click
+ * resets to the default width, dragging resizes between 16–20rem and
+ * collapses past the threshold. Width persists in the `sidebar-width` cookie
+ * (read back by `Sidebar.Provider`).
+ */
+declare function AppShellSidebar({ children, ...props }: React$1.ComponentProps<typeof Sidebar>): react_jsx_runtime.JSX.Element;
+declare function AppShellSidebarHeader({ className, children, ...props }: React$1.ComponentProps<typeof Sidebar.Header>): react_jsx_runtime.JSX.Element;
+declare function AppShellSidebarSection({ className, children, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AppShellSidebarContent({ className, children, ...props }: React$1.ComponentProps<typeof Sidebar.Content>): react_jsx_runtime.JSX.Element;
+declare function AppShellSidebarGroup({ className, title, children, ...props }: React$1.ComponentProps<typeof Sidebar.Group> & {
+    title?: string;
+}): react_jsx_runtime.JSX.Element;
+type AppShellSidebarItemData = {
+    title: string;
+    icon?: IconType | React$1.ReactNode;
+    href?: string;
+    onClick?: () => void;
+    /** Marks the item as the current route. The shell has no router — compute it in the app. */
+    active?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    /** "Coming soon" — disabled with a clock hint. */
+    soon?: boolean;
+    /** External link — opens in a new tab with a hint icon. */
+    external?: boolean;
+    items?: AppShellSidebarItemData[];
+};
+type AppShellSidebarItemProps = AppShellSidebarItemData & {
+    index?: number;
+    isDropdownChild?: boolean;
+    level?: number;
+};
+declare function AppShellSidebarItem({ index, isDropdownChild, level, ...item }: AppShellSidebarItemProps): react_jsx_runtime.JSX.Element;
+declare function AppShellCommandButton({ className, children, ...props }: React$1.ComponentProps<'button'>): react_jsx_runtime.JSX.Element;
+declare function AppShellSidebarFooter({ className, children, ...props }: React$1.ComponentProps<typeof Sidebar.Footer>): react_jsx_runtime.JSX.Element;
+declare function AppShellCopyright({ className, children, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function AppShellHeader({ className, logo, title, actions, user, sidebarToggleLabel, mobileActionsClassName, ...props }: Omit<React$1.ComponentProps<'div'>, 'title'> & {
+    /** Mobile-only logo slot (top-left). */
+    logo?: React$1.ReactNode;
+    /** Page title area (both breakpoints). */
+    title?: React$1.ReactNode;
+    /** Right-side actions (both breakpoints). */
+    actions?: React$1.ReactNode;
+    /** Mobile-only user slot (top-right, e.g. avatar). */
+    user?: React$1.ReactNode;
+    sidebarToggleLabel?: string;
+    mobileActionsClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function AppShellNavbar({ className, children, ...props }: React$1.ComponentProps<'nav'>): react_jsx_runtime.JSX.Element;
+declare function AppShellNavbarItem({ className, icon, active, href, children, ...props }: Omit<React$1.ComponentProps<'a'>, 'children'> & {
+    icon?: IconType | React$1.ReactNode;
+    active?: boolean;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+type AppShellRightSidebarContextValue = {
+    state: 'expanded' | 'collapsed';
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    toggleSidebar: () => void;
+    sidebarWidth: string;
+    setSidebarWidth: (width: string) => void;
+};
+declare function useAppShellRightSidebar(): AppShellRightSidebarContextValue;
+/**
+ * State container for the right context sidebar. Wrap the `AppShell` with it
+ * whenever a page renders `AppShell.RightSidebar`; open state and width
+ * persist in cookies and `]` toggles it.
+ */
+declare function AppShellRightSidebarProvider({ children, defaultOpen, }: {
+    children: React$1.ReactNode;
+    defaultOpen?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function AppShellRightSidebarTrigger({ className, label, ...props }: React$1.ComponentProps<typeof Button> & {
+    label?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Fixed right context panel with drag-to-resize on its left edge, matching
+ * the left sidebar behavior (click toggles, double click resets, drag past
+ * the threshold collapses). Requires `AppShell.RightSidebarProvider`.
+ */
+declare function AppShellRightSidebar({ className, children, ...props }: React$1.ComponentProps<'aside'>): react_jsx_runtime.JSX.Element;
+declare function AppShellInset({ className, style, children, loading, spacing, ...props }: React$1.ComponentProps<'div'> & {
+    /**
+     * Shows a blocking loading overlay while keeping the shell (sidebar,
+     * navbar) interactive. Content stays mounted but hidden.
+     */
+    loading?: boolean;
+    /** Spacing scale unit for `--calculated-spacing` (bottom paddings, widget offsets). */
+    spacing?: number;
+}): react_jsx_runtime.JSX.Element;
+declare function AppShellLoading({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare const AppShell: typeof AppShellRoot & {
+    Sidebar: typeof AppShellSidebar;
+    SidebarHeader: typeof AppShellSidebarHeader;
+    SidebarSection: typeof AppShellSidebarSection;
+    SidebarContent: typeof AppShellSidebarContent;
+    SidebarGroup: typeof AppShellSidebarGroup;
+    SidebarItem: typeof AppShellSidebarItem;
+    SidebarFooter: typeof AppShellSidebarFooter;
+    CommandButton: typeof AppShellCommandButton;
+    Copyright: typeof AppShellCopyright;
+    Header: typeof AppShellHeader;
+    Navbar: typeof AppShellNavbar;
+    NavbarItem: typeof AppShellNavbarItem;
+    Inset: typeof AppShellInset;
+    Loading: typeof AppShellLoading;
+    RightSidebar: typeof AppShellRightSidebar;
+    RightSidebarProvider: typeof AppShellRightSidebarProvider;
+    RightSidebarTrigger: typeof AppShellRightSidebarTrigger;
+};
+
+type AccordionProps = Omit<Accordion$2.Root.Props, 'value' | 'defaultValue' | 'onValueChange' | 'multiple'> & {
+    /** Radix-compatible API: 'single' keeps at most one item open. */
+    type?: 'single' | 'multiple';
+    /** Kept for Radix API compatibility; Base UI single accordions are always collapsible. */
+    collapsible?: boolean;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    /** Receives a `string` when `type="single"` and a `string[]` when `type="multiple"`. */
+    onValueChange?: (value: string & string[]) => void;
+};
+declare function Accordion$1({ type, collapsible: _collapsible, value, defaultValue, onValueChange, ...props }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ className, ...props }: Accordion$2.Item.Props): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: Accordion$2.Trigger.Props): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ className, children, ...props }: Accordion$2.Panel.Props): react_jsx_runtime.JSX.Element;
+
+declare function AccordionRoot({ className, ...props }: React$1.ComponentProps<typeof Accordion$1>): react_jsx_runtime.JSX.Element;
+declare namespace AccordionRoot {
+    var displayName: string;
+}
+declare function AccordionItemExtended({ className, ...props }: React$1.ComponentProps<typeof AccordionItem>): react_jsx_runtime.JSX.Element;
+declare namespace AccordionItemExtended {
+    var displayName: string;
+}
+declare function AccordionTriggerExtended({ className, ...props }: React$1.ComponentProps<typeof AccordionTrigger>): react_jsx_runtime.JSX.Element;
+declare namespace AccordionTriggerExtended {
+    var displayName: string;
+}
+declare function AccordionContentExtended({ className, ...props }: React$1.ComponentProps<typeof AccordionContent>): react_jsx_runtime.JSX.Element;
+declare namespace AccordionContentExtended {
+    var displayName: string;
+}
+declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItemExtended;
+    Trigger: typeof AccordionTriggerExtended;
+    Content: typeof AccordionContentExtended;
+};
+
+type ComponentVariant = 'primary' | 'secondary' | 'tertiary' | 'destructive' | 'warning' | 'success' | 'ghost' | 'link' | 'outline' | 'default';
+
+type ActionItem = {
+    label: string;
+    icon?: IconType;
+    href?: string;
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    disabled?: boolean;
+    className?: string;
+    variant?: ComponentVariant;
+};
+type ActionGroupAlign = 'start' | 'center' | 'end';
+declare function ActionGroup({ items, disabled, children, className, align, }: {
+    items?: ActionItem[][];
+    disabled?: boolean;
+    className?: string;
+    children?: React__default.ReactNode;
+    align?: ActionGroupAlign;
+}): react_jsx_runtime.JSX.Element;
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "info" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function AlertRoot({ className, variant, ...props }: React$1.ComponentProps<'div'> & VariantProps<typeof alertVariants>): react_jsx_runtime.JSX.Element;
+declare function AlertTitle({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare const Alert: typeof AlertRoot & {
+    Title: typeof AlertTitle;
+    Description: typeof AlertDescription;
+};
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const BrandDomainInput: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React__default.RefAttributes<HTMLInputElement>>;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    className?: string;
+    hideBackButton?: boolean;
+    disableLinks?: boolean;
+}
+declare function Breadcrumb({ items, className, hideBackButton, disableLinks }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+interface CardSliderProps extends React__default.ComponentProps<'div'> {
+    /** Zero-based index of the visible panel */
+    index: number;
+    /** Duration in ms (ignored when `prefers-reduced-motion: reduce`) */
+    transitionDurationMs?: number;
+}
+/**
+ * Horizontal slide between step panels inside a card (viewport + flex track).
+ * Each direct child is one full-width step.
+ */
+declare function CardSlider({ index, className, children, transitionDurationMs, ...props }: CardSliderProps): react_jsx_runtime.JSX.Element | null;
+interface CardProps extends React__default.ComponentProps<'div'> {
+    className?: string;
+}
+declare function CardRoot({ className, children, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+interface CardHeaderProps extends React__default.ComponentProps<'div'> {
+    className?: string;
+}
+declare function CardHeader({ className, children, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+interface CardContentProps extends React__default.ComponentProps<'div'> {
+    className?: string;
+}
+declare function CardContent({ className, children, ...props }: CardContentProps): react_jsx_runtime.JSX.Element;
+interface CardFooterProps extends React__default.ComponentProps<'div'> {
+    className?: string;
+}
+declare function CardFooter({ className, children, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
+declare const Card: typeof CardRoot & {
+    Header: typeof CardHeader;
+    Content: typeof CardContent;
+    Footer: typeof CardFooter;
+    Slider: typeof CardSlider;
+};
+
+type ChatMessage = {
+    role: 'user' | 'assistant';
+    content: string;
+};
+
+declare const ChatPreview: ({ messages, className, }: {
+    messages: ChatMessage[];
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+type CheckboxProps = Checkbox$1.Root.Props & {
+    indeterminate?: boolean;
+};
+declare function Checkbox({ className, indeterminate, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+declare const DATA_CUSTOM_TABLE_VARIANTS: readonly ["default", "inset"];
+declare const DEFAULT_DATA_CUSTOM_TABLE_VARIANT = "default";
+type DataCustomTableVariant = (typeof DATA_CUSTOM_TABLE_VARIANTS)[number];
+interface CursorPaginationMeta$2 {
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+    limit?: number;
+    nextCursor?: string;
+    previousCursor?: string;
+}
+type DataCustomTableProps<T> = {
+    isLoading: boolean;
+    data: T[];
+    columns: ColumnDef<T>[];
+    totalItems?: number;
+    variant?: DataCustomTableVariant;
+    pageSizeOptions?: number[];
+    cursorMeta?: CursorPaginationMeta$2;
+    onPaginationChange?: (page: number, limit: number, cursor?: string | null, direction?: 'next' | 'previous') => void;
+    onRowSelectionChange?: (selectedRows: T[]) => void;
+    rowSelection?: Record<string, boolean>;
+    onRowSelectionStateChange?: (rowSelection: Record<string, boolean>) => void;
+    emptyMessage?: string;
+    showIndexCol?: boolean;
+    showCheckboxCol?: boolean;
+    showPagination?: boolean;
+};
+declare function DataCustomTable<T>({ isLoading, data, columns, totalItems, variant, pageSizeOptions, cursorMeta, onPaginationChange, onRowSelectionChange, rowSelection, onRowSelectionStateChange, emptyMessage, showIndexCol, showCheckboxCol, showPagination, }: DataCustomTableProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace DataCustomTable {
+    var displayName: string;
+}
+
+interface SafariProps extends HTMLAttributes<HTMLDivElement> {
+    url: string;
+    children?: React.ReactNode;
+}
+declare function Safari({ url, children }: SafariProps): react_jsx_runtime.JSX.Element;
+
+declare const Devices: {
+    Safari: typeof Safari;
+};
+
+declare const useDialog: zustand.UseBoundStore<zustand.StoreApi<DialogStore>>;
+interface DialogStore {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+interface DialogStackContextType {
+    activeIndex: number;
+    register: (id: string, order?: number) => number;
+    unregister: (id: string) => void;
+    goTo: (index: number) => void;
+    next: () => void;
+    back: () => void;
+    total: number;
+}
+declare const useDialogStack: () => DialogStackContextType;
+declare function DialogStack({ children, defaultIndex, onIndexChange, }: {
+    children: React__default.ReactNode;
+    defaultIndex?: number;
+    onIndexChange?: (index: number) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function Dialog$1({ title, description, actions: actionsProp, isOpen, onOpenChange, style, className, overlay, children, order, removeOverlay, notRelative, showDescription, classNames, hideMobileFooterClose, }: {
+    title?: string | React__default.ReactNode;
+    description?: string;
+    actions?: {
+        className?: string;
+        variant?: ButtonVariants;
+        label: string;
+        onClick: () => void;
+        disabled?: boolean;
+        isLoading?: boolean;
+    }[] | null | undefined;
+    className?: string;
+    children: React__default.ReactNode;
+    isOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    style?: React__default.CSSProperties;
+    overlay?: boolean;
+    order?: number;
+    offset?: number;
+    removeOverlay?: boolean;
+    notRelative?: boolean;
+    showDescription?: boolean;
+    /** Mobile: do not prepend the default “Close” button next to `actions` (header X still closes). */
+    hideMobileFooterClose?: boolean;
+    classNames?: {
+        container?: string;
+        content?: string;
+        header?: string;
+        description?: string;
+        footer?: string;
+    };
+}): react_jsx_runtime.JSX.Element;
+
+declare const KeyboardShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type DropdownMenuProps = Omit<Menu.Root.Props, 'onOpenChange'> & {
+    onOpenChange?: (open: boolean) => void;
+};
+declare function DropdownMenuRoot({ open, onOpenChange, defaultOpen, children, ...props }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ children, ...props }: Menu.Portal.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ className, asChild, children, ...props }: Menu.Trigger.Props & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, align, side, children, ...props }: Menu.Positioner.Props & {
+    sideOffset?: number;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ children, ...props }: Menu.Group.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, resetClassName, asChild, children, ...props }: Menu.Item.Props & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+    resetClassName?: boolean;
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, onCheckedChange, ...props }: Menu.CheckboxItem.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ children, ...props }: Menu.RadioGroup.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: Menu.RadioItem.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: Menu.GroupLabel.Props & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: Menu.Separator.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<typeof KeyboardShortcut>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSub({ children, ...props }: Menu.SubmenuRoot.Props): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: Menu.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, sideOffset, alignOffset, children, }: {
+    className?: string;
+    sideOffset?: number;
+    alignOffset?: number;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function DropdownMenuArrow({ className, ...props }: Menu.Arrow.Props): react_jsx_runtime.JSX.Element;
+declare const DropdownMenu: typeof DropdownMenuRoot & {
+    Arrow: typeof DropdownMenuArrow;
+    CheckboxItem: typeof DropdownMenuCheckboxItem;
+    Content: typeof DropdownMenuContent;
+    Group: typeof DropdownMenuGroup;
+    Item: typeof DropdownMenuItem;
+    Label: typeof DropdownMenuLabel;
+    Portal: typeof DropdownMenuPortal;
+    RadioGroup: typeof DropdownMenuRadioGroup;
+    RadioItem: typeof DropdownMenuRadioItem;
+    Separator: typeof DropdownMenuSeparator;
+    Shortcut: typeof DropdownMenuShortcut;
+    Sub: typeof DropdownMenuSub;
+    SubContent: typeof DropdownMenuSubContent;
+    SubTrigger: typeof DropdownMenuSubTrigger;
+    Trigger: typeof DropdownMenuTrigger;
+};
+
+declare function EmojiPickerRoot({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.Root>): react_jsx_runtime.JSX.Element;
+/**
+ * Opt-in category strip. Add it inside `EmojiPicker` (e.g. below `Search`) to
+ * jump between category sections; it also highlights the section in view.
+ */
+declare function EmojiPickerCategorySelector({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerSearch({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.Search>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerViewport({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.Viewport>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerLoading({ className, children, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.Loading>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerEmpty({ className, children, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.Empty>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerList({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.List>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerSkinToneSelector({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.SkinToneSelector>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerFooter({ className, children, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function EmojiPickerActiveEmoji({ className, ...props }: React$1.ComponentProps<typeof EmojiPicker$1.ActiveEmoji> & {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const EmojiPicker: typeof EmojiPickerRoot & {
+    Search: typeof EmojiPickerSearch;
+    CategorySelector: typeof EmojiPickerCategorySelector;
+    Viewport: typeof EmojiPickerViewport;
+    Loading: typeof EmojiPickerLoading;
+    Empty: typeof EmojiPickerEmpty;
+    List: typeof EmojiPickerList;
+    SkinToneSelector: typeof EmojiPickerSkinToneSelector;
+    Footer: typeof EmojiPickerFooter;
+    ActiveEmoji: typeof EmojiPickerActiveEmoji;
+};
+
+declare function EmptyState({ icon, title, description, children, variant, className, }: {
+    icon?: IconType;
+    title?: string;
+    description?: string;
+    children?: React.ReactNode;
+    variant?: 'default' | 'embedded' | 'flat';
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function HoverCardRoot({ ...props }: PreviewCard.Root.Props): react_jsx_runtime.JSX.Element;
+declare function HoverCardTrigger({ ...props }: PreviewCard.Trigger.Props): react_jsx_runtime.JSX.Element;
+type HoverCardContentProps = PreviewCard.Popup.Props & Pick<PreviewCard.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset'>;
+declare function HoverCardContent({ className, side, sideOffset, align, alignOffset, ...props }: HoverCardContentProps): react_jsx_runtime.JSX.Element;
+declare const HoverCard: typeof HoverCardRoot & {
+    Trigger: typeof HoverCardTrigger;
+    Content: typeof HoverCardContent;
+};
+
+type InputGroupProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare function InputGroupRoot({ className, ...props }: InputGroupProps): react_jsx_runtime.JSX.Element;
+type InputGroupInputProps = React$1.ComponentProps<'input'>;
+declare function InputGroupInput({ className, ...props }: InputGroupInputProps): react_jsx_runtime.JSX.Element;
+declare namespace InputGroupInput {
+    var displayName: string;
+}
+type InputGroupAddonProps = React$1.HTMLAttributes<HTMLDivElement> & {
+    align?: 'inline-start' | 'inline-end';
+};
+declare function InputGroupAddon({ align, className, ...props }: InputGroupAddonProps): react_jsx_runtime.JSX.Element;
+declare namespace InputGroupAddon {
+    var displayName: string;
+}
+type InputGroupTextProps = React$1.HTMLAttributes<HTMLSpanElement>;
+declare function InputGroupText({ className, ...props }: InputGroupTextProps): react_jsx_runtime.JSX.Element;
+declare namespace InputGroupText {
+    var displayName: string;
+}
+declare const InputGroup: typeof InputGroupRoot & {
+    Input: typeof InputGroupInput;
+    Addon: typeof InputGroupAddon;
+    Text: typeof InputGroupText;
+};
+
+type Currency = {
+    code: string;
+    symbol: string;
+};
+
+interface CurrencyInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    value?: number;
+    locale?: string;
+    allowZero?: boolean;
+    defaultCurrency?: string;
+    disableCurrencySelect?: boolean;
+    centsMode?: boolean;
+    onChange?: (value: number) => void;
+    onCurrencyChange?: (currency: Currency) => void;
+    align?: 'start' | 'center' | 'end';
+}
+declare const CurrencyInput: React$1.ForwardRefExoticComponent<CurrencyInputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface Country {
+    code: string;
+    name: string;
+    flag: string;
+    dialCode: string;
+}
+
+interface PhoneInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    value?: string;
+    onChange?: (value: string) => void;
+    onCountryChange?: (country: Country) => void;
+    disableCountrySelect?: boolean;
+    locale?: string;
+    align?: 'start' | 'center' | 'end';
+}
+declare const PhoneInput: React$1.ForwardRefExoticComponent<PhoneInputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+type InputTimeType = 'date' | 'time' | 'datetime-local';
+interface InputTimeProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange'> {
+    type?: InputTimeType;
+    defaultType?: InputTimeType;
+    onTypeChange?: (type: InputTimeType) => void;
+    onChange?: (e: React$1.ChangeEvent<HTMLInputElement>) => void;
+    align?: 'start' | 'center' | 'end';
+}
+declare function InputTime({ type: typeProp, defaultType, onTypeChange, className, placeholder, align, ...props }: InputTimeProps): react_jsx_runtime.JSX.Element;
+declare namespace InputTime {
+    var displayName: string;
+}
+
+interface InputTimePickerProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** The currently selected date. When `undefined`, both selects start empty. */
+    date: Date | undefined;
+    /**
+     * Callback invoked with a new `Date` whenever the hour or minute changes.
+     * Only the respective unit is mutated; seconds and milliseconds are preserved.
+     */
+    setDate: (date: Date | undefined) => void;
+    /** When `true`, both hour and minute Selects are disabled. */
+    disabled?: boolean;
+    /** Placeholder shown in the hour Select when no value is picked. Defaults to `"HH"`. */
+    hourPlaceholder?: string;
+    /** Placeholder shown in the minute Select when no value is picked. Defaults to `"MM"`. */
+    minutePlaceholder?: string;
+    /** `aria-label` for the hour Select trigger. Defaults to `"Hours"`. */
+    hourAriaLabel?: string;
+    /** `aria-label` for the minute Select trigger. Defaults to `"Minutes"`. */
+    minuteAriaLabel?: string;
+}
+/**
+ * Controlled hour:minute picker composed of two {@link Select} dropdowns.
+ *
+ * Displays a single-row selector with hours (00–23) on the left,
+ * a colon separator, and minutes (00–59) on the right.
+ *
+ * When {@link InputTimePickerProps.date} is `undefined`, both selects start empty with
+ * English placeholders (`HH` / `MM`). Picking a value creates or mutates a `Date`
+ * and passes it to {@link InputTimePickerProps.setDate}.
+ *
+ * @example
+ * const [date, setDate] = useState<Date>();
+ * <InputTimePicker date={date} setDate={setDate} />
+ *
+ * @example
+ * <InputTimePicker
+ *   date={date}
+ *   setDate={setDate}
+ *   hourPlaceholder="Hora"
+ *   minutePlaceholder="Minuto"
+ *   hourAriaLabel="Horas"
+ *   minuteAriaLabel="Minutos"
+ * />
+ */
+declare const InputTimePicker: React$1.ForwardRefExoticComponent<InputTimePickerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type TimeUnit = 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+interface TimeUnitLabel {
+    /** Abbreviated label shown in the Select trigger. */
+    short: string;
+    /** Full label shown in the Select dropdown. */
+    label: string;
+}
+interface TimeUnitOption {
+    /** Unit identifier used in the Select value. */
+    value: TimeUnit;
+    /** Number of minutes in one unit of this type. */
+    toMinutes: number;
+}
+/**
+ * All supported time units with their minute-conversion factors.
+ *
+ * Months are approximated as 30 days and years as 365 days.
+ */
+declare const TIME_UNITS: TimeUnitOption[];
+interface InputTimeUnitProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    /** Current value in **minutes**. Drives the input display via unit conversion. */
+    value?: number;
+    /** Unit selected by default when the user has not manually picked one. */
+    defaultUnit?: TimeUnit;
+    /** When `true`, the unit Select is disabled — only the numeric input is editable. */
+    disableUnitSelect?: boolean;
+    /** Restrict which units appear in the dropdown. An empty or omitted array shows all units. */
+    allowedUnits?: TimeUnit[];
+    /**
+     * Called with the total value in **minutes**.
+     * Receives `undefined` when the input is empty or invalid.
+     */
+    onChange?: (valueInMinutes: number | undefined) => void;
+    /** Called whenever the user picks a different unit. */
+    onUnitChange?: (unit: TimeUnit) => void;
+    /** Alignment of the unit dropdown relative to the trigger. */
+    align?: 'start' | 'center' | 'end';
+    /** Extra classes for the outermost wrapper div. */
+    containerClassName?: string;
+    /**
+     * Override labels for specific time units. Merged with English defaults.
+     * Only the units you provide will be overridden; the rest keep their defaults.
+     *
+     * @example
+     * labels={{ hours: { short: 'hrs', label: 'Horas' } }}
+     */
+    labels?: Partial<Record<TimeUnit, Partial<TimeUnitLabel>>>;
+}
+/**
+ * Numeric input paired with a time-unit Select.
+ *
+ * Accepts and emits values in **minutes**, converting the displayed number
+ * based on the selected unit (seconds, minutes, hours, days, weeks, months, years).
+ *
+ * On the left, an {@link Input} for the numeric quantity (digits and decimal dots only).
+ * On the right, a {@link Select} for the time unit, showing a short abbreviation
+ * with English defaults (`s`, `m`, `h`, `d`, `w`, `mo`, `y`).
+ *
+ * When the user picks a different unit, the displayed value is re-computed
+ * so the underlying minute value stays constant — only the representation changes.
+ *
+ * @example
+ * // Basic usage: pick a duration
+ * <InputTimeUnit
+ *   value={5}
+ *   onChange={(minutes) => console.log(minutes)}
+ * />
+ *
+ * @example
+ * // Restrict to hours and days only, with custom labels
+ * <InputTimeUnit
+ *   allowedUnits={['hours', 'days']}
+ *   defaultUnit="hours"
+ *   labels={{ hours: { short: 'hrs' }, days: { short: 'dias' } }}
+ * />
+ */
+declare const InputTimeUnit: React$1.ForwardRefExoticComponent<InputTimeUnitProps & React$1.RefAttributes<HTMLInputElement>>;
+
+type KbdKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Enter' | 'Escape' | 'Tab' | 'Backspace' | 'Delete' | 'Space' | 'Mod' | 'Command' | 'Meta' | 'Super' | 'Control' | 'Ctrl' | 'Shift' | 'Alt' | 'Option' | 'F1' | 'F2' | 'F3' | 'F4' | 'F5' | 'F6' | 'F7' | 'F8' | 'F9' | 'F10' | 'F11' | 'F12' | (string & NonNullable<unknown>);
+type KbdProps = {
+    keys: KbdKey | KbdKey[] | KbdKey[][];
+    className?: string;
+    separator?: ReactNode;
+    thenSeparator?: ReactNode;
+};
+declare function Kbd({ keys, className, separator, thenSeparator, }: KbdProps): react_jsx_runtime.JSX.Element | null;
+
+declare const LanguageSwitch: React__default.FC;
+
+declare function Loader({ text, variant, className, iconClassName, }: {
+    text?: string;
+    variant?: 'default' | 'screen' | 'center' | 'button' | 'clean';
+    className?: string;
+    iconClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare const OnneLogo: ({ variant, className, }: {
+    variant?: "default" | "icon" | "text";
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const OnnebookLogo: ({ variant, classNames, className, style, }: {
+    variant?: "default" | "icon" | "text";
+    name?: string;
+    className?: string;
+    classNames?: {
+        icon?: {
+            container?: string;
+            path?: string;
+        };
+        text?: string;
+    };
+    style?: React.CSSProperties;
+}) => react_jsx_runtime.JSX.Element;
+
+type MarqueeProps = HTMLAttributes<HTMLDivElement>;
+declare const Marquee: ({ className, ...props }: MarqueeProps) => react_jsx_runtime.JSX.Element;
+type MarqueeContentProps = MarqueeProps$1;
+declare const MarqueeContent: ({ loop, autoFill, pauseOnHover, ...props }: MarqueeContentProps) => react_jsx_runtime.JSX.Element;
+type MarqueeFadeProps = HTMLAttributes<HTMLDivElement> & {
+    side: 'left' | 'right';
+};
+declare const MarqueeFade: ({ className, side, ...props }: MarqueeFadeProps) => react_jsx_runtime.JSX.Element;
+type MarqueeItemProps = HTMLAttributes<HTMLDivElement | HTMLAnchorElement> & {
+    href?: string;
+};
+declare const MarqueeItem: ({ href, className, ...props }: MarqueeItemProps) => react_jsx_runtime.JSX.Element;
+
+declare function NetworkStatus(): react_jsx_runtime.JSX.Element;
+
+declare function PopoverRoot({ children, ...props }: Popover$1.Root.Props): react_jsx_runtime.JSX.Element;
+declare function PopoverTrigger({ asChild, children, ...props }: Popover$1.Trigger.Props & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function PopoverContent({ className, align, side, sideOffset, alignOffset, showArrow, children, ...props }: Popover$1.Popup.Props & Pick<Popover$1.Positioner.Props, 'align' | 'side' | 'sideOffset' | 'alignOffset'> & {
+    showArrow?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function PopoverAnchor({ children, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare const Popover: typeof PopoverRoot & {
+    Trigger: typeof PopoverTrigger;
+    Content: typeof PopoverContent;
+    Anchor: typeof PopoverAnchor;
+};
+
+declare function ProgressRoot({ className, children, value, ...props }: Progress$1.Root.Props): react_jsx_runtime.JSX.Element;
+declare function ProgressTrack({ className, ...props }: Progress$1.Track.Props): react_jsx_runtime.JSX.Element;
+declare function ProgressIndicator({ className, ...props }: Progress$1.Indicator.Props): react_jsx_runtime.JSX.Element;
+declare function ProgressLabel({ className, ...props }: Progress$1.Label.Props): react_jsx_runtime.JSX.Element;
+declare function ProgressValue({ className, ...props }: Progress$1.Value.Props): react_jsx_runtime.JSX.Element;
+declare const Progress: typeof ProgressRoot & {
+    Track: typeof ProgressTrack;
+    Indicator: typeof ProgressIndicator;
+    Label: typeof ProgressLabel;
+    Value: typeof ProgressValue;
+};
+
+declare function RadioGroupRoot({ className, ...props }: RadioGroup$1.Props): react_jsx_runtime.JSX.Element;
+declare function RadioGroupItem({ className, ...props }: Radio.Root.Props): react_jsx_runtime.JSX.Element;
+declare const RadioGroup: typeof RadioGroupRoot & {
+    Item: typeof RadioGroupItem;
+};
+
+declare function SelectRoot({ value: valueProp, defaultValue, onValueChange: onValueChangeProp, open: openProp, onOpenChange: onOpenChangeProp, defaultOpen, children, ...props }: Omit<Select$1.Root.Props<string>, 'value' | 'defaultValue' | 'onValueChange' | 'onOpenChange'> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function SelectGroup({ ...props }: Select$1.Group.Props): react_jsx_runtime.JSX.Element;
+declare function SelectValue({ className, placeholder, children, ...props }: Select$1.Value.Props): react_jsx_runtime.JSX.Element;
+declare function SelectContent({ className, children, position, side, align, sideOffset, ...props }: Select$1.Popup.Props & Pick<Select$1.Positioner.Props, 'side' | 'align' | 'sideOffset'> & {
+    position?: 'popper' | 'item-aligned';
+}): react_jsx_runtime.JSX.Element;
+declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): react_jsx_runtime.JSX.Element;
+declare function SelectItem({ className, children, value, ...props }: Select$1.Item.Props): react_jsx_runtime.JSX.Element | null;
+declare function SelectSeparator({ className, ...props }: Separator$1.Props): react_jsx_runtime.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: Select$1.ScrollUpArrow.Props): react_jsx_runtime.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: Select$1.ScrollDownArrow.Props): react_jsx_runtime.JSX.Element;
+declare const Select: typeof SelectRoot & {
+    Content: typeof SelectContent;
+    Group: typeof SelectGroup;
+    Item: typeof SelectItem;
+    Label: typeof SelectLabel;
+    ScrollDownButton: typeof SelectScrollDownButton;
+    ScrollUpButton: typeof SelectScrollUpButton;
+    Separator: typeof SelectSeparator;
+    Trigger: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.SelectTriggerProps & {
+        removeIcon?: boolean;
+    }, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+    Value: typeof SelectValue;
+};
+
+interface SelectInfiniteScrollProps<T extends object> {
+    search?: boolean;
+    value: string;
+    onValueChange: (value: string) => void;
+    /** Fires when the resolved selected item changes (including when cleared). */
+    onSelectedItemChange?: (item: T | null) => void;
+    disabled?: boolean;
+    id?: string;
+    className?: string;
+    enabled?: boolean;
+    queryKey: (string | undefined)[];
+    queryFn: (params: {
+        pageParam?: unknown;
+        search: string;
+    }) => Promise<T[]>;
+    options?: Record<string, unknown>;
+    getItemValue: (item: T) => string;
+    renderItem: (item: T, isSelected: boolean) => React__default.ReactNode;
+    renderSelectedValue?: (item: T) => React__default.ReactNode;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    contentTitle?: string;
+}
+declare function SelectInfiniteScroll<T extends object>({ value, onValueChange, onSelectedItemChange, disabled, search: searchProp, id, className, queryKey, queryFn, enabled, options, getItemValue, renderItem, renderSelectedValue, placeholder, searchPlaceholder, emptyText, contentTitle, }: SelectInfiniteScrollProps<T>): react_jsx_runtime.JSX.Element;
+
+interface SelectMultiProps<T extends object> {
+    values: string[];
+    onValuesChange: (values: string[]) => void;
+    options?: T[];
+    isLoading?: boolean;
+    disabled?: boolean;
+    id?: string;
+    className?: string;
+    getItemValue: (item: T) => string;
+    renderItem: (item: T, isSelected: boolean) => React__default.ReactNode;
+    getBadgeLabel?: (item: T) => string;
+    filterFn?: (item: T, search: string) => boolean;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    contentTitle?: string;
+}
+declare function SelectMulti<T extends object>({ values, onValuesChange, options, isLoading, disabled, id, className, getItemValue, renderItem, getBadgeLabel, filterFn, placeholder, searchPlaceholder, emptyText, contentTitle, }: SelectMultiProps<T>): react_jsx_runtime.JSX.Element;
+
+declare function SheetRoot({ ...props }: Dialog$2.Root.Props): react_jsx_runtime.JSX.Element;
+declare function SheetTrigger({ asChild, children, ...props }: Dialog$2.Trigger.Props & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SheetClose({ asChild, children, ...props }: Dialog$2.Close.Props & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SheetContent({ className, children, side, ...props }: Dialog$2.Popup.Props & {
+    side?: 'top' | 'right' | 'bottom' | 'left';
+}): react_jsx_runtime.JSX.Element;
+declare function SheetHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SheetFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function SheetTitle({ className, ...props }: Dialog$2.Title.Props): react_jsx_runtime.JSX.Element;
+declare function SheetDescription({ className, ...props }: Dialog$2.Description.Props): react_jsx_runtime.JSX.Element;
+declare const Sheet: typeof SheetRoot & {
+    Close: typeof SheetClose;
+    Content: typeof SheetContent;
+    Description: typeof SheetDescription;
+    Footer: typeof SheetFooter;
+    Header: typeof SheetHeader;
+    Title: typeof SheetTitle;
+    Trigger: typeof SheetTrigger;
+};
+
+type TextShimmerProps = {
+    children: string;
+    as?: React__default.ElementType;
+    className?: string;
+    duration?: number;
+    spread?: number;
+};
+declare function TextShimmerComponent({ children, as: Component, className, duration, spread, }: TextShimmerProps): react_jsx_runtime.JSX.Element;
+declare const TextShimmer: React__default.MemoExoticComponent<typeof TextShimmerComponent>;
+
+declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & {
+    containerClassName?: string;
+} & React$1.RefAttributes<HTMLTableElement>> & {
+    Header: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Body: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Footer: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Row: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+    Head: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+    Cell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+    Caption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+};
+
+interface CursorPaginationMeta$1 {
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+    limit?: number;
+}
+interface DataTableProps<TData> extends React$1.HTMLAttributes<HTMLDivElement> {
+    table: Table$1<TData>;
+    children?: React$1.ReactNode;
+    emptyMessage?: string;
+    cursorMeta?: CursorPaginationMeta$1;
+    onNavigate?: (direction: 'next' | 'previous') => void;
+    showPagination?: boolean;
+    isLoading?: boolean;
+    disablePageSize?: boolean;
+}
+declare function DataTable<TData>({ table, children, className, cursorMeta, onNavigate, showPagination, isLoading, disablePageSize, emptyMessage, ...props }: DataTableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface CursorPaginationMeta {
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+    limit?: number;
+}
+interface DataTablePaginationProps<TData> {
+    table: Table$1<TData>;
+    pageSizeOptions?: number[];
+    cursorMeta?: CursorPaginationMeta;
+    onNavigate?: (direction: 'next' | 'previous') => void;
+    disablePageSize?: boolean;
+}
+declare function DataTablePagination<TData>({ table, pageSizeOptions, cursorMeta, onNavigate, disablePageSize, }: DataTablePaginationProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableToolbarProps<TData> {
+    table: Table$1<TData>;
+    show?: {
+        reset: boolean;
+        view: boolean;
+    };
+    children?: React.ReactNode;
+}
+declare function DataTableToolbar<TData>({ table, show, children, }: DataTableToolbarProps<TData>): react_jsx_runtime.JSX.Element | null;
+
+interface DataTableViewOptionsProps<TData> {
+    table: Table$1<TData>;
+}
+declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+type TabsRootProps = React$1.ComponentProps<typeof Tabs$1.Root>;
+declare function Tabs({ className, ...props }: TabsRootProps): react_jsx_runtime.JSX.Element;
+declare namespace Tabs {
+    var List: typeof TabsList;
+    var Trigger: typeof TabsTrigger;
+    var Content: typeof TabsContent;
+}
+type TabsListProps = React$1.ComponentProps<typeof Tabs$1.List>;
+declare function TabsList({ className, ...props }: TabsListProps): react_jsx_runtime.JSX.Element;
+type TabsTabProps = React$1.ComponentProps<typeof Tabs$1.Tab>;
+declare function TabsTrigger({ className, ...props }: TabsTabProps): react_jsx_runtime.JSX.Element;
+type TabsPanelProps = React$1.ComponentProps<typeof Tabs$1.Panel>;
+declare function TabsContent({ className, ...props }: TabsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface CellProps extends React.HTMLAttributes<HTMLSpanElement> {
+    wrap?: boolean;
+    emptyText?: string;
+}
+
+interface PhoneProps extends React.HTMLAttributes<HTMLSpanElement> {
+    phone: string | null | undefined;
+    flag?: boolean;
+}
+
+declare const Text: {
+    Phone: ({ phone, flag, className }: PhoneProps) => react_jsx_runtime.JSX.Element;
+    Cell: ({ wrap, children, className, emptyText, ...props }: CellProps) => react_jsx_runtime.JSX.Element;
+};
+
+declare function Textarea({ className, ...props }: React$1.ComponentProps<'textarea'>): react_jsx_runtime.JSX.Element;
+declare namespace Textarea {
+    var displayName: string;
+}
+
+type AppToasterProps = Omit<ToasterProps, 'theme'> & {
+    /** App theme id (`cream`, `onix`, …) or Sonner’s own `light` / `dark` / `system` */
+    theme?: ToasterProps['theme'] | string;
+};
+declare const Toaster: ({ theme: themeProp, toastOptions, style, className, richColors, ...props }: AppToasterProps) => react_jsx_runtime.JSX.Element;
+
+interface TrackerBlockProps {
+    key?: string | number;
+    color?: string;
+    tooltip?: string;
+    defaultBackgroundColor?: string;
+    disabledTooltip?: boolean;
+}
+interface TrackerProps extends React.ComponentProps<'div'>, Pick<TrackerBlockProps, 'disabledTooltip'> {
+    data: TrackerBlockProps[];
+    defaultBackgroundColor?: string;
+}
+declare const Tracker: ({ data, disabledTooltip, className, ref, ...props }: TrackerProps) => react_jsx_runtime.JSX.Element;
+
+type VideoPlayerProps = ComponentProps<typeof MediaController>;
+declare const VideoPlayer: ({ style, ...props }: VideoPlayerProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerControlBarProps = ComponentProps<typeof MediaControlBar>;
+declare const VideoPlayerControlBar: (props: VideoPlayerControlBarProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerTimeRangeProps = ComponentProps<typeof MediaTimeRange>;
+declare const VideoPlayerTimeRange: ({ className, ...props }: VideoPlayerTimeRangeProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerTimeDisplayProps = ComponentProps<typeof MediaTimeDisplay>;
+declare const VideoPlayerTimeDisplay: ({ className, ...props }: VideoPlayerTimeDisplayProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerVolumeRangeProps = ComponentProps<typeof MediaVolumeRange>;
+declare const VideoPlayerVolumeRange: ({ className, ...props }: VideoPlayerVolumeRangeProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerPlayButtonProps = ComponentProps<typeof MediaPlayButton>;
+declare const VideoPlayerPlayButton: ({ className, ...props }: VideoPlayerPlayButtonProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerSeekBackwardButtonProps = ComponentProps<typeof MediaSeekBackwardButton>;
+declare const VideoPlayerSeekBackwardButton: ({ className, ...props }: VideoPlayerSeekBackwardButtonProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerSeekForwardButtonProps = ComponentProps<typeof MediaSeekForwardButton>;
+declare const VideoPlayerSeekForwardButton: ({ className, ...props }: VideoPlayerSeekForwardButtonProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerMuteButtonProps = ComponentProps<typeof MediaMuteButton>;
+declare const VideoPlayerMuteButton: ({ className, ...props }: VideoPlayerMuteButtonProps) => react_jsx_runtime.JSX.Element;
+type VideoPlayerContentProps = ComponentProps<'video'>;
+declare const VideoPlayerContent: ({ className, tabIndex, ...props }: VideoPlayerContentProps) => react_jsx_runtime.JSX.Element;
+
+declare function AvatarRoot({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function AvatarImage({ src, className, ...props }: React$1.ComponentProps<'img'>): react_jsx_runtime.JSX.Element | null;
+declare function AvatarFallback({ name, children, className, ...props }: React$1.ComponentProps<'span'> & {
+    name?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare const Avatar: typeof AvatarRoot & {
+    Image: typeof AvatarImage;
+    Fallback: typeof AvatarFallback;
+};
+
+declare function Calendar({ className, classNames, showOutsideDays, components: userComponents, ...props }: React$1.ComponentProps<typeof DayPicker>): react_jsx_runtime.JSX.Element;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+type ChartConfig = {
+    [k in string]: {
+        label?: React$1.ReactNode;
+        icon?: React$1.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare function ChartRoot({ id, className, children, config, ...props }: React$1.ComponentProps<'div'> & {
+    config: ChartConfig;
+    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
+}): react_jsx_runtime.JSX.Element;
+/** Recharts injects these when rendering tooltip content; callers may omit them. */
+type TooltipInjectedProps = 'active' | 'payload' | 'coordinate' | 'accessibilityLayer' | 'activeIndex';
+type ChartTooltipContentProps = Omit<TooltipContentProps, TooltipInjectedProps> & Partial<Pick<TooltipContentProps, TooltipInjectedProps>> & React$1.ComponentProps<'div'> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+    color?: string;
+};
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: ChartTooltipContentProps): react_jsx_runtime.JSX.Element | null;
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React$1.ComponentProps<'div'> & Pick<DefaultLegendContentProps, 'payload' | 'verticalAlign'> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare const Chart: typeof ChartRoot & {
+    Legend: React$1.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React$1.ReactPortal | null>;
+    LegendContent: typeof ChartLegendContent;
+    Style: ({ id, config }: {
+        id: string;
+        config: ChartConfig;
+    }) => react_jsx_runtime.JSX.Element | null;
+    Tooltip: typeof RechartsPrimitive.Tooltip;
+    TooltipContent: typeof ChartTooltipContent;
+};
+
+declare const collapsibleRootVariants: (props?: ({
+    variant?: "row" | "card" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+/** Extra styles on top of {@link SettingsItem} for the collapsible trigger. */
+declare const collapsibleTriggerSettingsOverlayVariants: (props?: ({
+    variant?: "row" | "card" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const collapsibleContentVariants: (props?: ({
+    variant?: "row" | "card" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CollapsibleAlign = 'center' | 'start' | null | undefined;
+type CollapsibleContextValue = VariantProps<typeof collapsibleRootVariants> & {
+    align: CollapsibleAlign;
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    contentId: string;
+    disabled: boolean;
+};
+/** Read open state from a parent {@link Collapsible} (e.g. custom chevron in the trigger action). */
+declare function useCollapsibleOpen(): boolean;
+/** Returns null when not inside {@link Collapsible}; use from {@link SettingsItem} with `collapsibleTrigger`. */
+declare function useOptionalCollapsibleContext(): CollapsibleContextValue | null;
+declare function CollapsibleRoot({ className, variant, align, open: openProp, defaultOpen, onOpenChange, expandWhen, disabled, children, ...props }: React$1.ComponentProps<'div'> & VariantProps<typeof collapsibleRootVariants> & {
+    align?: CollapsibleAlign;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    expandWhen?: boolean;
+    disabled?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function CollapsibleContent({ className, children, }: {
+    className?: string;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare const Collapsible: typeof CollapsibleRoot & {
+    Content: typeof CollapsibleContent;
+};
+
+declare function Dialog({ ...props }: Dialog$2.Root.Props): react_jsx_runtime.JSX.Element;
+
+declare function CommandRoot({ className, ...props }: React$1.ComponentProps<typeof Command$1>): react_jsx_runtime.JSX.Element;
+declare function CommandDialog({ title, description, children, className, commandClassName, closeButtonClassName, showCloseButton, filter, ...props }: Omit<React$1.ComponentProps<typeof Dialog>, 'children'> & {
+    children?: React$1.ReactNode;
+    title?: string;
+    description?: string;
+    className?: string;
+    commandClassName?: string;
+    closeButtonClassName?: string;
+    showCloseButton?: boolean;
+    filter?: React$1.ComponentProps<typeof Command$1>['filter'];
+}): react_jsx_runtime.JSX.Element;
+declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): react_jsx_runtime.JSX.Element;
+declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Command$1.List>): react_jsx_runtime.JSX.Element;
+declare function CommandEmpty({ ...props }: React$1.ComponentProps<typeof Command$1.Empty>): react_jsx_runtime.JSX.Element;
+declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): react_jsx_runtime.JSX.Element;
+declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): react_jsx_runtime.JSX.Element;
+declare function CommandItem({ className, ...props }: React$1.ComponentProps<typeof Command$1.Item>): react_jsx_runtime.JSX.Element;
+declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function CommandFooter({ className, navigateLabel, selectLabel, closeLabel, children, ...props }: React$1.ComponentProps<'div'> & {
+    navigateLabel?: string;
+    selectLabel?: string;
+    closeLabel?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const Command: typeof CommandRoot & {
+    Dialog: typeof CommandDialog;
+    Empty: typeof CommandEmpty;
+    Footer: typeof CommandFooter;
+    Group: typeof CommandGroup;
+    Input: typeof CommandInput;
+    Item: typeof CommandItem;
+    List: typeof CommandList;
+    Separator: typeof CommandSeparator;
+    Shortcut: typeof CommandShortcut;
+};
+
+declare function DrawerRoot({ ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DrawerTrigger({ ...props }: React$1.ComponentProps<typeof Drawer$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DrawerPortal({ ...props }: React$1.ComponentProps<typeof Drawer$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DrawerClose({ ...props }: React$1.ComponentProps<typeof Drawer$1.Close>): react_jsx_runtime.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Overlay>): react_jsx_runtime.JSX.Element;
+declare function DrawerContent({ className, children, title, showDivider, onOpenAutoFocus, ...props }: React$1.ComponentProps<typeof Drawer$1.Content> & {
+    title?: string;
+    showDivider?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DrawerHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Title>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Description>): react_jsx_runtime.JSX.Element;
+declare const Drawer: typeof DrawerRoot & {
+    Close: typeof DrawerClose;
+    Content: typeof DrawerContent;
+    Description: typeof DrawerDescription;
+    Footer: typeof DrawerFooter;
+    Header: typeof DrawerHeader;
+    Overlay: typeof DrawerOverlay;
+    Portal: typeof DrawerPortal;
+    Title: typeof DrawerTitle;
+    Trigger: typeof DrawerTrigger;
+};
+
+interface ImageUploadProps {
+    value: File | string | null;
+    onChange: (file: File | null) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+    previewClassName?: string;
+    id?: string;
+}
+declare const ImageUpload: {
+    ({ value, onChange, label, disabled, className, previewClassName, id, }: ImageUploadProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare function Label({ className, children, required, ...props }: React$1.ComponentProps<'label'> & {
+    required?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<Omit<_base_ui_react.ScrollAreaRootProps, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>> & {
+    ScrollBar: React$1.ForwardRefExoticComponent<Omit<Omit<_base_ui_react.ScrollAreaScrollbarProps, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+export { ANNOUNCEMENT_TYPES, Accordion, ActionGroup, Alert, AnnouncementBanner, type AnnouncementBannerProps, type AnnouncementType, AppShell, type AppShellSidebarItemData, Avatar, Badge, type BadgeProps, BrandDomainInput, type BrandIconName, Breadcrumb, Button, type ButtonVariants, Calendar, Card, CardContent, CardFooter, CardHeader, CardSlider, Chart, type ChartConfig, ChatPreview, Checkbox, type CheckboxProps, Collapsible, CollapsibleContent, Command, type Country, type Currency, CurrencyInput, type CurrencyInputProps, type CustomIconName, DATA_CUSTOM_TABLE_VARIANTS, DEFAULT_DATA_CUSTOM_TABLE_VARIANT, DataCustomTable, type DataCustomTableVariant, DataTable, DataTableColumnHeader, DataTablePagination, DataTableToolbar, DataTableViewOptions, Devices, Dialog$1 as Dialog, DialogStack, Drawer, DropdownMenu, type DuoIconName, EmojiPicker, EmptyState, type FillIconName, HoverCard, type HoverCardContentProps, Icon, type IconProps, type IconSharedProps, type IconType, type IconVariant, ImageUpload, type ImageUploadProps, Input, InputGroup, type InputProps, InputTime, InputTimePicker, type InputTimePickerProps, type InputTimeProps, type InputTimeType, InputTimeUnit, type InputTimeUnitProps, Kbd, type KbdKey, type KbdProps, Label, LanguageSwitch, Loader, Marquee, MarqueeContent, type MarqueeContentProps, MarqueeFade, type MarqueeFadeProps, MarqueeItem, type MarqueeItemProps, type MarqueeProps, NetworkStatus, OnneLogo, OnnebookLogo, PhoneInput, type PhoneInputProps, Popover, Progress, RadioGroup, SIDEBAR_WIDTH, ScrollArea, Select, SelectInfiniteScroll, type SelectInfiniteScrollProps, SelectMulti, type SelectMultiProps, Separator, Sheet, Sidebar, Skeleton, type SocialIconName, TIME_UNITS, Table, Tabs, Text, TextShimmer, type TextShimmerProps, Textarea, type ThemeIcon, type TimeUnit, type TimeUnitLabel, type TimeUnitOption, Toaster, Tracker, type TrackerBlockProps, VideoPlayer, VideoPlayerContent, type VideoPlayerContentProps, VideoPlayerControlBar, type VideoPlayerControlBarProps, VideoPlayerMuteButton, type VideoPlayerMuteButtonProps, VideoPlayerPlayButton, type VideoPlayerPlayButtonProps, type VideoPlayerProps, VideoPlayerSeekBackwardButton, type VideoPlayerSeekBackwardButtonProps, VideoPlayerSeekForwardButton, type VideoPlayerSeekForwardButtonProps, VideoPlayerTimeDisplay, type VideoPlayerTimeDisplayProps, VideoPlayerTimeRange, type VideoPlayerTimeRangeProps, VideoPlayerVolumeRange, type VideoPlayerVolumeRangeProps, badgeVariants, buttonVariants, collapsibleContentVariants, collapsibleRootVariants, collapsibleTriggerSettingsOverlayVariants, resolveThemeIcon, useAppShellRightSidebar, useCollapsibleOpen, useDialog, useDialogStack, useOptionalCollapsibleContext, useSidebar };