noorui-rtl 0.3.1 → 0.3.3

package/dist/index.d.mts

@@ -0,0 +1,1508 @@
+import * as React from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as class_variance_authority from 'class-variance-authority';
+import { VariantProps } from 'class-variance-authority';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogProps } from '@radix-ui/react-dialog';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { LucideIcon } from 'lucide-react';
+import * as _radix_ui_react_label from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ToastPrimitives from '@radix-ui/react-toast';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Node, Edge, OnNodesChange, OnEdgesChange, OnConnect, BackgroundVariant, FitViewOptions, DefaultEdgeOptions, NodeProps } from '@xyflow/react';
+import { ClassValue } from 'clsx';
+
+type Direction = 'ltr' | 'rtl';
+
+interface DirectionContextType {
+    direction: Direction;
+    setDirection: (direction: Direction) => void;
+    locale: 'en' | 'ar';
+    setLocale: (locale: 'en' | 'ar') => void;
+}
+declare function DirectionProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+declare function useDirection(): DirectionContextType;
+
+declare function ClientProviders({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+
+interface ArabicNumberProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof arabicNumberVariants> {
+    /** The number to display */
+    value: number;
+    /** Format type */
+    format?: 'number' | 'currency' | 'percentage';
+    /** Use Arabic-Indic numerals */
+    useArabicNumerals?: boolean;
+    /** Locale for formatting */
+    locale?: 'en' | 'ar';
+    /** Number of decimal places */
+    decimals?: number;
+    /** Visual style variant */
+    variant?: 'default' | 'inline' | 'badge';
+}
+declare const arabicNumberVariants: (props?: ({
+    variant?: "default" | "inline" | "badge" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const ArabicNumber: React.ForwardRefExoticComponent<ArabicNumberProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;
+
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+    displayName: string;
+};
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "primary" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface CalendarEvent {
+    /** Event date */
+    date: Date;
+    /** Event title */
+    title: string;
+    /** Event color/variant */
+    variant?: 'default' | 'primary' | 'secondary' | 'destructive';
+}
+type SelectionMode = 'single' | 'range';
+interface DateRange {
+    from: Date | undefined;
+    to: Date | undefined;
+}
+interface CalendarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    /** Selection mode */
+    mode?: SelectionMode;
+    /** Selected date (single mode) */
+    selected?: Date;
+    /** Selected date range (range mode) */
+    selectedRange?: DateRange;
+    /** Callback when date is selected */
+    onSelect?: (date: Date | DateRange | undefined) => void;
+    /** Show Hijri dates */
+    showHijri?: boolean;
+    /** Calendar events to display */
+    events?: CalendarEvent[];
+    /** Disabled dates */
+    disabled?: Date[] | ((date: Date) => boolean);
+    /** Minimum selectable date */
+    minDate?: Date;
+    /** Maximum selectable date */
+    maxDate?: Date;
+    /** Locale */
+    locale?: 'en' | 'ar';
+    /** Custom Hijri date provider */
+    getHijriDate?: (date: Date) => {
+        hijri: string;
+        hijriDay: string;
+    };
+}
+declare const Calendar: React.ForwardRefExoticComponent<CalendarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+
+declare const chatMessageVariants: (props?: ({
+    role?: "user" | "assistant" | "system" | null | undefined;
+    variant?: "default" | "compact" | null | undefined;
+    state?: "error" | "complete" | "streaming" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ChatMessageProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chatMessageVariants> {
+    /**
+     * The role/sender of the message
+     */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * The message content (supports markdown)
+     */
+    content: string;
+    /**
+     * Optional timestamp
+     */
+    timestamp?: string;
+    /**
+     * Optional avatar URL
+     */
+    avatar?: string;
+    /**
+     * Optional name/label
+     */
+    name?: string;
+    /**
+     * Show copy button
+     */
+    showCopy?: boolean;
+    /**
+     * Show regenerate button (assistant only)
+     */
+    showRegenerate?: boolean;
+    /**
+     * Callback when copy is clicked
+     */
+    onCopy?: () => void;
+    /**
+     * Callback when regenerate is clicked
+     */
+    onRegenerate?: () => void;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+}
+declare const ChatMessage: React.ForwardRefExoticComponent<ChatMessageProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const Collapsible: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface CommandDialogProps extends DialogProps {
+}
+declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => React.JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "value" | "type" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key">, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key">, "value" | "disabled" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+declare const ContextMenu: React.FC<React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Root>>;
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuPortal: React.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+declare const ContextMenuSub: React.FC<ContextMenuPrimitive.ContextMenuSubProps>;
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+declare const conversationHistoryVariants: (props?: ({
+    variant?: "default" | "floating" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface Conversation {
+    id: string;
+    title: string;
+    titleAr?: string;
+    preview?: string;
+    previewAr?: string;
+    timestamp: Date;
+    messageCount?: number;
+    isActive?: boolean;
+}
+interface ConversationHistoryProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'>, VariantProps<typeof conversationHistoryVariants> {
+    /**
+     * List of conversations
+     */
+    conversations: Conversation[];
+    /**
+     * Currently active conversation ID
+     */
+    activeId?: string;
+    /**
+     * Callback when conversation is selected
+     */
+    onSelect?: (id: string) => void;
+    /**
+     * Callback when new conversation is created
+     */
+    onCreate?: () => void;
+    /**
+     * Callback when conversation is renamed
+     */
+    onRename?: (id: string, newTitle: string) => void;
+    /**
+     * Callback when conversation is deleted
+     */
+    onDelete?: (id: string) => void;
+    /**
+     * Callback when conversation is shared
+     */
+    onShare?: (id: string) => void;
+    /**
+     * Show search input
+     */
+    showSearch?: boolean;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Header title
+     */
+    title?: string;
+    /**
+     * Header title in Arabic
+     */
+    titleAr?: string;
+}
+declare const ConversationHistory: React.ForwardRefExoticComponent<ConversationHistoryProps & React.RefAttributes<HTMLDivElement>>;
+
+interface Notification {
+    id: string;
+    title: string;
+    titleAr?: string;
+    description?: string;
+    descriptionAr?: string;
+    message?: string;
+    messageAr?: string;
+    time?: string;
+    timestamp?: string;
+    type?: 'info' | 'success' | 'warning' | 'error' | 'comment';
+    read?: boolean;
+    icon?: React.ReactNode;
+    avatar?: string;
+}
+interface NotificationCenterProps {
+    notifications?: Notification[];
+    onNotificationClick?: (notification: Notification) => void;
+    onMarkAsRead?: (id: string) => void;
+    onMarkAllAsRead?: () => void;
+    onClearAll?: () => void;
+    onRemove?: (id: string) => void;
+    className?: string;
+    maxHeight?: string;
+}
+declare const NotificationCenter: React.ForwardRefExoticComponent<NotificationCenterProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface NavItem {
+    title: string;
+    titleAr: string;
+    href: string;
+    icon?: React.ReactNode;
+    badge?: string | number;
+    disabled?: boolean;
+}
+interface DashboardShellProps {
+    children: React.ReactNode;
+    navItems?: NavItem[];
+    user?: {
+        name?: string;
+        email?: string;
+        image?: string;
+        initials?: string;
+    };
+    notifications?: Notification[];
+    onProfileClick?: () => void;
+    onSettingsClick?: () => void;
+    onBillingClick?: () => void;
+    onTeamClick?: () => void;
+    onSupportClick?: () => void;
+    onLogout?: () => void;
+    onNotificationClick?: (notification: Notification) => void;
+    onMarkAsRead?: (id: string) => void;
+    onMarkAllAsRead?: () => void;
+    onClearAll?: () => void;
+    onRemove?: (id: string) => void;
+    logo?: React.ReactNode;
+    logoHref?: string;
+    sidebarWidth?: string;
+    className?: string;
+    /**
+     * Use relative positioning instead of fixed (useful for embedded examples)
+     * @default false
+     */
+    relative?: boolean;
+}
+declare function DashboardShell({ children, navItems, user, notifications, onProfileClick, onSettingsClick, onBillingClick, onTeamClick, onSupportClick, onLogout, onNotificationClick, onMarkAsRead, onMarkAllAsRead, onClearAll, onRemove, logo, logoHref, sidebarWidth, className, relative, }: DashboardShellProps): React.JSX.Element;
+
+type SortDirection = 'asc' | 'desc' | null;
+interface ColumnDef<T> {
+    id: string;
+    header: string;
+    headerAr?: string;
+    accessorKey: keyof T;
+    cell?: (row: T) => React.ReactNode;
+    sortable?: boolean;
+    filterable?: boolean;
+    align?: 'start' | 'center' | 'end';
+    width?: string;
+}
+interface DataTableProps<T> {
+    data: T[];
+    columns: ColumnDef<T>[];
+    isLoading?: boolean;
+    sortBy?: string;
+    sortDirection?: SortDirection;
+    onSort?: (columnId: string) => void;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    searchPlaceholderAr?: string;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    filterBy?: (keyof T)[];
+    pagination?: boolean;
+    currentPage?: number;
+    totalPages?: number;
+    pageSize?: number;
+    onPageChange?: (page: number) => void;
+    mobileView?: 'table' | 'cards';
+    emptyMessage?: string;
+    emptyMessageAr?: string;
+    className?: string;
+    striped?: boolean;
+    hoverable?: boolean;
+    compact?: boolean;
+}
+declare function DataTable<T>({ data, columns, isLoading, sortBy, sortDirection, onSort, searchable, searchPlaceholder, searchPlaceholderAr, searchValue, onSearchChange, pagination, currentPage, totalPages, pageSize, onPageChange, mobileView, emptyMessage, emptyMessageAr, className, striped, hoverable, compact, }: DataTableProps<T>): React.JSX.Element;
+
+interface DatePickerProps {
+    date?: Date;
+    onDateChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    placeholderAr?: string;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * Format function for displaying the selected date
+     */
+    formatDate?: (date: Date | undefined, locale: 'en' | 'ar') => string;
+    /**
+     * Minimum selectable date
+     */
+    minDate?: Date;
+    /**
+     * Maximum selectable date
+     */
+    maxDate?: Date;
+    /**
+     * Dates that should be disabled
+     */
+    disabledDates?: Date[];
+    /**
+     * Show Hijri date alongside Gregorian
+     */
+    showHijri?: boolean;
+}
+declare function DatePicker({ date, onDateChange, placeholder, placeholderAr, disabled, className, formatDate, minDate, maxDate, disabledDates, showHijri, }: DatePickerProps): React.JSX.Element;
+
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+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 const DropdownMenu: React.FC<React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Root>>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+
+interface EmptyStateProps {
+    icon?: React.ReactNode;
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    className?: string;
+}
+declare function EmptyState({ icon, title, description, action, className, }: EmptyStateProps): React.JSX.Element;
+declare namespace EmptyState {
+    var displayName: string;
+}
+
+interface FeatureCardProps {
+    title: string;
+    description: string;
+    icon: LucideIcon;
+    href?: string;
+    className?: string;
+}
+declare function FeatureCard({ title, description, icon: Icon, href, className, }: FeatureCardProps): React.JSX.Element;
+declare namespace FeatureCard {
+    var displayName: string;
+}
+
+interface FileUploadProps {
+    onUpload?: (files: File[]) => void;
+    onChange?: (files: File[]) => void;
+    maxSize?: number;
+    maxFiles?: number;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    className?: string;
+    value?: File[];
+}
+declare const FileUpload: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    initialValues?: Record<string, any>;
+    validators?: Record<string, (value: any) => string | undefined>;
+    onSubmit: (values: Record<string, any>) => void | Promise<void>;
+}
+declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
+interface FormFieldProps {
+    name: string;
+    children: (props: {
+        field: {
+            name: string;
+            value: any;
+            onChange: (value: any) => void;
+            onBlur: () => void;
+        };
+        error?: string;
+        touched: boolean;
+    }) => React.ReactNode;
+}
+declare const FormField: React.FC<FormFieldProps>;
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<Omit<_radix_ui_react_label.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & class_variance_authority.VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>, "ref"> & {
+    required?: boolean;
+} & React.RefAttributes<HTMLLabelElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & {
+    error?: string;
+} & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+
+interface HijriDateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof hijriDateVariants> {
+    /** Gregorian date in English (e.g., "November 6, 2025") */
+    gregorianDate: string;
+    /** Gregorian date in Arabic (optional, for RTL display) */
+    gregorianDateAr?: string;
+    /** Hijri date in English (e.g., "5 Jumada al-Awwal 1447") */
+    hijriDate: string;
+    /** Hijri date in Arabic (e.g., "٥ جمادى الأولى ١٤٤٧") */
+    hijriDateAr: string;
+    /** Show calendar icon */
+    showIcon?: boolean;
+    /** Show Islamic holiday badge if applicable */
+    showHoliday?: boolean;
+    /** Visual variant */
+    variant?: 'default' | 'badge' | 'compact' | 'detailed';
+}
+declare const hijriDateVariants: (props?: ({
+    variant?: "default" | "compact" | "badge" | "detailed" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const HijriDate: React.ForwardRefExoticComponent<HijriDateProps & React.RefAttributes<HTMLDivElement>>;
+
+interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const Label: React.ForwardRefExoticComponent<Omit<_radix_ui_react_label.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_types.ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+
+interface ListingCardBadge {
+    label: string;
+    variant?: 'default' | 'secondary' | 'destructive' | 'outline';
+    className?: string;
+}
+interface ListingCardStat {
+    icon: LucideIcon;
+    value: string | number;
+    label?: string;
+}
+interface ListingCardAction {
+    icon: LucideIcon;
+    label: string;
+    onClick?: () => void;
+}
+interface ListingCardTag {
+    label: string;
+    variant?: 'default' | 'secondary' | 'outline';
+}
+interface ListingCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Main title of the listing
+     */
+    title: string;
+    /**
+     * Subtitle or location text
+     */
+    subtitle?: string | React.ReactNode;
+    /**
+     * Short description
+     */
+    description?: string;
+    /**
+     * Price or main value to display
+     */
+    price?: string | React.ReactNode;
+    /**
+     * Image URL or custom image component
+     */
+    image?: string | React.ReactNode;
+    /**
+     * Icon to show as placeholder when no image provided
+     */
+    placeholderIcon?: LucideIcon;
+    /**
+     * Badges to show on top left of image
+     */
+    badges?: ListingCardBadge[];
+    /**
+     * Action buttons on top right of image (heart, share, etc)
+     */
+    actions?: ListingCardAction[];
+    /**
+     * Stats/specs to display (bedrooms, bathrooms, area, etc)
+     */
+    stats?: ListingCardStat[];
+    /**
+     * Tags/amenities to display
+     */
+    tags?: ListingCardTag[];
+    /**
+     * Max number of tags to show before "+N more"
+     */
+    maxTags?: number;
+    /**
+     * Type badge next to title
+     */
+    typeBadge?: string;
+    /**
+     * CTA button text
+     */
+    ctaText?: string;
+    /**
+     * CTA button click handler
+     */
+    onCtaClick?: () => void;
+    /**
+     * Card click handler
+     */
+    onClick?: () => void;
+    /**
+     * Whether card is featured
+     */
+    featured?: boolean;
+    /**
+     * Image aspect ratio
+     */
+    imageAspect?: 'square' | 'video' | 'wide';
+    /**
+     * Hover effect
+     */
+    hoverEffect?: boolean;
+}
+declare const ListingCard: React.ForwardRefExoticComponent<ListingCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface LoadingSpinnerProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg';
+    text?: string;
+}
+declare function LoadingSpinnerComponent({ size, text, className, ...props }: LoadingSpinnerProps): React.JSX.Element;
+declare const LoadingSpinner: React.MemoExoticComponent<typeof LoadingSpinnerComponent>;
+
+interface MessageActionsProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Show copy button
+     */
+    showCopy?: boolean;
+    /**
+     * Show regenerate button
+     */
+    showRegenerate?: boolean;
+    /**
+     * Show edit button
+     */
+    showEdit?: boolean;
+    /**
+     * Show share button
+     */
+    showShare?: boolean;
+    /**
+     * Show flag/report button
+     */
+    showFlag?: boolean;
+    /**
+     * Show feedback buttons (thumbs up/down)
+     */
+    showFeedback?: boolean;
+    /**
+     * Callback when copy is clicked
+     */
+    onCopy?: () => void;
+    /**
+     * Callback when regenerate is clicked
+     */
+    onRegenerate?: () => void;
+    /**
+     * Callback when edit is clicked
+     */
+    onEdit?: () => void;
+    /**
+     * Callback when share is clicked
+     */
+    onShare?: () => void;
+    /**
+     * Callback when flag is clicked
+     */
+    onFlag?: () => void;
+    /**
+     * Callback when thumbs up is clicked
+     */
+    onThumbsUp?: () => void;
+    /**
+     * Callback when thumbs down is clicked
+     */
+    onThumbsDown?: () => void;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Compact mode (icon only)
+     */
+    compact?: boolean;
+}
+declare const MessageActions: React.ForwardRefExoticComponent<MessageActionsProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AIModel {
+    id: string;
+    name: string;
+    nameAr?: string;
+    provider: string;
+    providerAr?: string;
+    description: string;
+    descriptionAr?: string;
+    specs: {
+        speed: 'fast' | 'medium' | 'slow';
+        speedLabel?: string;
+        speedLabelAr?: string;
+        contextLength: number;
+        pricing?: string;
+        pricingAr?: string;
+    };
+    recommended?: boolean;
+    icon?: 'zap' | 'brain' | 'sparkles' | 'bot';
+}
+interface ModelSelectorProps {
+    /**
+     * Available models
+     */
+    models: AIModel[];
+    /**
+     * Selected model ID
+     */
+    value?: string;
+    /**
+     * Callback when model changes
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Placeholder text
+     */
+    placeholder?: string;
+    /**
+     * Placeholder text in Arabic
+     */
+    placeholderAr?: string;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+declare const ModelSelector: React.ForwardRefExoticComponent<ModelSelectorProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number | undefined) => void;
+    onValueChange?: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    showControls?: boolean;
+    formatDisplay?: (value: number) => string;
+    parseValue?: (value: string) => number | undefined;
+    allowNegative?: boolean;
+    allowDecimal?: boolean;
+    thousandsSeparator?: string | boolean;
+    decimalSeparator?: string;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, 'size'> & React.ComponentProps<'a'>;
+declare const PaginationLink: {
+    ({ className, isActive, size, children, ...props }: PaginationLinkProps): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, children, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, children, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+
+interface ParameterPreset {
+    label: string;
+    labelAr?: string;
+    value: number;
+    description?: string;
+    descriptionAr?: string;
+}
+interface ParameterSliderProps {
+    /**
+     * Parameter label
+     */
+    label: string;
+    /**
+     * Parameter label in Arabic
+     */
+    labelAr?: string;
+    /**
+     * Parameter description/tooltip
+     */
+    description?: string;
+    /**
+     * Parameter description in Arabic
+     */
+    descriptionAr?: string;
+    /**
+     * Current value
+     */
+    value: number;
+    /**
+     * Callback when value changes
+     */
+    onValueChange: (value: number) => void;
+    /**
+     * Minimum value
+     */
+    min?: number;
+    /**
+     * Maximum value
+     */
+    max?: number;
+    /**
+     * Step size
+     */
+    step?: number;
+    /**
+     * Number of decimal places to display
+     */
+    decimals?: number;
+    /**
+     * Preset values
+     */
+    presets?: ParameterPreset[];
+    /**
+     * Show value display
+     */
+    showValue?: boolean;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+declare const ParameterSlider: React.ForwardRefExoticComponent<ParameterSliderProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface Prayer {
+    /** Prayer name in English */
+    name: string;
+    /** Prayer name in Arabic */
+    nameAr: string;
+    /** Prayer time (e.g., "04:45 AM" or "04:45") */
+    time: string;
+}
+interface PrayerTimesProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Array of prayer times */
+    prayers: Prayer[];
+    /** Name of the next prayer to highlight */
+    nextPrayer?: string;
+    /** Countdown to next prayer (e.g., "2:30:15") */
+    countdown?: string;
+    /** Location name in English */
+    location?: string;
+    /** Location name in Arabic */
+    locationAr?: string;
+    /** Date in English */
+    date?: string;
+    /** Date in Arabic */
+    dateAr?: string;
+    /** Visual variant */
+    variant?: 'default' | 'compact' | 'detailed' | 'notification';
+    /** Callback when notification is dismissed (notification variant only) */
+    onDismiss?: () => void;
+    /** Show play adhan button (notification variant only) */
+    showPlayAdhan?: boolean;
+    /** Callback when play adhan is clicked (notification variant only) */
+    onPlayAdhan?: () => void;
+}
+declare const PrayerTimes: React.ForwardRefExoticComponent<PrayerTimesProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
+    indicatorClassName?: string;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
+interface PromptInputProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /**
+     * Callback when send button is clicked or Enter is pressed
+     */
+    onSend?: (value: string) => void;
+    /**
+     * Whether the input is in loading state
+     */
+    isLoading?: boolean;
+    /**
+     * Show file attachment button
+     */
+    showAttachment?: boolean;
+    /**
+     * Show voice input button
+     */
+    showVoice?: boolean;
+    /**
+     * Show character/token counter
+     */
+    showCounter?: boolean;
+    /**
+     * Maximum characters allowed
+     */
+    maxLength?: number;
+    /**
+     * Callback when attachment button is clicked
+     */
+    onAttachment?: () => void;
+    /**
+     * Callback when voice button is clicked
+     */
+    onVoice?: () => void;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Placeholder text
+     */
+    placeholder?: string;
+    /**
+     * Placeholder text in Arabic
+     */
+    placeholderAr?: string;
+}
+declare const PromptInput: React.ForwardRefExoticComponent<PromptInputProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+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>>;
+
+interface RichTextEditorProps {
+    content?: string;
+    onChange?: (content: string) => void;
+    placeholder?: string;
+    className?: string;
+    editable?: boolean;
+    minHeight?: string;
+}
+declare const RichTextEditor: React.ForwardRefExoticComponent<RichTextEditorProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Select: typeof SelectPrimitive.Root;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "end" | "start" | "top" | "bottom" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+/**
+ * Skeleton - Loading placeholder component
+ *
+ * Displays an animated placeholder while content is loading.
+ * Fully RTL-compatible and supports custom dimensions.
+ *
+ * @example
+ * ```tsx
+ * <Skeleton className="h-4 w-full" />
+ * <Skeleton className="h-12 w-12 rounded-full" />
+ * ```
+ */
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+
+interface Step {
+    id: string;
+    title: string;
+    titleAr?: string;
+    description?: string;
+    descriptionAr?: string;
+    optional?: boolean;
+}
+interface StepperProps {
+    steps: Step[];
+    currentStep: number;
+    onStepClick?: (step: number) => void;
+    orientation?: 'horizontal' | 'vertical';
+    variant?: 'default' | 'simple' | 'circles';
+    allowSkip?: boolean;
+    className?: string;
+}
+declare function Stepper({ steps, currentStep, onStepClick, orientation, variant, allowSkip, className, }: StepperProps): React.JSX.Element;
+
+interface StreamingTextProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * The full text to display
+     */
+    text: string;
+    /**
+     * Speed of typing in milliseconds per character
+     */
+    speed?: number;
+    /**
+     * Whether to show blinking cursor
+     */
+    showCursor?: boolean;
+    /**
+     * Whether streaming is enabled
+     */
+    isStreaming?: boolean;
+    /**
+     * Callback when streaming completes
+     */
+    onComplete?: () => void;
+    /**
+     * Start streaming immediately
+     */
+    autoStart?: boolean;
+}
+declare const StreamingText: React.ForwardRefExoticComponent<StreamingTextProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const Tabs: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>, "ref"> & 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>>;
+
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+declare const thinkingIndicatorVariants: (props?: ({
+    variant?: "dots" | "pulse" | "wave" | "typing" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ThinkingIndicatorProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof thinkingIndicatorVariants> {
+    /**
+     * Custom message to display (overrides default)
+     */
+    message?: string;
+}
+declare const ThinkingIndicator: React.ForwardRefExoticComponent<ThinkingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface Time {
+    hours: number;
+    minutes: number;
+}
+interface TimePickerProps {
+    time?: Time;
+    onTimeChange?: (time: Time | undefined) => void;
+    placeholder?: string;
+    placeholderAr?: string;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * 12-hour or 24-hour format
+     */
+    format?: '12h' | '24h';
+    /**
+     * Minutes step interval
+     */
+    minuteStep?: number;
+    /**
+     * Format function for displaying the selected time
+     */
+    formatTime?: (time: Time | undefined, format: '12h' | '24h', locale: 'en' | 'ar') => string;
+}
+declare function TimePicker({ time, onTimeChange, placeholder, placeholderAr, disabled, className, format, minuteStep, formatTime, }: TimePickerProps): React.JSX.Element;
+
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | "success" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare function Toaster(): React.JSX.Element;
+
+declare const tokenCounterVariants: (props?: ({
+    variant?: "default" | "compact" | null | undefined;
+    status?: "warning" | "safe" | "danger" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TokenCounterProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof tokenCounterVariants> {
+    /**
+     * Number of input tokens used
+     */
+    inputTokens: number;
+    /**
+     * Number of output tokens used
+     */
+    outputTokens: number;
+    /**
+     * Maximum token limit for the model
+     */
+    maxTokens?: number;
+    /**
+     * Cost per 1K input tokens (USD)
+     */
+    inputCostPer1K?: number;
+    /**
+     * Cost per 1K output tokens (USD)
+     */
+    outputCostPer1K?: number;
+    /**
+     * Show cost estimation
+     */
+    showCost?: boolean;
+    /**
+     * Show token breakdown
+     */
+    showBreakdown?: boolean;
+    /**
+     * Warning threshold (percentage)
+     */
+    warningThreshold?: number;
+    /**
+     * Danger threshold (percentage)
+     */
+    dangerThreshold?: number;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Label for the counter
+     */
+    label?: string;
+    /**
+     * Label in Arabic
+     */
+    labelAr?: string;
+}
+declare const TokenCounter: React.ForwardRefExoticComponent<TokenCounterProps & React.RefAttributes<HTMLDivElement>>;
+
+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>>;
+
+interface UserMenuProps {
+    user?: {
+        name?: string;
+        email?: string;
+        image?: string;
+        initials?: string;
+    };
+    onProfileClick?: () => void;
+    onSettingsClick?: () => void;
+    onBillingClick?: () => void;
+    onTeamClick?: () => void;
+    onSupportClick?: () => void;
+    onLogout?: () => void;
+    className?: string;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+}
+declare const UserMenu: React.ForwardRefExoticComponent<UserMenuProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface WorkflowCanvasProps {
+    /**
+     * Initial nodes for the workflow
+     */
+    initialNodes?: Node[];
+    /**
+     * Initial edges/connections
+     */
+    initialEdges?: Edge[];
+    /**
+     * Custom node types
+     */
+    nodeTypes?: Record<string, React.ComponentType<any>>;
+    /**
+     * Callback when nodes change
+     */
+    onNodesChange?: OnNodesChange;
+    /**
+     * Callback when edges change
+     */
+    onEdgesChange?: OnEdgesChange;
+    /**
+     * Callback when nodes connect
+     */
+    onConnect?: OnConnect;
+    /**
+     * Whether the canvas is read-only
+     */
+    readOnly?: boolean;
+    /**
+     * Show minimap
+     */
+    showMiniMap?: boolean;
+    /**
+     * Show controls (zoom, fit view)
+     */
+    showControls?: boolean;
+    /**
+     * Show background pattern
+     */
+    showBackground?: boolean;
+    /**
+     * Background variant
+     */
+    backgroundVariant?: BackgroundVariant;
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+    /**
+     * Fit view options
+     */
+    fitViewOptions?: FitViewOptions;
+    /**
+     * Default edge options
+     */
+    defaultEdgeOptions?: DefaultEdgeOptions;
+}
+declare function WorkflowCanvas({ initialNodes, initialEdges, nodeTypes, onNodesChange: onNodesChangeProp, onEdgesChange: onEdgesChangeProp, onConnect: onConnectProp, readOnly, showMiniMap, showControls, showBackground, backgroundVariant, isRTL, className, fitViewOptions, defaultEdgeOptions: defaultEdgeOptionsProp, }: WorkflowCanvasProps): React.JSX.Element;
+
+interface WorkflowNodeData extends Record<string, unknown> {
+    /**
+     * Node label/title
+     */
+    label: string;
+    /**
+     * Node label in Arabic
+     */
+    labelAr?: string;
+    /**
+     * Node description
+     */
+    description?: string;
+    /**
+     * Node description in Arabic
+     */
+    descriptionAr?: string;
+    /**
+     * Node type/category
+     */
+    type?: string;
+    /**
+     * Node type in Arabic
+     */
+    typeAr?: string;
+    /**
+     * Icon component
+     */
+    icon?: LucideIcon;
+    /**
+     * Badge status
+     */
+    status?: 'active' | 'inactive' | 'error' | 'success';
+    /**
+     * Whether text direction is RTL
+     */
+    isRTL?: boolean;
+    /**
+     * Custom content to render
+     */
+    children?: React.ReactNode;
+}
+declare function WorkflowNode({ data, selected }: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+
+declare function TriggerNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function WebhookTriggerNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function ScheduleTriggerNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function ActionNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function CodeActionNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function FilterNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function AINode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function LLMNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function EmbeddingNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function OutputNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function SaveNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare function NotifyNode(props: NodeProps<Node<WorkflowNodeData>>): React.JSX.Element;
+declare const workflowNodeTypes: {
+    trigger: typeof TriggerNode;
+    webhook: typeof WebhookTriggerNode;
+    schedule: typeof ScheduleTriggerNode;
+    action: typeof ActionNode;
+    code: typeof CodeActionNode;
+    filter: typeof FilterNode;
+    ai: typeof AINode;
+    llm: typeof LLMNode;
+    embedding: typeof EmbeddingNode;
+    output: typeof OutputNode;
+    save: typeof SaveNode;
+    notify: typeof NotifyNode;
+};
+
+interface ZakatAssets {
+    cash: number;
+    gold: number;
+    silver: number;
+    business: number;
+    investments: number;
+    other: number;
+}
+interface ZakatCalculatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Current gold price per gram in SAR */
+    goldPricePerGram?: number;
+    /** Current silver price per gram in SAR */
+    silverPricePerGram?: number;
+    /** Use Arabic-Indic numerals */
+    useArabicNumerals?: boolean;
+    /** Locale for formatting */
+    locale?: 'en' | 'ar';
+    /** Callback when calculation updates */
+    onCalculate?: (result: ZakatCalculationResult) => void;
+    /** Initial asset values */
+    defaultValues?: Partial<ZakatAssets>;
+}
+interface ZakatCalculationResult {
+    totalWealth: number;
+    nisabThreshold: number;
+    zakatDue: number;
+    isZakatApplicable: boolean;
+    breakdown: ZakatAssets;
+}
+declare const ZakatCalculator: React.ForwardRefExoticComponent<ZakatCalculatorProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Merge Tailwind classes with proper conflict resolution
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertTitle, ArabicNumber, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, Breadcrumb, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, type ButtonProps, Calendar, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ChatMessage, Checkbox, ClientProviders, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ConversationHistory, DashboardShell, DataTable, DatePicker, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DirectionProvider, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, FeatureCard, FileUpload, Form, FormDescription, FormField, FormItem, FormLabel, FormMessage, type FormProps, HijriDate, Input, type InputProps, Label, ListingCard, LoadingSpinner, MessageActions, ModelSelector, NotificationCenter, NumberInput, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, ParameterSlider, Popover, PopoverContent, PopoverTrigger, PrayerTimes, Progress, PromptInput, RadioGroup, RadioGroupItem, RichTextEditor, ScrollArea, ScrollBar, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, Skeleton, Slider, type Step, Stepper, type StepperProps, StreamingText, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, ThinkingIndicator, TimePicker, Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, Toaster, TokenCounter, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UserMenu, WorkflowCanvas, WorkflowNode, ZakatCalculator, badgeVariants, buttonVariants, cn, useDirection, workflowNodeTypes };