indas-ui 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,3173 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { ColumnDef, Row, ColumnFiltersState, Column, Table, SortingState, Header, Cell, VisibilityState, ExpandedState } from '@tanstack/react-table';
+import * as _tanstack_table_core from '@tanstack/table-core';
+import { Session } from 'next-auth';
+import { ClassValue } from 'clsx';
+
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'primary' | 'secondary' | 'tertiary' | 'outline' | 'ghost' | 'destructive' | 'footer-primary' | 'footer-secondary' | 'action-create' | 'action-save' | 'action-save-as' | 'action-edit' | 'action-delete' | 'action-print' | 'action-send' | 'action-mail' | 'action-download' | 'action-refresh' | 'action-cancel' | 'action-secondary' | 'action-apply' | 'action-back';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'footer';
+    loading?: boolean;
+    icon?: LucideIcon | React$1.ReactNode;
+    iconPosition?: 'left' | 'right';
+    /** When true, renders as circular icon-only button (36px × 36px) */
+    iconOnly?: boolean;
+    /** Tooltip text for icon-only buttons */
+    tooltip?: string;
+    /** When true, renders as inline button on desktop + floating action button on mobile (bottom-right, above bottom nav) */
+    fab?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+/**
+ * CheckboxButton - Toggle button with checkbox-style UI
+ * Styled like "Set First Plan as Master"
+ */
+interface CheckboxButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    label: string;
+    size?: 'xs' | 'sm' | 'md';
+}
+declare const CheckboxButton: React$1.ForwardRefExoticComponent<CheckboxButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+/**
+ * InputButton - Inline input with label in bordered container
+ * Styled like "Show Wastage upto: 30%"
+ */
+interface InputButtonProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    label: string;
+    size?: 'sm' | 'md';
+    inputClassName?: string;
+    suffix?: string;
+    /** Show inline minus/plus stepper buttons around the input. */
+    stepper?: boolean;
+    /** Called when stepper buttons are clicked. Receives 'inc' or 'dec'.
+     *  Use this to advance to the next valid value (e.g. skip 4 → 5). */
+    onStep?: (direction: 'inc' | 'dec') => void;
+    /** Optional gate for disabling the stepper buttons (e.g. at min/max). */
+    canStep?: (direction: 'inc' | 'dec') => boolean;
+}
+declare const InputButton: React$1.ForwardRefExoticComponent<InputButtonProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface InputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
+    label?: React$1.ReactNode;
+    error?: string | boolean;
+    helper?: string;
+    leftIcon?: LucideIcon;
+    rightIcon?: LucideIcon;
+    onRightIconClick?: () => void;
+    selectOnFocus?: boolean;
+    position?: 'first' | 'middle' | 'last' | 'only';
+    compact?: boolean;
+    trackEdits?: boolean;
+    originalValue?: string | number;
+    isEdited?: boolean;
+}
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface CheckboxProps extends React__default.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    indeterminate?: boolean;
+}
+declare const Checkbox: React__default.FC<CheckboxProps>;
+
+interface LabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement> {
+    children: React__default.ReactNode;
+}
+declare const Label: React__default.FC<LabelProps>;
+
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    error?: string;
+    helper?: string;
+}
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+interface SwitchProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface DropdownOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+    description?: string;
+    key?: string;
+    image?: string;
+}
+interface DropdownProps {
+    options: DropdownOption[];
+    value?: string | number | string[];
+    placeholder?: string;
+    onValueChange: (value: string | number | string[]) => void;
+    onOpen?: () => void;
+    disabled?: boolean;
+    loading?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    className?: string;
+    error?: boolean | string;
+    label?: React.ReactNode;
+    labelExtra?: React.ReactNode;
+    required?: boolean;
+    emptyMessage?: string;
+    triggerClassName?: string;
+    autoWidth?: boolean;
+    customFooter?: React.ReactNode;
+    multiSelect?: boolean;
+    maxSelections?: number;
+    showSelectedCount?: boolean;
+    showAsTags?: boolean;
+    allowTextInput?: boolean;
+    onCreateOption?: (inputValue: string) => DropdownOption | Promise<DropdownOption>;
+    createOptionLabel?: string;
+    allowCustomValues?: boolean;
+    allowCustomInput?: boolean;
+    trackEdits?: boolean;
+    originalValue?: string | number | string[];
+    isEdited?: boolean;
+    variant?: 'default' | 'compact' | 'detailed';
+    size?: 'sm' | 'md' | 'lg';
+    contentClassName?: string;
+    /** Header title for select all section */
+    selectAllLabel?: string;
+    /** Show "ONLY" button on hover (like OTIF) */
+    showOnlyButton?: boolean;
+    /** Custom trigger element - replaces default trigger button */
+    customTrigger?: React.ReactNode;
+}
+
+declare function Dropdown({ options, value, placeholder, onValueChange, onOpen, disabled, loading, searchable, clearable, className, error, label, labelExtra, required, emptyMessage, triggerClassName, autoWidth, customFooter, multiSelect, maxSelections, showSelectedCount, showAsTags, allowTextInput, onCreateOption, createOptionLabel, allowCustomValues, allowCustomInput, variant, size, contentClassName, selectAllLabel, showOnlyButton, customTrigger }: DropdownProps): react_jsx_runtime.JSX.Element;
+
+type CurrencyCode = string;
+interface CurrencyInfo {
+    code: string;
+    name: string;
+    symbol: string;
+    flag: string;
+    decimal: number;
+}
+interface ExchangeRates {
+    [key: string]: number;
+}
+interface CurrencyContextType {
+    selectedCurrency: CurrencyCode;
+    baseCurrency: CurrencyCode;
+    exchangeRates: ExchangeRates;
+    availableCurrencies: CurrencyInfo[];
+    isLoading: boolean;
+    lastUpdated: Date | null;
+    error: string | null;
+    setCurrency: (currency: CurrencyCode) => void;
+    refreshRates: () => Promise<void>;
+    convertAmount: (amount: number, from?: CurrencyCode, to?: CurrencyCode) => number;
+    formatCurrency: (amount: number, currency?: CurrencyCode, options?: {
+        showSymbol?: boolean;
+        locale?: string;
+        compact?: boolean;
+        precision?: number;
+    }) => string;
+    parseCurrencyInput: (input: string, currency?: CurrencyCode) => number | null;
+    getCurrencyInfo: (currency: CurrencyCode) => CurrencyInfo | null;
+    getAllCurrencies: () => CurrencyInfo[];
+    setManualRate: (from: CurrencyCode, to: CurrencyCode, rate: number) => void;
+    removeManualRate: (from: CurrencyCode, to: CurrencyCode) => void;
+    isManualRate: (from: CurrencyCode, to: CurrencyCode) => boolean;
+}
+declare function CurrencyProvider({ children, baseCurrencyCode }: {
+    children: React__default.ReactNode;
+    baseCurrencyCode?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function useCurrency(): CurrencyContextType;
+
+interface UnifiedCurrencyDropdownProps {
+    value?: CurrencyCode;
+    onValueChange?: (currency: CurrencyCode) => void;
+    amount?: number;
+    onAmountChange?: (amount: number) => void;
+    showRates?: boolean;
+    showConverter?: boolean;
+    allowManualRates?: boolean;
+    className?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'default' | 'compact' | 'detailed';
+    validation?: {
+        min?: number;
+        max?: number;
+        required?: boolean;
+        customValidator?: (value: CurrencyCode) => string | null;
+    };
+    error?: string;
+}
+declare function UnifiedCurrencyDropdown({ value, onValueChange, amount, onAmountChange, showRates, showConverter, allowManualRates, className, label, placeholder, disabled, required, size, variant, validation, error }: UnifiedCurrencyDropdownProps): react_jsx_runtime.JSX.Element;
+
+interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+interface DatePickerProps {
+    value?: Date | DateRange | string;
+    onChange?: (date: Date | DateRange | string | undefined) => void;
+    mode?: 'single' | 'range';
+    placeholder?: string;
+    label?: string;
+    error?: string;
+    disabled?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    className?: string;
+    showTime?: boolean;
+    showFromTo?: boolean;
+    returnFormat?: 'date' | 'string';
+    /** Show calendar inline without trigger/popover */
+    inline?: boolean;
+    /** Render just a calendar icon button as the trigger (for use inside search bars) */
+    iconOnly?: boolean;
+    /** Alignment of the popover relative to the trigger */
+    popoverAlign?: 'start' | 'center' | 'end';
+    presets?: Array<{
+        label: string;
+        value: Date | DateRange;
+    }>;
+}
+declare function DatePicker({ value, onChange, mode, placeholder, label, error, disabled, minDate, maxDate, className, showTime, showFromTo, returnFormat, inline, iconOnly, popoverAlign, presets }: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface DateTimePickerProps {
+    value?: Date | string;
+    onChange?: (date: Date | string | undefined) => void;
+    placeholder?: string;
+    label?: string;
+    error?: string;
+    disabled?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    className?: string;
+    returnFormat?: 'date' | 'string';
+    timeFormat?: '12h' | '24h';
+}
+declare function DateTimePicker({ value, onChange, placeholder, label, error, disabled, minDate, maxDate, className, returnFormat, timeFormat }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
+
+interface AttachedFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    url?: string;
+    file?: File;
+}
+interface FileAttachmentProps {
+    value?: AttachedFile[];
+    onChange?: (files: AttachedFile[]) => void;
+    maxFiles?: number;
+    maxFileSize?: number;
+    acceptedFileTypes?: string[];
+    label?: string;
+    className?: string;
+    disabled?: boolean;
+    showInlinePreview?: boolean;
+    previewShape?: 'circular' | 'rectangular';
+    previewSize?: 'sm' | 'md' | 'lg';
+    hideInstructions?: boolean;
+    enableEmailImport?: boolean;
+}
+declare function FileAttachment({ value, onChange, maxFiles, maxFileSize, // 10MB
+acceptedFileTypes, label, className, disabled, showInlinePreview, previewShape, previewSize, hideInstructions, enableEmailImport }: FileAttachmentProps): react_jsx_runtime.JSX.Element;
+
+interface CardProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    children: React__default.ReactNode;
+}
+declare const Card: React__default.FC<CardProps>;
+declare const CardHeader: React__default.FC<CardProps>;
+declare const CardTitle: React__default.FC<CardProps>;
+declare const CardDescription: React__default.FC<CardProps>;
+declare const CardContent: React__default.FC<CardProps>;
+declare const CardFooter: React__default.FC<CardProps>;
+
+interface StatsCardProps {
+    title: string;
+    value: string | number;
+    icon?: LucideIcon;
+    trend?: {
+        value: number;
+        direction: 'up' | 'down';
+        label?: string;
+    };
+    description?: string;
+    className?: string;
+    variant?: 'default' | 'accent' | 'warning' | 'error';
+}
+declare function StatsCard({ title, value, icon: Icon, trend, description, className, variant }: StatsCardProps): react_jsx_runtime.JSX.Element;
+interface StatsGridProps {
+    children: React$1.ReactNode;
+    columns?: 1 | 2 | 3 | 4;
+    className?: string;
+}
+declare function StatsGrid({ children, columns, className }: StatsGridProps): react_jsx_runtime.JSX.Element;
+
+declare const textVariants: (props?: {
+    variant?: "primary" | "secondary" | "destructive" | "warning" | "success" | "link" | "default" | "muted" | "link-hover";
+    size?: "xs" | "sm" | "lg" | "base" | "xl" | "2xl" | "3xl" | "4xl";
+    weight?: "bold" | "normal" | "medium" | "semibold";
+    align?: "left" | "right" | "center" | "justify";
+} & class_variance_authority_types.ClassProp) => string;
+interface TextProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof textVariants> {
+    as?: 'span' | 'p' | 'div' | 'label' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    truncate?: boolean;
+}
+declare const Text: React$1.ForwardRefExoticComponent<TextProps & React$1.RefAttributes<HTMLElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Collapsible: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormToggleProps {
+    /** Whether the form section is expanded */
+    isExpanded: boolean;
+    /** Callback when toggle state changes */
+    onToggle: (expanded: boolean) => void;
+    /** Title to display in the header */
+    title?: string;
+    /** Title when creating new record */
+    createTitle?: string;
+    /** Title when editing existing record */
+    editTitle?: string;
+    /** Whether currently editing a record */
+    isEditing?: boolean;
+    /** Form content to display when expanded */
+    children: React__default.ReactNode;
+    /** Additional actions to show in header (right side) */
+    headerActions?: React__default.ReactNode;
+    /** Show "New" button when collapsed */
+    showNewButton?: boolean;
+    /** Custom "New" button text */
+    newButtonText?: string;
+    /** Custom class for the container */
+    className?: string;
+    /** Custom class for the content area */
+    contentClassName?: string;
+    /** Disable the toggle */
+    disabled?: boolean;
+    /** Show close button when expanded */
+    showCloseButton?: boolean;
+    /** Callback when close button is clicked (optional - defaults to just toggling) */
+    onClose?: () => void;
+}
+/**
+ * Reusable form toggle component for master modules
+ *
+ * Features:
+ * - Smooth expand/collapse animation
+ * - "New" button when collapsed
+ * - Customizable titles for create/edit modes
+ * - Header actions support
+ * - Fully themed with CSS variables
+ *
+ * @example
+ * ```tsx
+ * <FormToggle
+ *   isExpanded={isFormExpanded}
+ *   onToggle={setIsFormExpanded}
+ *   createTitle="Create New Company"
+ *   editTitle="Edit Company"
+ *   isEditing={!!editingCompany}
+ * >
+ *   <form>...</form>
+ * </FormToggle>
+ * ```
+ */
+declare function FormToggle({ isExpanded, onToggle, title, createTitle, editTitle, isEditing, children, headerActions, showNewButton, newButtonText, className, contentClassName, disabled, showCloseButton, onClose }: FormToggleProps): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: {
+    variant?: "secondary" | "outline" | "destructive" | "warning" | "success" | "orange" | "cyan" | "indigo" | "lime" | "pink" | "purple" | "teal" | "violet" | "default" | "department" | "module" | "danger" | "info" | "amber" | "emerald" | "sky" | "rose" | "primary-selected" | "warning-selected" | "success-selected" | "orange-selected" | "error-selected" | "primary-unselected" | "warning-unselected" | "success-unselected" | "orange-unselected" | "error-unselected";
+    size?: "sm" | "lg" | "default";
+} & class_variance_authority_types.ClassProp) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, size, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace Badge {
+    var displayName: string;
+}
+/**
+ * FilterBadge - Clickable badge for status filters
+ * Responsive: smaller on mobile, full text on desktop
+ */
+type FilterBadgeVariant = 'primary' | 'warning' | 'success' | 'orange' | 'error';
+interface FilterBadgeProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    label: string;
+    shortLabel?: string;
+    count: number;
+    variant: FilterBadgeVariant;
+    selected?: boolean;
+}
+declare function FilterBadge({ label, shortLabel, count, variant, selected, className, ...props }: FilterBadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace FilterBadge {
+    var displayName: string;
+}
+/**
+ * FilterBadgeGroup - Badges on desktop, compact dropdown on mobile
+ */
+interface FilterBadgeItem {
+    id: string;
+    label: string;
+    shortLabel?: string;
+    count: number;
+    variant: FilterBadgeVariant;
+}
+interface FilterBadgeGroupProps {
+    items: FilterBadgeItem[];
+    selected: string;
+    onSelect: (id: string) => void;
+    className?: string;
+}
+declare function FilterBadgeGroup({ items, selected, onSelect, className }: FilterBadgeGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace FilterBadgeGroup {
+    var displayName: string;
+}
+
+interface BooleanBadgeProps {
+    value: boolean;
+    variant?: 'success' | 'info' | 'primary';
+    className?: string;
+}
+declare const BooleanBadge: React__default.ForwardRefExoticComponent<BooleanBadgeProps & React__default.RefAttributes<HTMLSpanElement>>;
+
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "destructive" | "default";
+} & class_variance_authority_types.ClassProp) => string> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface TooltipDetailedProps extends React$1.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    title?: string;
+    actions?: Array<{
+        label: string;
+        shortcut?: string;
+    }>;
+}
+declare const TooltipDetailed: React$1.ForwardRefExoticComponent<TooltipDetailedProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Width of the skeleton (can be CSS value like '100%', '200px', etc.)
+     */
+    width?: string | number;
+    /**
+     * Height of the skeleton (can be CSS value like '40px', '2rem', etc.)
+     */
+    height?: string | number;
+    /**
+     * Border radius variant
+     */
+    variant?: 'default' | 'rounded' | 'circular';
+    /**
+     * Animation type
+     */
+    animation?: 'pulse' | 'wave' | 'none';
+}
+/**
+ * Skeleton component for loading states
+ * Provides visual placeholder while content is loading
+ *
+ * @example
+ * // Basic usage
+ * <Skeleton width="100%" height="40px" />
+ *
+ * // Circular avatar skeleton
+ * <Skeleton width="48px" height="48px" variant="circular" />
+ *
+ * // Multiple skeletons for form fields
+ * <div className="space-y-3">
+ *   <Skeleton width="100%" height="40px" />
+ *   <Skeleton width="100%" height="40px" />
+ *   <Skeleton width="60%" height="40px" />
+ * </div>
+ */
+declare function Skeleton({ width, height, variant, animation, className, style, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+/**
+ * Skeleton for text lines
+ */
+declare function SkeletonText({ lines, className }: {
+    lines?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Skeleton for form fields (matching your modal layout)
+ */
+declare function SkeletonFormFields({ count, columns }: {
+    count?: number;
+    columns?: number;
+}): react_jsx_runtime.JSX.Element;
+
+interface SkeletonTableProps {
+    rows?: number;
+    columns?: number;
+}
+/**
+ * Skeleton loading state for DataGrid tables
+ * Shows animated placeholder rows while data is loading
+ *
+ * @example
+ * {loading ? (
+ *   <SkeletonTable rows={10} columns={6} />
+ * ) : (
+ *   <DataGrid data={data} columns={columns} />
+ * )}
+ */
+declare function SkeletonTable({ rows, columns }: SkeletonTableProps): react_jsx_runtime.JSX.Element;
+
+declare const modalSizes: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    master: string;
+    fullscreen: string;
+};
+/**
+ * Modal wrapper — intercepts the device back button in standalone PWA mode.
+ * When a modal opens, a history entry is pushed. Pressing the device back
+ * button fires `popstate` which closes the modal instead of navigating away.
+ */
+declare function Modal({ open, onOpenChange, ...props }: DialogPrimitive.DialogProps): react_jsx_runtime.JSX.Element;
+/**
+ * ADAPTIVE TRIGGER
+ *
+ * On desktop: opens the modal dialog as normal.
+ * On mobile + mobilePageUrl: navigates to a dedicated page instead,
+ * so users get native back-button support and full-screen real estate.
+ */
+declare const ModalTrigger: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    mobilePageUrl?: string;
+    onMobileNavigate?: (url: string) => void;
+    mobileBreakpoint?: number;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ModalPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const ModalClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ModalOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * ADAPTIVE MODAL CONTENT
+ *
+ * Desktop: standard Radix dialog overlay (unchanged)
+ * Mobile: renders as a full-screen page with a back-arrow header.
+ *         No Radix overlay/portal — just a fixed div on top of everything.
+ *         ModalHeader/ModalTitle inside become the page header automatically.
+ */
+declare const ModalContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    hideCloseButton?: boolean;
+    disableOutsideClick?: boolean;
+    size?: keyof typeof modalSizes;
+} & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * ADAPTIVE HEADER
+ *
+ * Desktop: renders as normal header div
+ * Mobile page mode: renders as a sticky top bar with a back arrow (ChevronLeft)
+ *                   that closes the modal, plus the title inline
+ */
+declare const ModalHeader: {
+    ({ className, children, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ModalFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const ModalTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const Dialog: typeof Modal;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    mobilePageUrl?: string;
+    onMobileNavigate?: (url: string) => void;
+    mobileBreakpoint?: number;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    hideCloseButton?: boolean;
+    disableOutsideClick?: boolean;
+    size?: keyof typeof modalSizes;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, children, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+type AlertType = 'success' | 'error' | 'warning' | 'info' | 'confirmation' | 'critical' | 'loading';
+interface AlertAction {
+    label: string;
+    onClick: () => void;
+    variant?: 'primary' | 'secondary';
+    disabled?: boolean;
+}
+interface ModalAlertProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    type: AlertType;
+    title: string;
+    description: string;
+    actions?: AlertAction[];
+    showCloseButton?: boolean;
+    autoClose?: number;
+    preventClose?: boolean;
+    className?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+declare function ModalAlert({ open, onOpenChange, type, title, description, actions, showCloseButton, autoClose, preventClose, className, 'aria-labelledby': ariaLabelledby, 'aria-describedby': ariaDescribedby, ...props }: ModalAlertProps): react_jsx_runtime.JSX.Element;
+declare function useModalAlert(): {
+    alert: {
+        open: boolean;
+        type: AlertType;
+        title: string;
+        description: string;
+        actions?: AlertAction[];
+        autoClose?: number;
+    };
+    showAlert: (params: Omit<{
+        open: boolean;
+        type: AlertType;
+        title: string;
+        description: string;
+        actions?: AlertAction[];
+        autoClose?: number;
+    }, "open">) => void;
+    hideAlert: () => void;
+    showSuccess: (title: string, description: string, autoClose?: number) => void;
+    showError: (title: string, description: string) => void;
+    showWarning: (title: string, description: string, actions?: AlertAction[]) => void;
+    showInfo: (title: string, description: string, autoClose?: number) => void;
+    showConfirmation: (title: string, description: string, onConfirm: () => void, onCancel?: () => void) => void;
+    showLoading: (title: string, description: string) => void;
+    AlertComponent: () => react_jsx_runtime.JSX.Element;
+};
+
+declare const TabsRoot: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface TabItem {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    /** Dropdown options for this tab (for time filter style) */
+    dropdownOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+interface TabsProps {
+    tabs: TabItem[];
+    activeTab: string;
+    onTabChange: (tabId: string) => void;
+    fullWidth?: boolean;
+    className?: string;
+    /** Visual variant: 'pill' (default) or 'rounded' (square corners) */
+    variant?: 'pill' | 'rounded';
+    /** Size variant */
+    size?: 'sm' | 'md';
+    /** For dropdown mode: currently selected values per tab */
+    dropdownValues?: Record<string, string[]>;
+    /** For dropdown mode: callback when dropdown selection changes */
+    onDropdownChange?: (tabId: string, selectedValues: string[]) => void;
+}
+declare function Tabs({ tabs, activeTab, onTabChange, fullWidth, className, variant, size, dropdownValues, onDropdownChange }: TabsProps): react_jsx_runtime.JSX.Element;
+
+interface HeaderStepItem {
+    id: number;
+    label: string;
+    subtitle?: string;
+    icon?: LucideIcon;
+}
+interface HeaderStepsProps {
+    steps: HeaderStepItem[];
+    currentStep: number;
+    onStepClick?: (stepId: number) => void;
+    className?: string;
+}
+declare function HeaderSteps({ steps, currentStep, onStepClick, className }: HeaderStepsProps): react_jsx_runtime.JSX.Element;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PageLoadingProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg';
+    text?: string;
+    color?: string;
+    speed?: string;
+}
+declare const PageLoading: React$1.ForwardRefExoticComponent<PageLoadingProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface LoadingProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    text?: string;
+    variant?: 'spinner' | 'cradle' | 'pendulum' | 'pulse' | 'dots';
+    color?: string;
+}
+declare const Loading: React$1.ForwardRefExoticComponent<LoadingProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const LoadingStates: {
+    Saving: () => react_jsx_runtime.JSX.Element;
+    Loading: () => react_jsx_runtime.JSX.Element;
+    Processing: () => react_jsx_runtime.JSX.Element;
+    Calculating: () => react_jsx_runtime.JSX.Element;
+    Generating: () => react_jsx_runtime.JSX.Element;
+    Validating: () => react_jsx_runtime.JSX.Element;
+    Exporting: () => react_jsx_runtime.JSX.Element;
+    Importing: () => react_jsx_runtime.JSX.Element;
+    Syncing: () => react_jsx_runtime.JSX.Element;
+    Connecting: () => react_jsx_runtime.JSX.Element;
+    Authenticating: () => react_jsx_runtime.JSX.Element;
+    SigningIn: () => react_jsx_runtime.JSX.Element;
+    Inline: ({ size }: {
+        size?: "sm" | "md";
+    }) => react_jsx_runtime.JSX.Element;
+    InlinePendulum: ({ size }: {
+        size?: "sm" | "md";
+    }) => react_jsx_runtime.JSX.Element;
+    InlineCradle: ({ size }: {
+        size?: "sm" | "md";
+    }) => react_jsx_runtime.JSX.Element;
+};
+declare function LoadingOverlay({ isVisible, text, variant, size }: {
+    isVisible: boolean;
+    text?: string;
+    variant?: LoadingProps['variant'];
+    size?: LoadingProps['size'];
+}): react_jsx_runtime.JSX.Element;
+declare function NavigationProgress(): react_jsx_runtime.JSX.Element;
+
+interface DynamicSidebarProps {
+    isCollapsed?: boolean;
+    onMenuItemClick?: () => void;
+    onToggleSidebar?: () => void;
+    onQuickCreate?: (modulePath: string, moduleName: string) => void;
+    className?: string;
+    companyId?: number;
+    userId?: number;
+}
+declare function DynamicSidebar({ isCollapsed, onMenuItemClick, onToggleSidebar, onQuickCreate, className, companyId, userId }: DynamicSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface FooterKPI {
+    id: string;
+    label: string;
+    value: string | number;
+    trend?: {
+        value: number;
+        direction: 'up' | 'down';
+    };
+    onClick?: () => void;
+}
+interface FooterIconButton {
+    id: string;
+    icon: LucideIcon;
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+    disabled?: boolean;
+}
+interface FooterProps {
+    kpis?: FooterKPI[];
+    actions?: React$1.ReactNode;
+    iconButtons?: FooterIconButton[];
+    leftContent?: React$1.ReactNode;
+    className?: string;
+    sticky?: boolean;
+    compact?: boolean;
+    padding?: 'compact' | 'normal' | 'medium';
+    variant?: 'page' | 'modal';
+    gradient?: boolean;
+}
+declare function Footer({ kpis, actions, iconButtons, leftContent, className, sticky, compact, padding, variant, gradient }: FooterProps): react_jsx_runtime.JSX.Element;
+declare function CompactFooter({ className, children }: {
+    className?: string;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface AppShellProps {
+    children: React$1.ReactNode;
+    sidebar?: DynamicSidebarProps;
+    footer?: FooterProps;
+    className?: string;
+}
+declare function AppShell({ children, sidebar, footer, className }: AppShellProps): react_jsx_runtime.JSX.Element;
+interface PageProps {
+    children: React$1.ReactNode;
+    title?: string;
+    description?: string;
+    actions?: React$1.ReactNode;
+    className?: string;
+    maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+    padding?: boolean;
+}
+declare function Page({ children, title, description, actions, className, maxWidth, padding }: PageProps): react_jsx_runtime.JSX.Element;
+interface GridProps {
+    children: React$1.ReactNode;
+    columns?: {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    gap?: number;
+    className?: string;
+}
+declare function Grid({ children, columns, gap, className }: GridProps): react_jsx_runtime.JSX.Element;
+
+interface FABAction {
+    label: string;
+    onClick: () => void;
+}
+interface FloatingActionButtonProps {
+    actions: FABAction[];
+    className?: string;
+}
+declare function FloatingActionButton({ actions, className }: FloatingActionButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Summary aggregation types
+ */
+type SummaryAggregationType = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'custom';
+/**
+ * Summary configuration for a column
+ */
+interface ColumnSummary<TData = any> {
+    type: SummaryAggregationType;
+    label?: string;
+    customFn?: (data: TData[]) => string | number;
+    format?: (value: number) => string;
+    className?: string;
+    customValue?: () => string | number;
+}
+/**
+ * Summary configuration for the entire grid
+ */
+interface SummaryConfig<TData = any> {
+    columns: Record<string, ColumnSummary<TData>>;
+    position?: 'top' | 'bottom';
+    style?: React.CSSProperties;
+    className?: string;
+}
+
+interface DataGridProps<TData> {
+    data: TData[];
+    columns: ColumnDef<TData>[];
+    onRowClick?: (row: TData) => void;
+    onRowContextMenu?: (row: TData, event: React__default.MouseEvent) => void;
+    onRowSelect?: (selectedRows: TData[]) => void;
+    onImport?: (data: TData[]) => void;
+    selectedRowIds?: string[];
+    getRowId?: (row: TData) => string;
+    getRowProps?: (row: TData) => {
+        className?: string;
+        style?: React__default.CSSProperties;
+    };
+    enableViewToggle?: boolean;
+    viewMode?: 'all' | 'selected';
+    onViewModeChange?: (mode: 'all' | 'selected') => void;
+    enableVirtualization?: boolean;
+    enableColumnResizing?: boolean;
+    enableColumnReordering?: boolean;
+    enableColumnFreezing?: boolean;
+    frozenColumns?: string[];
+    rightFrozenColumns?: string[];
+    enableGrouping?: boolean;
+    groupByColumns?: string[];
+    onGroupingChange?: (grouping: string[]) => void;
+    enableExport?: boolean;
+    enableImport?: boolean;
+    enableVisualization?: boolean;
+    enableStickyActions?: boolean;
+    enableRowSelection?: boolean;
+    enableSorting?: boolean;
+    defaultSortBy?: string;
+    defaultSortOrder?: 'asc' | 'desc';
+    initialColumnVisibility?: Record<string, boolean>;
+    enableSearch?: boolean;
+    enableFiltering?: boolean;
+    enableColumnVisibility?: boolean;
+    pageSize?: number;
+    stickyHeader?: boolean;
+    className?: string;
+    title?: string;
+    description?: string;
+    headerActions?: React__default.ReactNode;
+    headerActionsRight?: React__default.ReactNode;
+    preToggleActions?: React__default.ReactNode;
+    loading?: boolean;
+    hideHeader?: boolean;
+    compactHeader?: boolean;
+    columnResizeMode?: 'onChange' | 'onEnd';
+    style?: React__default.CSSProperties;
+    compactMode?: boolean;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    rowHeight?: number;
+    mainColumns?: string;
+    enableBacchaSearch?: boolean;
+    searchType?: 'advanced' | 'new';
+    enablePagination?: boolean;
+    paginationPageSize?: number;
+    paginationPageSizeOptions?: number[];
+    circularCheckboxes?: boolean;
+    enableAutoResize?: boolean;
+    rowSelectionMode?: 'single' | 'multi';
+    enableRowClickSelection?: boolean;
+    enableCtrlClickMultiSelect?: boolean;
+    enableShiftClickRange?: boolean;
+    singleSelectionStyle?: 'radio' | 'highlight';
+    enableRowReordering?: boolean;
+    onRowOrderChange?: (reorderedData: TData[]) => void;
+    hideSelectionInSelectedView?: boolean;
+    renderSubComponent?: (row: Row<TData>) => React__default.ReactNode;
+    getRowCanExpand?: (row: Row<TData>) => boolean;
+    /** 'basic' = custom content in colSpan td, 'detailed' = real grid rows from subData */
+    expandMode?: 'basic' | 'detailed';
+    /** Return sub-data items for a row (used in detailed mode) */
+    getSubData?: (row: TData) => TData[];
+    /** Row ID accessor for sub-rows in detailed mode */
+    getSubRowId?: (row: TData) => string;
+    /** Callback when a sub-row is clicked in detailed mode */
+    onSubRowClick?: (item: TData) => void;
+    /** Callback when a sub-row is selected — propagates to parent for footer actions */
+    onSubRowSelect?: (item: TData) => void;
+    /** Auto-expand all expandable rows by default */
+    defaultExpandAll?: boolean;
+    enableDateFilter?: boolean;
+    dateFrom?: Date | null;
+    dateTo?: Date | null;
+    onDateFromChange?: (date: Date | null) => void;
+    onDateToChange?: (date: Date | null) => void;
+    /** Actions to render just before the date picker (left of date picker) */
+    preDateActions?: React__default.ReactNode;
+    enableSummary?: boolean;
+    summaryConfig?: SummaryConfig<TData>;
+    enableFilterRow?: boolean;
+    /**
+     * Optional initial values for the column filter row. Seeded into state on mount and
+     * re-applied when the prop reference changes (so modals can pre-filter on open).
+     */
+    initialColumnFilters?: ColumnFiltersState;
+}
+declare function DataGrid<TData>({ data, columns: initialColumns, onRowClick, onRowContextMenu, onRowSelect, onImport, selectedRowIds, getRowId, getRowProps, enableViewToggle, viewMode, onViewModeChange, enableVirtualization, enableColumnResizing, enableColumnReordering, enableColumnFreezing, frozenColumns, rightFrozenColumns, enableGrouping, groupByColumns, onGroupingChange, enableExport, enableImport, enableVisualization, enableStickyActions, enableRowSelection, enableSorting, defaultSortBy, defaultSortOrder, initialColumnVisibility, enableSearch, enableFiltering, enableColumnVisibility, pageSize, stickyHeader, className, title, description, headerActions, headerActionsRight, preToggleActions, loading, hideHeader, compactHeader, columnResizeMode, style, compactMode, minHeight, maxHeight, // Default: standard mode, responsive to screen height
+rowHeight, mainColumns, enableBacchaSearch, searchType, enablePagination, paginationPageSize, paginationPageSizeOptions, circularCheckboxes, enableAutoResize, rowSelectionMode, enableRowClickSelection, enableCtrlClickMultiSelect, enableShiftClickRange, singleSelectionStyle, enableRowReordering, onRowOrderChange, hideSelectionInSelectedView, renderSubComponent, getRowCanExpand, expandMode, getSubData, getSubRowId, onSubRowClick, onSubRowSelect, defaultExpandAll, enableDateFilter, preDateActions, enableSummary, summaryConfig, dateFrom, dateTo, onDateFromChange, onDateToChange, enableFilterRow, initialColumnFilters, }: DataGridProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface PaginationControlsProps {
+    pageIndex: number;
+    pageSize: number;
+    totalRows: number;
+    pageSizeOptions?: number[];
+    onPageChange: (pageIndex: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+}
+declare function PaginationControls({ pageIndex, pageSize, totalRows, pageSizeOptions, onPageChange, onPageSizeChange, }: PaginationControlsProps): react_jsx_runtime.JSX.Element;
+
+interface AutoResizeButtonProps {
+    onAutoResize: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare function AutoResizeButton({ onAutoResize, disabled, className, }: AutoResizeButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ActionsMenuProps<TData> {
+    enableVisualization?: boolean;
+    currentView: 'grid' | 'chart' | 'cards';
+    onViewChange: (view: 'grid' | 'chart' | 'cards') => void;
+    enableExport?: boolean;
+    enableImport?: boolean;
+    data: TData[];
+    filename?: string;
+    onImportComplete: (data: TData[]) => void;
+    enableColumnVisibility?: boolean;
+    onOpenColumnChooser: () => void;
+    enableAutoResize?: boolean;
+    onAutoResize?: () => void;
+    enableDateFilter?: boolean;
+    dateFrom?: Date | null;
+    dateTo?: Date | null;
+    onDateFromChange?: (date: Date | null) => void;
+    onDateToChange?: (date: Date | null) => void;
+    enableFiltering?: boolean;
+    onOpenAdvancedFilter: () => void;
+    activeFiltersCount?: number;
+    enableGrouping?: boolean;
+    columns?: Column<TData, unknown>[];
+    grouping?: string[];
+    onGroupingChange?: (columnId: string) => void;
+    onClearGrouping?: () => void;
+}
+declare function ActionsMenu<TData>({ enableVisualization, currentView, onViewChange, enableExport, enableImport, data, filename, onImportComplete, enableColumnVisibility, onOpenColumnChooser, enableAutoResize, onAutoResize, enableDateFilter, dateFrom, dateTo, onDateFromChange, onDateToChange, enableFiltering, onOpenAdvancedFilter, activeFiltersCount, enableGrouping, columns, grouping, onGroupingChange, onClearGrouping }: ActionsMenuProps<TData>): react_jsx_runtime.JSX.Element;
+
+type CardSize = 'compact' | 'normal' | 'expanded';
+interface CardViewProps<TData> {
+    data: TData[];
+    columns: ColumnDef<TData>[];
+    onRowClick?: (item: TData) => void;
+    selectedRows: TData[];
+    onRowSelect?: (item: TData, selected: boolean) => void;
+    isLoading?: boolean;
+    cardSize?: CardSize;
+    circularCheckboxes?: boolean;
+}
+declare function CardView<TData>({ data, columns, onRowClick, selectedRows, onRowSelect, isLoading, cardSize, circularCheckboxes, }: CardViewProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DataVisualizationProps<TData> {
+    data: TData[];
+    columns: ColumnDef<TData>[];
+    title?: string;
+}
+declare function DataVisualization<TData>({ data, columns, title }: DataVisualizationProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface ColumnChooserModalProps<TData> {
+    isOpen: boolean;
+    onClose: () => void;
+    table: Table<TData>;
+    frozenColumnsState: Set<string>;
+    setFrozenColumnsState: (columns: Set<string>) => void;
+    enableColumnFreezing?: boolean;
+    autoResizeAllColumns?: (table: Table<TData>) => void;
+}
+declare function ColumnChooserModal<TData>({ isOpen, onClose, table, frozenColumnsState, setFrozenColumnsState, enableColumnFreezing, autoResizeAllColumns }: ColumnChooserModalProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface FilterCondition {
+    id: string;
+    column: string;
+    operator: string;
+    value: any;
+    type: 'string' | 'number' | 'date' | 'boolean' | 'multi-select';
+}
+type TabId = 'filters' | 'columns' | 'sort';
+interface AdvancedFilterModalProps<TData> {
+    isOpen: boolean;
+    onClose: () => void;
+    onApply: (filters: FilterCondition[]) => void;
+    columns: ColumnDef<TData>[];
+    data: TData[];
+    table?: Table<TData>;
+    sorting?: SortingState;
+    onSortingChange?: (sorting: SortingState) => void;
+    enableGrouping?: boolean;
+    grouping?: string[];
+    onGroupingChange?: (columnId: string) => void;
+    onClearGrouping?: () => void;
+    initialTab?: TabId;
+}
+declare function AdvancedFilterModal<TData>({ isOpen, onClose, onApply, columns, data, table, sorting, onSortingChange, enableGrouping, grouping, onGroupingChange, onClearGrouping, initialTab, }: AdvancedFilterModalProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface DraggableColumnHeaderProps<TData> {
+    header: Header<TData, unknown>;
+    enableReordering?: boolean;
+    enableResizing?: boolean;
+    enableFreezing?: boolean;
+    enableGrouping?: boolean;
+    isGrouped?: boolean;
+    isFrozen?: boolean;
+    isLastFrozen?: boolean;
+    isFirstPinnedRight?: boolean;
+    isLastColumn?: boolean;
+    onRightClick?: (header: Header<TData, unknown>, event: React__default.MouseEvent) => void;
+    onFilterClick?: (header: Header<TData, unknown>, event: React__default.MouseEvent) => void;
+    style?: React__default.CSSProperties;
+}
+declare function DraggableColumnHeader<TData>({ header, enableReordering, enableResizing, enableFreezing, enableGrouping, isGrouped, isFrozen, isLastFrozen, isFirstPinnedRight, isLastColumn, onRightClick, onFilterClick, style, }: DraggableColumnHeaderProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface ColumnContextMenuProps<TData> {
+    column: Column<TData, unknown>;
+    data: TData[];
+    isVisible: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    onClose: () => void;
+    onApplyFilter: (columnId: string, filterType: string, value: any) => void;
+}
+declare function ColumnContextMenu<TData>({ column, data, isVisible, position, onClose, onApplyFilter, }: ColumnContextMenuProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface ActionsColumnConfig<TData = any> {
+    /**
+     * Module-level permissions. When provided, actions that require a permission
+     * the user lacks are automatically hidden — no need to set showEdit/showDelete manually.
+     *
+     * canEdit   → controls: edit button (modify existing records)
+     * canSave   → controls: duplicate (creates a new record)
+     * canDelete → controls: delete, archive (destructive operations)
+     * canExport → controls: export
+     * canPrint  → controls: print
+     * canCancel → controls: block (cancel/block operations)
+     *
+     * Individual show* props still work as a further per-row override on top of permissions.
+     */
+    permissions?: {
+        canEdit?: boolean;
+        canSave?: boolean;
+        canDelete?: boolean;
+        canExport?: boolean;
+        canPrint?: boolean;
+        canCancel?: boolean;
+    };
+    onView?: (row: TData) => void;
+    onEdit?: (row: TData) => void;
+    onDelete?: (row: TData) => void;
+    onDuplicate?: (row: TData) => void;
+    onTarget?: (row: TData) => void;
+    onPin?: (row: TData, pinned: boolean) => void;
+    onFavorite?: (row: TData, favorited: boolean) => void;
+    onArchive?: (row: TData) => void;
+    onRestore?: (row: TData) => void;
+    onExport?: (row: TData) => void;
+    onPrint?: (row: TData) => void;
+    onCopy?: (row: TData) => void;
+    onShare?: (row: TData) => void;
+    onBlock?: (row: TData, blocked: boolean) => void;
+    showView?: boolean | ((row: TData) => boolean);
+    showEdit?: boolean | ((row: TData) => boolean);
+    showDelete?: boolean | ((row: TData) => boolean);
+    showDuplicate?: boolean | ((row: TData) => boolean);
+    showTarget?: boolean | ((row: TData) => boolean);
+    showPin?: boolean | ((row: TData) => boolean);
+    showFavorite?: boolean | ((row: TData) => boolean);
+    showArchive?: boolean | ((row: TData) => boolean);
+    showRestore?: boolean | ((row: TData) => boolean);
+    showExport?: boolean | ((row: TData) => boolean);
+    showPrint?: boolean | ((row: TData) => boolean);
+    showCopy?: boolean | ((row: TData) => boolean);
+    showShare?: boolean | ((row: TData) => boolean);
+    showBlock?: boolean | ((row: TData) => boolean);
+    isPinned?: (row: TData) => boolean;
+    isFavorited?: (row: TData) => boolean;
+    isArchived?: (row: TData) => boolean;
+    isProtected?: (row: TData) => boolean;
+    isBlocked?: (row: TData) => boolean;
+    mode?: 'buttons' | 'dropdown' | 'mixed';
+    primaryActions?: ActionType[];
+    maxVisibleActions?: number;
+    confirmDelete?: boolean;
+    confirmArchive?: boolean;
+    showStatusBadges?: boolean;
+    labels?: {
+        view?: string;
+        edit?: string;
+        delete?: string;
+        duplicate?: string;
+        target?: string;
+        pin?: string;
+        unpin?: string;
+        favorite?: string;
+        unfavorite?: string;
+        archive?: string;
+        restore?: string;
+        export?: string;
+        print?: string;
+        copy?: string;
+        share?: string;
+        block?: string;
+        unblock?: string;
+    };
+    deleteConfirmation?: {
+        title?: string;
+        description?: string;
+    };
+    archiveConfirmation?: {
+        title?: string;
+        description?: string;
+    };
+    blockConfirmation?: {
+        title?: string;
+        description?: string;
+    };
+}
+type ActionType = 'view' | 'edit' | 'delete' | 'duplicate' | 'target' | 'pin' | 'favorite' | 'archive' | 'restore' | 'export' | 'print' | 'copy' | 'share' | 'block';
+interface ActionsColumnProps<TData> {
+    row: {
+        original: TData;
+    };
+    config: ActionsColumnConfig<TData>;
+}
+declare function ActionsColumn<TData>({ row, config, }: ActionsColumnProps<TData>): react_jsx_runtime.JSX.Element;
+/**
+ * Helper function to create an actions column definition for DataGrid
+ *
+ * @example
+ * const columns = [
+ *   { accessorKey: 'name', header: 'Name' },
+ *   { accessorKey: 'email', header: 'Email' },
+ *   createActionsColumn({
+ *     onEdit: handleEdit,
+ *     onDelete: handleDelete,
+ *     showEdit: true,
+ *     showDelete: true,
+ *     mode: 'buttons'
+ *   })
+ * ]
+ */
+declare function createActionsColumn<TData>(config: ActionsColumnConfig<TData>): {
+    id: string;
+    header: () => react_jsx_runtime.JSX.Element;
+    cell: ({ row }: {
+        row: {
+            original: TData;
+        };
+    }) => react_jsx_runtime.JSX.Element;
+    enableSorting: boolean;
+    enableHiding: boolean;
+    enableColumnFilter: boolean;
+    size: number;
+};
+
+declare function createSelectColumn<TData>(): ColumnDef<TData>;
+
+interface ExpandableRowProps<TData> {
+    row: Row<TData>;
+    renderSubComponent?: (row: Row<TData>) => React__default.ReactNode;
+    /** 'basic' = custom content in colSpan td, 'detailed' = real grid rows from subData */
+    expandMode?: 'basic' | 'detailed';
+    /** Data items to render as rows in detailed mode */
+    subData?: TData[];
+    /** Column definitions for detailed mode (should match parent grid columns) */
+    subColumns?: ColumnDef<TData, any>[];
+    /** Row ID accessor for detailed mode */
+    getSubRowId?: (row: TData) => string;
+    /** Callback when a sub-row is clicked in detailed mode */
+    onSubRowClick?: (item: TData) => void;
+    /** Callback when a sub-row is selected (clicked) — propagates selection to parent */
+    onSubRowSelect?: (item: TData) => void;
+    onRowClick?: (e: React__default.MouseEvent) => void;
+    onRowDoubleClick?: () => void;
+    onRowContextMenu?: (e: React__default.MouseEvent) => void;
+    className?: string;
+    rowHeight?: number;
+    children: React__default.ReactNode;
+}
+declare function ExpandableRow<TData>({ row, renderSubComponent, expandMode, subData, subColumns, getSubRowId, onSubRowClick, onSubRowSelect, onRowClick, onRowDoubleClick, onRowContextMenu, className, rowHeight, children }: ExpandableRowProps<TData>): react_jsx_runtime.JSX.Element;
+interface ExpansionToggleCellProps<TData> {
+    row: Row<TData>;
+}
+declare function ExpansionToggleCell<TData>({ row }: ExpansionToggleCellProps<TData>): react_jsx_runtime.JSX.Element;
+declare function ExpansionToggleHeader({ table }: {
+    table: any;
+}): react_jsx_runtime.JSX.Element;
+interface ProcessBreakdownProps {
+    processes: Array<{
+        name: string;
+        totalCost: number;
+        unitCost: number;
+    }>;
+}
+declare function ProcessBreakdown({ processes }: ProcessBreakdownProps): react_jsx_runtime.JSX.Element;
+
+interface DraggableRowProps<TData> {
+    row: Row<TData>;
+    rowIndex: number;
+    enableBacchaSearch?: boolean;
+    mainColumnsArray?: string[];
+    frozenColumnsState?: Set<string>;
+    isHighlighted?: boolean;
+    isSelected?: boolean;
+    onRowClick?: (e: React__default.MouseEvent) => void;
+    onRowDoubleClick?: () => void;
+    onRowContextMenu?: (e: React__default.MouseEvent) => void;
+    showDragHandle?: boolean;
+    navigationState?: {
+        searchTerm?: string;
+    };
+    columnSearches?: Record<string, string>;
+    isColumnSearchActive?: Record<string, boolean>;
+    onColumnSearch?: (columnId: string, rowId: string, value: string) => void;
+    onClearColumnSearch?: (columnId: string) => void;
+    SearchHighlighter?: React__default.ComponentType<{
+        text: string;
+        searchTerm: string;
+    }>;
+    InlineSearchCell?: React__default.ComponentType<any>;
+}
+declare function DraggableRow<TData>({ row, rowIndex, enableBacchaSearch, mainColumnsArray, frozenColumnsState, isHighlighted, isSelected, onRowClick, onRowDoubleClick, onRowContextMenu, showDragHandle, navigationState, columnSearches, isColumnSearchActive, onColumnSearch, onClearColumnSearch, SearchHighlighter, InlineSearchCell, }: DraggableRowProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface SummaryRowProps<TData> {
+    table: Table<TData>;
+    data: TData[];
+    config: SummaryConfig<TData> | SummaryConfig<TData>[];
+    enableRowSelection?: boolean;
+    showDragHandle?: boolean;
+}
+declare function SummaryRow<TData>({ table, data, config, enableRowSelection, showDragHandle }: SummaryRowProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface EditableCellProps$1 {
+    value: any;
+    rowId?: string;
+    columnId?: string;
+    onSave: ((rowId: string, columnId: string, newValue: any) => void) | ((newValue: any) => void);
+    onCancel?: () => void;
+    onNavigate?: (direction: 'next' | 'previous') => void;
+    editable?: boolean;
+    type?: 'text' | 'number' | 'date' | 'email' | 'dropdown';
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    className?: string;
+    formatDisplay?: (value: number) => string;
+    currencySymbol?: string;
+    trackEdits?: boolean;
+    originalValue?: any;
+    isEdited?: boolean;
+}
+declare function EditableCell$1({ value, rowId, columnId, onSave, onCancel, onNavigate, editable, type, options, className, formatDisplay, currencySymbol, trackEdits, originalValue, isEdited: externalIsEdited }: EditableCellProps$1): react_jsx_runtime.JSX.Element;
+declare const EditableTableCell: typeof EditableCell$1;
+declare function useCellEditing<TData>(): {
+    data: TData[];
+    setData: React__default.Dispatch<React__default.SetStateAction<TData[]>>;
+    editingCell: {
+        rowId: string;
+        columnId: string;
+    };
+    startEditing: (rowId: string, columnId: string) => void;
+    isEditing: (rowId: string, columnId: string) => boolean;
+    handleCellSave: (rowId: string, columnId: string, newValue: any) => void;
+    handleCellCancel: () => void;
+};
+
+interface CellRendererProps<TData> {
+    cell: Cell<TData, unknown>;
+    cellIndex: number;
+    row: any;
+    enableBacchaSearch?: boolean;
+    mainColumnsArray?: string[];
+    frozenColumnsState?: Set<string>;
+    navigationState?: {
+        searchTerm?: string;
+    };
+    columnSearches?: Record<string, string>;
+    isColumnSearchActive?: Record<string, boolean>;
+    onColumnSearch?: (columnId: string, rowId: string, value: string) => void;
+    onClearColumnSearch?: (columnId: string) => void;
+    SearchHighlighter?: React__default.ComponentType<{
+        text: string;
+        searchTerm: string;
+    }>;
+    InlineSearchCell?: React__default.ComponentType<any>;
+    isSelected?: boolean;
+}
+declare function CellRenderer<TData>({ cell, cellIndex, row, enableBacchaSearch, mainColumnsArray, frozenColumnsState, navigationState, columnSearches, isColumnSearchActive, onColumnSearch, onClearColumnSearch, SearchHighlighter, InlineSearchCell, isSelected }: CellRendererProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface SelectionCellProps {
+    checked: boolean;
+    indeterminate?: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    circular?: boolean;
+    mode?: 'checkbox' | 'radio';
+}
+declare function SelectionCell({ checked, indeterminate, onChange, disabled, circular, mode, }: SelectionCellProps): react_jsx_runtime.JSX.Element;
+
+interface BooleanCellProps {
+    value: boolean;
+    variant?: 'success' | 'info' | 'warning' | 'danger';
+}
+/**
+ * Standardized Boolean Cell Component for DataGrid
+ * Displays a compact checkmark or X icon in a colored circle
+ * Matches the Die availability column style from machine planning grid
+ */
+declare function BooleanCell({ value, variant }: BooleanCellProps): react_jsx_runtime.JSX.Element;
+declare namespace BooleanCell {
+    var displayName: string;
+}
+
+interface InlineSearchCellProps {
+    value: any;
+    columnId: string;
+    rowId: string;
+    onSearch: (columnId: string, searchTerm: string) => void;
+    onClearSearch: (columnId: string) => void;
+    isSearchActive: boolean;
+    searchTerm: string;
+    className?: string;
+}
+declare function InlineSearchCell({ value, columnId, rowId, onSearch, onClearSearch, isSearchActive, searchTerm, className }: InlineSearchCellProps): react_jsx_runtime.JSX.Element;
+
+interface SearchNavigationState {
+    currentIndex: number;
+    totalResults: number;
+    highlightedRowId: string | null;
+    searchTerm: string;
+}
+interface SearchNavigatorProps {
+    navigationState: SearchNavigationState;
+    onNavigate: (direction: 'up' | 'down') => void;
+    onSelect: (rowId: string) => void;
+    onClear: () => void;
+    searchInputRef?: React__default.RefObject<HTMLInputElement>;
+    enabled: boolean;
+}
+declare function SearchNavigator({ navigationState, onNavigate, onSelect, onClear, searchInputRef, enabled }: SearchNavigatorProps): any;
+declare function useSearchNavigation(scrollContainerRef?: React__default.RefObject<HTMLDivElement>): {
+    navigationState: SearchNavigationState;
+    updateSearchResults: (searchTerm: string, matchingRowIds: string[]) => void;
+    navigate: (direction: "up" | "down") => void;
+    selectRow: (rowId: string) => string;
+    clearNavigation: () => void;
+};
+
+interface SearchHighlighterProps {
+    text: string;
+    searchTerm: string;
+    className?: string;
+    highlightClassName?: string;
+}
+declare function SearchHighlighter({ text, searchTerm, className, highlightClassName }: SearchHighlighterProps): react_jsx_runtime.JSX.Element;
+declare function fuzzyMatch(text: string, searchTerm: string): boolean;
+declare function advancedSearch(data: any[], searchTerm: string, columns: any[], mainColumns?: string[]): {
+    matchingRows: any[];
+    rowIds: string[];
+    columnMatches: Record<string, string[]>;
+};
+
+interface SearchNewModalProps<TData> {
+    data: TData[];
+    columns: any[];
+    mainColumns?: string;
+    onRowSelect?: (rowId: string) => void;
+    selectedRows?: Set<string>;
+    className?: string;
+    onSearchClear?: () => void;
+}
+declare function SearchNewModal<TData>({ data, columns, mainColumns, onRowSelect, selectedRows, className, onSearchClear }: SearchNewModalProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface KeyboardNavigationConfig {
+    enableArrowKeys?: boolean;
+    enableTabNavigation?: boolean;
+    enableEnterToEdit?: boolean;
+    enableSpaceToSelect?: boolean;
+    enableCtrlA?: boolean;
+}
+declare function useKeyboardNavigation<TData>(table: Table<TData>, config?: KeyboardNavigationConfig): {
+    focusedCell: {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    setFocus: (rowIndex: number, columnIndex: number) => void;
+    clearFocus: () => void;
+    getCellClassName: (rowIndex: number, columnIndex: number) => "" | "ring-2 ring-blue-500 bg-blue-50";
+    moveFocus: (direction: "up" | "down" | "left" | "right") => void;
+};
+
+interface ClipboardConfig {
+    enableCopy?: boolean;
+    enablePaste?: boolean;
+    copyFormat?: 'csv' | 'tsv' | 'json';
+    includeHeaders?: boolean;
+}
+declare function useClipboard<TData>(table: Table<TData>, config?: ClipboardConfig): {
+    copyToClipboard: (customData?: string) => Promise<boolean>;
+    pasteFromClipboard: () => Promise<string>;
+    getSelectedData: () => {
+        rows: Row<TData>[];
+        columns: _tanstack_table_core.Column<TData, unknown>[];
+    };
+};
+
+interface CellPosition {
+    rowIndex: number;
+    columnIndex: number;
+}
+interface CellRange {
+    start: CellPosition;
+    end: CellPosition;
+}
+declare function useCellRangeSelection(): {
+    range: CellRange;
+    isSelecting: boolean;
+    handleMouseDown: (rowIndex: number, columnIndex: number, event: React.MouseEvent) => void;
+    handleMouseEnter: (rowIndex: number, columnIndex: number) => void;
+    handleMouseUp: () => void;
+    isCellInRange: (rowIndex: number, columnIndex: number) => boolean;
+    getCellClassName: (rowIndex: number, columnIndex: number) => string;
+    clearRange: () => void;
+    getSelectedCells: () => CellPosition[];
+    selectAll: (rowCount: number, columnCount: number) => void;
+};
+
+interface UseDataGridStateProps<TData> {
+    data: TData[];
+    selectedRowIds: string[];
+    enablePagination: boolean;
+    paginationPageSize: number;
+    frozenColumns: string[];
+    enableViewToggle: boolean;
+    viewMode: 'all' | 'selected';
+    enableRowReordering: boolean;
+    getRowId?: (row: TData) => string;
+}
+declare function useDataGridState<TData>({ data, selectedRowIds, enablePagination, paginationPageSize, frozenColumns, enableViewToggle, viewMode, enableRowReordering, getRowId, }: UseDataGridStateProps<TData>): {
+    sorting: SortingState;
+    setSorting: React$1.Dispatch<React$1.SetStateAction<SortingState>>;
+    columnFilters: ColumnFiltersState;
+    setColumnFilters: React$1.Dispatch<React$1.SetStateAction<ColumnFiltersState>>;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React$1.Dispatch<React$1.SetStateAction<VisibilityState>>;
+    rowSelection: Record<string, boolean>;
+    setRowSelection: React$1.Dispatch<React$1.SetStateAction<Record<string, boolean>>>;
+    globalFilter: string;
+    setGlobalFilter: React$1.Dispatch<React$1.SetStateAction<string>>;
+    expanded: ExpandedState;
+    setExpanded: React$1.Dispatch<React$1.SetStateAction<ExpandedState>>;
+    frozenColumnsState: Set<string>;
+    setFrozenColumnsState: React$1.Dispatch<React$1.SetStateAction<Set<string>>>;
+    reorderedData: TData[];
+    setReorderedData: React$1.Dispatch<React$1.SetStateAction<TData[]>>;
+    pagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    setPagination: React$1.Dispatch<React$1.SetStateAction<{
+        pageIndex: number;
+        pageSize: number;
+    }>>;
+    columnSearches: Record<string, string>;
+    setColumnSearches: React$1.Dispatch<React$1.SetStateAction<Record<string, string>>>;
+    isColumnSearchActive: Record<string, boolean>;
+    setIsColumnSearchActive: React$1.Dispatch<React$1.SetStateAction<Record<string, boolean>>>;
+    filteredData: TData[];
+    stableRowSelection: Record<string, boolean>;
+    safeSelectedCount: number;
+    toggleShouldBeVisible: boolean;
+};
+
+/**
+ * Export data to CSV format
+ */
+declare function exportToCSV<TData>(data: TData[], filename?: string): void;
+/**
+ * Export data to Excel format
+ */
+declare function exportToExcel<TData>(data: TData[], filename?: string): Promise<void>;
+/**
+ * Export data to PDF format
+ */
+declare function exportToPDF<TData>(data: TData[], filename?: string): void;
+/**
+ * Export data to JSON format
+ */
+declare function exportToJSON<TData>(data: TData[], filename?: string): void;
+/**
+ * Unified export function that handles all formats
+ */
+declare function exportData<TData>(data: TData[], format: 'excel' | 'csv' | 'pdf' | 'json', filename?: string): Promise<void>;
+
+/**
+ * Result of import operation
+ */
+interface ImportResult<TData> {
+    success: boolean;
+    data: TData[];
+    errors: string[];
+    warnings: string[];
+    totalRows: number;
+    validRows: number;
+}
+/**
+ * Import data from CSV file
+ */
+declare function importFromCSV<TData>(file: File, onProgress?: (progress: number) => void): Promise<ImportResult<TData>>;
+/**
+ * Import data from Excel file
+ */
+declare function importFromExcel<TData>(file: File, onProgress?: (progress: number) => void): Promise<ImportResult<TData>>;
+/**
+ * Import data from JSON file
+ */
+declare function importFromJSON<TData>(file: File, onProgress?: (progress: number) => void): Promise<ImportResult<TData>>;
+/**
+ * Unified import function that handles all formats
+ */
+declare function importData<TData>(file: File, onProgress?: (progress: number) => void): Promise<ImportResult<TData>>;
+
+interface FilterConfig {
+    id: string;
+    label: string;
+    type: 'dropdown' | 'multiselect';
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+}
+interface ReportOption {
+    value: string;
+    label: string;
+    dividerAfter?: boolean;
+}
+interface ToggleOption {
+    value: string;
+    label: string;
+}
+interface TimeFilterSelection {
+    type: 'Day' | 'Week' | 'Month' | 'Quarter' | 'Year';
+    /** For Day type: selected days like ['today', 'yesterday', 'last7'] */
+    days?: string[];
+    /** For Week type: selected weeks like ['this', 'last', 'last2'] */
+    weeks?: string[];
+    /** For Month type: selected months like ['this', 'last', 'jan', 'feb'] */
+    months?: string[];
+    /** For Quarter type: selected quarters like ['Q1', 'Q2'] */
+    quarters?: string[];
+    /** For Year type: selected years */
+    years?: string[];
+}
+interface FilterBarProps {
+    /** Dashboard title */
+    title: string;
+    /** Dynamic context label (shown as subtitle) */
+    contextLabel?: string;
+    /** Secondary toggle (e.g., Job/Value) */
+    secondaryToggle?: {
+        options: ToggleOption[];
+        value: string;
+        onChange: (value: string) => void;
+    };
+    /** Time filter */
+    timeFilter?: 'Day' | 'Week' | 'Month' | 'Quarter' | 'Year';
+    onTimeFilterChange?: (filter: 'Day' | 'Week' | 'Month' | 'Quarter' | 'Year') => void;
+    /** Time filter selection (for dropdown selections) */
+    timeFilterSelection?: TimeFilterSelection;
+    onTimeFilterSelectionChange?: (selection: TimeFilterSelection) => void;
+    /** Hide time filter toggle */
+    hideTimeFilter?: boolean;
+    /** Filter configurations */
+    filters?: FilterConfig[];
+    /** Filter values (controlled) */
+    filterValues?: Record<string, string | string[]>;
+    onFilterChange?: (filterId: string, value: string | string[]) => void;
+    /** Date range */
+    dateFrom?: Date;
+    dateTo?: Date;
+    onDateFromChange?: (date: Date | undefined) => void;
+    onDateToChange?: (date: Date | undefined) => void;
+    /** Apply/Reset handlers */
+    onApply?: () => void;
+    onReset?: () => void;
+    /** Reports dropdown */
+    reports?: ReportOption[];
+    onReportSelect?: (reportValue: string) => void;
+    /** Export dropdown (Print, Excel, PDF) - shows automatically when onExport is provided */
+    onExport?: (exportType: 'print' | 'excel' | 'pdf') => void;
+    /** Hide filter button */
+    hideFilterButton?: boolean;
+    /** Hide date range picker */
+    hideDateRange?: boolean;
+    /** Show Apply button */
+    showApplyButton?: boolean;
+    /** Insights button */
+    showInsights?: boolean;
+    insightsActive?: boolean;
+    onInsightsClick?: () => void;
+    /** Additional content */
+    children?: React$1.ReactNode;
+    className?: string;
+    /** Layout variant: 'default' or 'centered' (title in center) */
+    layout?: 'default' | 'centered';
+}
+declare function FilterBar({ title, contextLabel, secondaryToggle, timeFilter, onTimeFilterChange, timeFilterSelection, onTimeFilterSelectionChange, hideTimeFilter, filters, filterValues, onFilterChange, dateFrom, dateTo, onDateFromChange, onDateToChange, onApply, onReset, reports, onReportSelect, onExport, hideFilterButton, hideDateRange, showApplyButton, showInsights, insightsActive, onInsightsClick, children, className, layout }: FilterBarProps): react_jsx_runtime.JSX.Element;
+
+interface DashboardTooltipProps {
+    /** Tooltip content */
+    content: React$1.ReactNode;
+    /** Position of tooltip relative to trigger */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Delay before showing tooltip (ms) */
+    delay?: number;
+    /** Children element that triggers tooltip */
+    children: React$1.ReactElement;
+    /** Additional class for tooltip container */
+    className?: string;
+    /** Disable tooltip */
+    disabled?: boolean;
+}
+/**
+ * DashboardTooltip - Hover tooltip for dashboard elements
+ *
+ * Usage:
+ * <DashboardTooltip content="This is a tooltip">
+ *   <button>Hover me</button>
+ * </DashboardTooltip>
+ */
+declare function DashboardTooltip({ content, position, delay, children, className, disabled }: DashboardTooltipProps): react_jsx_runtime.JSX.Element;
+
+interface AreaChartDataItem {
+    [key: string]: string | number;
+}
+interface AreaChartSeries {
+    key: string;
+    name: string;
+    color?: string;
+}
+interface AreaChartProps {
+    data: AreaChartDataItem[];
+    xKey: string;
+    series: AreaChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    showGrid?: boolean;
+    smooth?: boolean;
+    className?: string;
+}
+/**
+ * AreaChart - ECharts Area Chart component
+ */
+declare function AreaChart({ data, xKey, series, height, showLegend, showGrid, smooth, className }: AreaChartProps): react_jsx_runtime.JSX.Element;
+
+interface BarChartDataItem {
+    [key: string]: string | number;
+}
+interface BarChartSeries {
+    key: string;
+    name: string;
+    color?: string;
+}
+interface BarChartProps {
+    data: BarChartDataItem[];
+    xKey: string;
+    series: BarChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    showGrid?: boolean;
+    horizontal?: boolean;
+    stacked?: boolean;
+    className?: string;
+}
+/**
+ * BarChart - ECharts Bar Chart component
+ */
+declare function BarChart({ data, xKey, series, height, showLegend, showGrid, horizontal, stacked, className }: BarChartProps): react_jsx_runtime.JSX.Element;
+
+interface DonutChartDataItem {
+    name: string;
+    value: number;
+    color?: string;
+}
+interface DonutChartProps {
+    data: DonutChartDataItem[];
+    height?: number;
+    showLegend?: boolean;
+    centerLabel?: string;
+    centerValue?: string;
+    innerRadius?: string;
+    outerRadius?: string;
+    className?: string;
+}
+/**
+ * DonutChart - ECharts Donut/Pie Chart component
+ * On hover: shows slice name + value in the center of the donut.
+ * On mouseout: restores the default centerLabel / centerValue.
+ */
+declare function DonutChart({ data, height, showLegend, centerLabel, centerValue, innerRadius, outerRadius, className }: DonutChartProps): react_jsx_runtime.JSX.Element;
+
+interface GaugeChartProps {
+    /** Current value (0-100 or custom max) */
+    value: number;
+    /** Maximum value */
+    max?: number;
+    /** Minimum value */
+    min?: number;
+    /** Chart height in pixels */
+    height?: number;
+    /** Title shown below the value */
+    title?: string;
+    /** Unit suffix (%, $, etc.) */
+    unit?: string;
+    /** Color or gradient stops */
+    color?: string | {
+        offset: number;
+        color: string;
+    }[];
+    /** Show axis ticks */
+    showAxis?: boolean;
+    /** Gauge style variant */
+    variant?: 'default' | 'progress' | 'meter';
+    /** Class name for wrapper */
+    className?: string;
+}
+/**
+ * GaugeChart - ECharts Gauge component
+ *
+ * Variants:
+ * - default: Half-donut arc, no pointer, value centered — clean and modern
+ * - progress: Full ring progress with rounded cap
+ * - meter: Speedometer with pointer needle
+ */
+declare function GaugeChart({ value, max, min, height, title, unit, color, showAxis, variant, className }: GaugeChartProps): react_jsx_runtime.JSX.Element;
+
+interface LineChartDataItem {
+    [key: string]: string | number;
+}
+interface LineChartSeries {
+    key: string;
+    name: string;
+    color?: string;
+    /** Line style: solid, dashed, dotted */
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+    /** Show data points */
+    showSymbol?: boolean;
+}
+interface LineChartProps {
+    data: LineChartDataItem[];
+    xKey: string;
+    series: LineChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    showGrid?: boolean;
+    /** Smooth curve or straight lines */
+    smooth?: boolean;
+    /** Show data labels on points */
+    showLabels?: boolean;
+    /** Y-axis minimum value */
+    yMin?: number;
+    /** Y-axis maximum value */
+    yMax?: number;
+    className?: string;
+}
+/**
+ * LineChart - ECharts Line Chart component (no area fill)
+ */
+declare function LineChart({ data, xKey, series, height, showLegend, showGrid, smooth, showLabels, yMin, yMax, className }: LineChartProps): react_jsx_runtime.JSX.Element;
+
+interface RadarChartIndicator {
+    /** Dimension name */
+    name: string;
+    /** Maximum value for this dimension */
+    max: number;
+    /** Minimum value (default 0) */
+    min?: number;
+}
+interface RadarChartSeries {
+    name: string;
+    values: number[];
+    color?: string;
+    /** Fill area opacity (0-1) */
+    areaOpacity?: number;
+}
+interface RadarChartProps {
+    /** Dimensions/axes of the radar */
+    indicators: RadarChartIndicator[];
+    /** Data series to plot */
+    series: RadarChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    /** Radar shape: polygon or circle */
+    shape?: 'polygon' | 'circle';
+    /** Number of split rings */
+    splitNumber?: number;
+    className?: string;
+}
+/**
+ * RadarChart - ECharts Radar/Spider Chart for multi-dimensional data
+ */
+declare function RadarChart({ indicators, series, height, showLegend, shape, splitNumber, className }: RadarChartProps): react_jsx_runtime.JSX.Element;
+
+interface FunnelChartDataItem {
+    name: string;
+    value: number;
+    color?: string;
+}
+interface FunnelChartProps {
+    data: FunnelChartDataItem[];
+    height?: number;
+    showLegend?: boolean;
+    /** Show labels on funnel stages */
+    showLabels?: boolean;
+    /** Label position */
+    labelPosition?: 'left' | 'right' | 'inside' | 'center';
+    /** Funnel orientation */
+    orient?: 'vertical' | 'horizontal';
+    /** Sort order */
+    sort?: 'ascending' | 'descending' | 'none';
+    /** Gap between stages */
+    gap?: number;
+    className?: string;
+}
+/**
+ * FunnelChart - ECharts Funnel Chart for conversion/process flows
+ */
+declare function FunnelChart({ data, height, showLegend, showLabels, labelPosition, orient, sort, gap, className }: FunnelChartProps): react_jsx_runtime.JSX.Element;
+
+interface HeatmapChartDataItem {
+    /** X-axis index or value */
+    x: number | string;
+    /** Y-axis index or value */
+    y: number | string;
+    /** Heat value */
+    value: number;
+}
+interface HeatmapChartProps {
+    data: HeatmapChartDataItem[];
+    /** X-axis categories */
+    xCategories: string[];
+    /** Y-axis categories */
+    yCategories: string[];
+    height?: number;
+    /** Show value labels in cells */
+    showLabels?: boolean;
+    /** Color range [min, max] */
+    colorRange?: [string, string];
+    /** Min value for color scale */
+    minValue?: number;
+    /** Max value for color scale */
+    maxValue?: number;
+    /** Show visual map legend */
+    showVisualMap?: boolean;
+    className?: string;
+}
+/**
+ * HeatmapChart - ECharts Heatmap for time/category based data visualization
+ */
+declare function HeatmapChart({ data, xCategories, yCategories, height, showLabels, colorRange, minValue, maxValue, showVisualMap, className }: HeatmapChartProps): react_jsx_runtime.JSX.Element;
+
+interface ScatterChartDataItem {
+    /** X value */
+    x: number;
+    /** Y value */
+    y: number;
+    /** Optional size value for bubble charts */
+    size?: number;
+    /** Optional label */
+    label?: string;
+}
+interface ScatterChartSeries {
+    name: string;
+    data: ScatterChartDataItem[];
+    color?: string;
+    /** Symbol shape */
+    symbol?: 'circle' | 'rect' | 'triangle' | 'diamond' | 'pin' | 'arrow';
+    /** Fixed symbol size (ignored if data has size values) */
+    symbolSize?: number;
+}
+interface ScatterChartProps {
+    series: ScatterChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    showGrid?: boolean;
+    /** X-axis label */
+    xAxisName?: string;
+    /** Y-axis label */
+    yAxisName?: string;
+    /** Enable bubble mode (size based on data) */
+    bubbleMode?: boolean;
+    /** Size range for bubble mode [min, max] */
+    sizeRange?: [number, number];
+    className?: string;
+}
+/**
+ * ScatterChart - ECharts Scatter/Bubble Chart for correlation data
+ */
+declare function ScatterChart({ series, height, showLegend, showGrid, xAxisName, yAxisName, bubbleMode, sizeRange, className }: ScatterChartProps): react_jsx_runtime.JSX.Element;
+
+interface ParetoChartDataItem {
+    name: string;
+    value: number;
+}
+interface ParetoChartProps {
+    data: ParetoChartDataItem[];
+    height?: number;
+    showLegend?: boolean;
+    /** Bar color */
+    barColor?: string;
+    /** Line color for cumulative percentage */
+    lineColor?: string;
+    /** Y-axis label for values */
+    valueAxisName?: string;
+    className?: string;
+}
+/**
+ * ParetoChart - Combined bar and line chart showing values and cumulative percentage
+ * Used for identifying the "vital few" from the "trivial many" (80/20 rule)
+ */
+declare function ParetoChart({ data, height, showLegend, barColor, lineColor, valueAxisName, className }: ParetoChartProps): react_jsx_runtime.JSX.Element;
+
+interface HistogramChartProps {
+    /** Raw data values to create histogram from */
+    data: number[];
+    /** Number of bins (default: auto-calculated) */
+    bins?: number;
+    height?: number;
+    showLegend?: boolean;
+    /** Bar color */
+    color?: string;
+    /** X-axis label */
+    xAxisName?: string;
+    /** Y-axis label */
+    yAxisName?: string;
+    /** Show normal distribution curve overlay */
+    showNormalCurve?: boolean;
+    className?: string;
+}
+/**
+ * HistogramChart - Frequency distribution chart
+ * Automatically bins data and shows distribution
+ */
+declare function HistogramChart({ data, bins, height, showLegend, color, xAxisName, yAxisName, showNormalCurve, className }: HistogramChartProps): react_jsx_runtime.JSX.Element;
+
+interface BubbleChartDataItem {
+    /** X-axis value */
+    x: number;
+    /** Y-axis value */
+    y: number;
+    /** Bubble size value */
+    size: number;
+    /** Optional label */
+    label?: string;
+}
+interface BubbleChartSeries {
+    name: string;
+    data: BubbleChartDataItem[];
+    color?: string;
+}
+interface BubbleChartProps {
+    series: BubbleChartSeries[];
+    height?: number;
+    showLegend?: boolean;
+    /** X-axis label */
+    xAxisName?: string;
+    /** Y-axis label */
+    yAxisName?: string;
+    /** Size axis label (for tooltip) */
+    sizeAxisName?: string;
+    /** Size range [min, max] in pixels */
+    sizeRange?: [number, number];
+    /** Bubble opacity (0-1) */
+    opacity?: number;
+    className?: string;
+}
+/**
+ * BubbleChart - Three-dimensional scatter plot with size encoding
+ * Shows relationship between X, Y, and Size dimensions
+ */
+declare function BubbleChart({ series, height, showLegend, xAxisName, yAxisName, sizeAxisName, sizeRange, opacity, className }: BubbleChartProps): react_jsx_runtime.JSX.Element;
+
+interface BoxPlotChartDataItem {
+    /** Category name */
+    name: string;
+    /** Raw data values to calculate box plot from */
+    values: number[];
+}
+interface BoxPlotChartProps {
+    data: BoxPlotChartDataItem[];
+    height?: number;
+    showLegend?: boolean;
+    /** Box color */
+    color?: string;
+    /** Orientation */
+    horizontal?: boolean;
+    /** Show outliers */
+    showOutliers?: boolean;
+    className?: string;
+}
+/**
+ * BoxPlotChart - Statistical box and whisker plot
+ * Shows min, Q1, median, Q3, max and outliers
+ */
+declare function BoxPlotChart({ data, height, showLegend, color, horizontal, showOutliers, className }: BoxPlotChartProps): react_jsx_runtime.JSX.Element;
+
+interface GeoMapDataItem {
+    /** Location name */
+    name: string;
+    /** Value for this location */
+    value: number;
+}
+interface GeoMapMarker {
+    /** Marker name/label */
+    name: string;
+    /** Coordinates [longitude, latitude] */
+    coords: [number, number];
+    /** Optional value (affects size) */
+    value?: number;
+}
+interface GeoMapProps {
+    /** Point markers on the map */
+    markers?: GeoMapMarker[];
+    height?: number;
+    /** Marker color */
+    markerColor?: string;
+    /** Marker size range [min, max] */
+    markerSizeRange?: [number, number];
+    /** Show ripple effect */
+    showRipple?: boolean;
+    /** Map background color */
+    mapColor?: string;
+    /** Map border color */
+    borderColor?: string;
+    /** Show state labels on hover */
+    showStateLabels?: boolean;
+    className?: string;
+}
+/**
+ * GeoMap - Geographic scatter/bubble map for India
+ * Shows location markers with optional size based on values
+ * Includes all Indian states and union territories
+ */
+declare function GeoMap({ markers, height, markerColor, markerSizeRange, showRipple, mapColor, borderColor, showStateLabels, className }: GeoMapProps): react_jsx_runtime.JSX.Element;
+
+interface TreemapDataItem {
+    /** Node name */
+    name: string;
+    /** Node value (determines size) */
+    value: number;
+    /** Optional children for hierarchical data */
+    children?: TreemapDataItem[];
+    /** Optional custom color */
+    color?: string;
+}
+interface TreemapChartProps {
+    data: TreemapDataItem[];
+    height?: number;
+    /** Show breadcrumb navigation */
+    showBreadcrumb?: boolean;
+    /** Color palette */
+    colors?: string[];
+    /** Show labels on leaves */
+    showLabels?: boolean;
+    /** Label position */
+    labelPosition?: 'inside' | 'insideTopLeft' | 'insideBottomLeft';
+    /** Enable drill-down on click */
+    drillDown?: boolean;
+    className?: string;
+}
+/**
+ * TreemapChart - Hierarchical data visualization
+ * Great for: Cost breakdown, category distribution, budget allocation
+ */
+declare function TreemapChart({ data, height, showBreadcrumb, colors, showLabels, labelPosition, drillDown, className }: TreemapChartProps): react_jsx_runtime.JSX.Element;
+
+interface SankeyNode {
+    /** Node name (must be unique) */
+    name: string;
+    /** Optional custom color */
+    color?: string;
+    /** Optional depth level (0 = leftmost) */
+    depth?: number;
+}
+interface SankeyLink {
+    /** Source node name */
+    source: string;
+    /** Target node name */
+    target: string;
+    /** Flow value */
+    value: number;
+    /** Optional custom color */
+    color?: string;
+}
+interface SankeyChartProps {
+    /** Nodes in the diagram */
+    nodes: SankeyNode[];
+    /** Links/flows between nodes */
+    links: SankeyLink[];
+    height?: number;
+    /** Orientation */
+    orient?: 'horizontal' | 'vertical';
+    /** Node width */
+    nodeWidth?: number;
+    /** Gap between nodes */
+    nodeGap?: number;
+    /** Show labels */
+    showLabels?: boolean;
+    /** Color palette for nodes */
+    colors?: string[];
+    /** Link opacity */
+    linkOpacity?: number;
+    className?: string;
+}
+/**
+ * SankeyChart - Flow/relationship visualization
+ * Great for: Material flow, process flow, cost flow, conversion funnels
+ */
+declare function SankeyChart({ nodes, links, height, orient, nodeWidth, nodeGap, showLabels, colors, linkOpacity, className }: SankeyChartProps): react_jsx_runtime.JSX.Element;
+
+interface WaterfallDataItem {
+    /** Category/step name */
+    name: string;
+    /** Value (positive = increase, negative = decrease) */
+    value: number;
+    /** Mark as total/subtotal (shows cumulative value) */
+    isTotal?: boolean;
+}
+interface WaterfallChartProps {
+    data: WaterfallDataItem[];
+    height?: number;
+    /** Color for positive values */
+    increaseColor?: string;
+    /** Color for negative values */
+    decreaseColor?: string;
+    /** Color for total bars */
+    totalColor?: string;
+    /** Show values on bars */
+    showValues?: boolean;
+    /** Horizontal orientation */
+    horizontal?: boolean;
+    /** Y-axis label */
+    yAxisName?: string;
+    className?: string;
+}
+/**
+ * WaterfallChart - Cumulative effect visualization
+ * Great for: Profit/loss analysis, cost breakdown, variance analysis
+ */
+declare function WaterfallChart({ data, height, increaseColor, decreaseColor, totalColor, showValues, horizontal, yAxisName, className }: WaterfallChartProps): react_jsx_runtime.JSX.Element;
+
+interface BulletChartDataItem {
+    /** Category name */
+    name: string;
+    /** Actual value */
+    actual: number;
+    /** Target value */
+    target: number;
+    /** Range thresholds [poor, satisfactory, good] */
+    ranges?: [number, number, number];
+}
+interface BulletChartProps {
+    data: BulletChartDataItem[];
+    height?: number;
+    /** Actual bar color */
+    actualColor?: string;
+    /** Target marker color */
+    targetColor?: string;
+    /** Range colors [poor, satisfactory, good] */
+    rangeColors?: [string, string, string];
+    /** Show values on bars */
+    showValues?: boolean;
+    /** Horizontal orientation (default) */
+    horizontal?: boolean;
+    className?: string;
+}
+/**
+ * BulletChart - Compact KPI vs Target visualization
+ * Great for: KPI dashboards, performance metrics, goal tracking
+ * Alternative to gauge charts when space is limited
+ */
+declare function BulletChart({ data, height, actualColor, targetColor, rangeColors, showValues, horizontal, className }: BulletChartProps): react_jsx_runtime.JSX.Element;
+
+interface SparklineProps {
+    /** Data points */
+    data: number[];
+    /** Chart type */
+    type?: 'line' | 'area' | 'bar';
+    /** Height in pixels */
+    height?: number;
+    /** Width (can be percentage or pixels) */
+    width?: number | string;
+    /** Line/bar color */
+    color?: string;
+    /** Area fill color (for area type) */
+    fillColor?: string;
+    /** Show end dot */
+    showEndDot?: boolean;
+    /** Show min/max markers */
+    showMinMax?: boolean;
+    /** Smooth line */
+    smooth?: boolean;
+    /** Reference line value */
+    referenceLine?: number;
+    className?: string;
+}
+/**
+ * Sparkline - Compact inline trend visualization
+ * Great for: KPI cards, table cells, compact trend indicators
+ */
+declare function Sparkline({ data, type, height, width, color, fillColor, showEndDot, showMinMax, smooth, referenceLine, className }: SparklineProps): react_jsx_runtime.JSX.Element;
+
+interface GanttTask {
+    id: string;
+    name: string;
+    start: string | Date;
+    end: string | Date;
+    progress?: number;
+    color?: string;
+    category?: string;
+    dependencies?: string[];
+}
+interface GanttChartProps {
+    tasks: GanttTask[];
+    height?: number;
+    showProgress?: boolean;
+    showToday?: boolean;
+    showGrid?: boolean;
+    dateFormat?: 'short' | 'medium' | 'long';
+    className?: string;
+}
+/**
+ * GanttChart - ECharts Gantt Chart component
+ *
+ * Displays project timelines with tasks, progress, and dependencies.
+ * Built on ECharts custom series for flexibility.
+ */
+declare function GanttChart({ tasks, height, showProgress, showToday, showGrid, dateFormat, className }: GanttChartProps): react_jsx_runtime.JSX.Element;
+
+interface FlowMapMarker {
+    name: string;
+    coords: [number, number];
+    value?: number;
+}
+interface FlowMapLine {
+    name?: string;
+    from: [number, number];
+    to: [number, number];
+    value?: number;
+    color?: string;
+}
+interface FlowMapProps {
+    markers?: FlowMapMarker[];
+    lines?: FlowMapLine[];
+    height?: number;
+    markerColor?: string;
+    lineColor?: string;
+    markerSizeRange?: [number, number];
+    lineWidth?: number;
+    showRipple?: boolean;
+    showLineEffect?: boolean;
+    effectSymbol?: 'circle' | 'arrow' | 'plane' | 'pin';
+    mapColor?: string;
+    borderColor?: string;
+    showLabels?: boolean;
+    curveness?: number;
+    className?: string;
+}
+/**
+ * FlowMap - Geographic flow/route visualization
+ *
+ * Combines scatter markers with animated flow lines between locations.
+ * Perfect for logistics, shipping routes, migration, trade flows.
+ *
+ * Uses ECharts Lines series for flow visualization.
+ */
+declare function FlowMap({ markers, lines, height, markerColor, lineColor, markerSizeRange, lineWidth, showRipple, showLineEffect, effectSymbol, mapColor, borderColor, showLabels, curveness, className }: FlowMapProps): react_jsx_runtime.JSX.Element;
+
+interface ChartCardProps {
+    title?: string;
+    description?: string;
+    children: React$1.ReactNode;
+    className?: string;
+    headerAction?: React$1.ReactNode;
+}
+/**
+ * ChartCard - Container for chart components with title and description
+ */
+declare function ChartCard({ title, description, children, className, headerAction }: ChartCardProps): react_jsx_runtime.JSX.Element;
+
+type KpiAccent = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'tertiary' | 'secondary';
+interface KpiProps {
+    /** KPI title/label — uppercase, small, accent-colored */
+    title: string;
+    /** Main value to display */
+    value: string | number;
+    /** Optional unit suffix (%, $, etc.) — appended after value */
+    unit?: string;
+    /** Optional badge in bottom-right corner (e.g., "12 actions") — shown only when `change` is undefined */
+    badge?: string | number;
+    /** Optional badge label (e.g., "actions") shown after the badge value */
+    badgeLabel?: string;
+    /** Change from previous period — renders trend pill (overrides badge) */
+    change?: number;
+    /** Change label (e.g., "vs last week") — small text after the trend pill */
+    changeLabel?: string;
+    /** Optional subtitle/description below value */
+    subtitle?: string;
+    /** Decorative watermark icon (bottom-right, faded) */
+    icon?: LucideIcon;
+    /** Accent color — drives title color, background tint, and watermark */
+    accent?: KpiAccent;
+    /** Active/selected state — adds ring and stronger background */
+    active?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Loading skeleton */
+    loading?: boolean;
+    /** Click handler — makes the card a button */
+    onClick?: () => void;
+    /** Optional footer content (e.g., sparkline chart) */
+    footer?: React$1.ReactNode;
+    className?: string;
+}
+/**
+ * Kpi — Compact KPI card with watermark icon style (matches home dashboard).
+ * Layout: tiny uppercase accent label on top, big bold value bottom-left,
+ * optional badge or trend pill bottom-right, decorative watermark icon in corner.
+ *
+ * Supports: trend %, subtitle, footer (sparkline), 3 sizes, active/loading states.
+ */
+declare function Kpi({ title, value, unit, badge, badgeLabel, change, changeLabel, subtitle, icon: Icon, accent, active, size, loading, onClick, footer, className, }: KpiProps): react_jsx_runtime.JSX.Element;
+
+interface ComparisonBar {
+    /** Label for this bar */
+    label: string;
+    /** Value to display */
+    value: number;
+    /** Percentage fill (0-100) */
+    percentage: number;
+    /** Bar color: success, warning, error, primary, or custom */
+    color?: 'success' | 'warning' | 'error' | 'primary' | string;
+}
+interface KpiComparisonProps {
+    /** Title of the KPI */
+    title: string;
+    /** Main value to display */
+    value: string | number;
+    /** Target value (optional) */
+    target?: string | number;
+    /** Status label (e.g., "On Track", "Behind") */
+    status?: {
+        label: string;
+        type: 'success' | 'warning' | 'error';
+    };
+    /** Comparison bars to display */
+    bars: ComparisonBar[];
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiComparison - KPI card with comparison progress bars
+ *
+ * Great for: Target tracking, period comparisons, goal progress
+ */
+declare function KpiComparison({ title, value, target, status, bars, className }: KpiComparisonProps): react_jsx_runtime.JSX.Element;
+
+interface KpiTrendProps {
+    /** Title of the KPI */
+    title: string;
+    /** Main value to display */
+    value: string | number;
+    /** Unit label (e.g., "days", "%", "hrs") */
+    unit?: string;
+    /** Change value (positive or negative) */
+    change?: number;
+    /** Change unit (defaults to same as unit) */
+    changeUnit?: string;
+    /** Description text (e.g., "Improved from 5.0 days last month") */
+    description?: string;
+    /** Icon to display next to title */
+    icon?: LucideIcon;
+    /** Icon color class */
+    iconColor?: string;
+    /** Whether a decrease is positive (e.g., for lead time, costs) */
+    decreaseIsGood?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiTrend - KPI card with trend indicator
+ *
+ * Great for: Metrics with period-over-period changes
+ */
+declare function KpiTrend({ title, value, unit, change, changeUnit, description, icon: Icon, iconColor, decreaseIsGood, className }: KpiTrendProps): react_jsx_runtime.JSX.Element;
+
+interface BreakdownItem {
+    /** Label for this item */
+    label: string;
+    /** Value to display */
+    value: string | number;
+    /** Color indicator: success, warning, error, primary, info, or custom hex */
+    color?: 'success' | 'warning' | 'error' | 'primary' | 'info' | string;
+}
+interface KpiBreakdownProps {
+    /** Title of the KPI */
+    title: string;
+    /** Total/summary value (optional, displayed in header) */
+    total?: string | number;
+    /** Breakdown items to display */
+    items: BreakdownItem[];
+    /** Show percentage next to values */
+    showPercentage?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiBreakdown - KPI card with list breakdown
+ *
+ * Great for: Status distributions, category splits, item counts by type
+ */
+declare function KpiBreakdown({ title, total, items, showPercentage, className }: KpiBreakdownProps): react_jsx_runtime.JSX.Element;
+
+interface QuickStat {
+    /** Label for this stat */
+    label: string;
+    /** Value to display */
+    value: string | number;
+    /** Icon component */
+    icon: LucideIcon;
+    /** Icon color: success, warning, error, primary, info */
+    iconColor?: 'success' | 'warning' | 'error' | 'primary' | 'info';
+}
+interface KpiQuickStatsProps {
+    /** Title of the KPI card */
+    title: string;
+    /** Stats to display (2-4 recommended) */
+    stats: QuickStat[];
+    /** Number of columns (2, 3, or 4) */
+    columns?: 2 | 3 | 4;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiQuickStats - KPI card with grid of icon stats
+ *
+ * Great for: Quick overview panels, dashboard summaries, multi-metric cards
+ */
+declare function KpiQuickStats({ title, stats, columns, className }: KpiQuickStatsProps): react_jsx_runtime.JSX.Element;
+
+interface RatingBreakdown {
+    /** Star rating (1-5) */
+    stars: number;
+    /** Number of ratings */
+    count: number;
+    /** Percentage of total */
+    percentage: number;
+}
+interface KpiRatingProps {
+    /** Title of the KPI */
+    title: string;
+    /** Rating score (e.g., 4.8) */
+    score: number;
+    /** Maximum score (defaults to 5) */
+    maxScore?: number;
+    /** Total number of reviews */
+    reviewCount?: number;
+    /** Status badge text (e.g., "Excellent", "Good") */
+    status?: string;
+    /** Status type for coloring */
+    statusType?: 'success' | 'warning' | 'error';
+    /** Change from previous period */
+    change?: number;
+    /** Period label (e.g., "from last month") */
+    changeLabel?: string;
+    /** Footer period text (e.g., "Last 30 days") */
+    periodLabel?: string;
+    /** Tooltip info */
+    tooltip?: {
+        /** Formula explanation */
+        formula?: string;
+        /** Description */
+        description?: string;
+        /** Rating breakdown data */
+        breakdown?: RatingBreakdown[];
+    };
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiRating - KPI card with star rating display
+ *
+ * Great for: Customer satisfaction, NPS scores, product ratings
+ */
+declare function KpiRating({ title, score, maxScore, reviewCount, status, statusType, change, changeLabel, periodLabel, tooltip, className }: KpiRatingProps): react_jsx_runtime.JSX.Element;
+
+interface KpiBeforeAfterProps {
+    /** Title of the KPI */
+    title: string;
+    /** Before value */
+    beforeValue: string | number;
+    /** Before label (defaults to "Before") */
+    beforeLabel?: string;
+    /** Before sublabel (e.g., "Avg cycle time") */
+    beforeSublabel?: string;
+    /** After value */
+    afterValue: string | number;
+    /** After label (defaults to "After") */
+    afterLabel?: string;
+    /** After sublabel (e.g., "Avg cycle time") */
+    afterSublabel?: string;
+    /** Improvement percentage */
+    improvement?: number;
+    /** Improvement label (defaults to "improvement") */
+    improvementLabel?: string;
+    /** Whether improvement is shown as decrease (down arrow) or increase (up arrow) */
+    improvementType?: 'decrease' | 'increase';
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiBeforeAfter - KPI card comparing before/after values
+ *
+ * Great for: Process improvements, A/B results, optimization metrics
+ */
+declare function KpiBeforeAfter({ title, beforeValue, beforeLabel, beforeSublabel, afterValue, afterLabel, afterSublabel, improvement, improvementLabel, improvementType, className }: KpiBeforeAfterProps): react_jsx_runtime.JSX.Element;
+
+interface KpiScrollItem {
+    /** Unique identifier */
+    id: string;
+    /** Icon component */
+    icon?: LucideIcon;
+    /** Icon background color */
+    iconBg?: string;
+    /** Icon color */
+    iconColor?: string;
+    /** Custom icon element (for images/svgs/avatars) */
+    customIcon?: React$1.ReactNode;
+    /** Main title */
+    title: string;
+    /** Subtitle/description */
+    subtitle?: string;
+    /** Metric value */
+    value: string | number;
+    /** Metric prefix (e.g., +, -, ₹) */
+    prefix?: string;
+    /** Metric suffix (e.g., %, k, m) */
+    suffix?: string;
+    /** Whether the value is positive (green), negative (red), or neutral */
+    sentiment?: 'positive' | 'negative' | 'neutral';
+    /** Secondary value (shown below main value) */
+    secondaryValue?: string;
+    /** Click handler */
+    onClick?: () => void;
+}
+interface KpiScrollProps {
+    /** Section title */
+    title?: string;
+    /** Section description */
+    description?: string;
+    /** Period options for dropdown */
+    periodOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Selected period value */
+    periodValue?: string;
+    /** Period change handler */
+    onPeriodChange?: (value: string) => void;
+    /** Items to display */
+    items: KpiScrollItem[];
+    /** Show "View All" button */
+    showViewAll?: boolean;
+    /** View All click handler */
+    onViewAll?: () => void;
+    /** View All label */
+    viewAllLabel?: string;
+    /** Card variant */
+    variant?: 'default' | 'compact' | 'detailed';
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * KpiScroll - Horizontal scrollable KPI cards
+ *
+ * Great for: Channel stats, customer metrics, quick summaries
+ */
+declare function KpiScroll({ title, description, periodOptions, periodValue, onPeriodChange, items, showViewAll, onViewAll, viewAllLabel, variant, className }: KpiScrollProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Chart height presets (in pixels)
+ * These ensure consistent sizing across all dashboard charts
+ */
+declare const chartHeights: {
+    /** Small charts - KPIs, mini sparklines */
+    readonly sm: 180;
+    /** Medium charts - Standard dashboard charts */
+    readonly md: 240;
+    /** Large charts - Featured/hero charts */
+    readonly lg: 300;
+    /** Extra large - Full-width detailed charts */
+    readonly xl: 360;
+};
+/**
+ * Grid layout configurations
+ * Responsive column layouts for different chart groupings
+ */
+declare const gridLayouts: {
+    /** Single chart full width */
+    readonly single: "grid-cols-1";
+    /** 2 charts side by side on large screens */
+    readonly double: "grid-cols-1 lg:grid-cols-2";
+    /** 3 charts on large screens, 2 on medium */
+    readonly triple: "grid-cols-1 md:grid-cols-2 lg:grid-cols-3";
+    /** 4 charts - 2x2 on medium, 4 on large */
+    readonly quad: "grid-cols-1 md:grid-cols-2 xl:grid-cols-4";
+    /** KPI cards - 4 columns on large, 2 on medium */
+    readonly kpi: "grid-cols-1 md:grid-cols-2 lg:grid-cols-4";
+};
+/**
+ * Section spacing
+ * Gap between charts and sections
+ */
+declare const spacing: {
+    /** Gap between charts in a grid */
+    readonly chartGap: "gap-4 lg:gap-6";
+    /** Gap between sections */
+    readonly sectionGap: "space-y-4 lg:space-y-6";
+    /** Padding for main content area */
+    readonly contentPadding: "p-4 md:p-6";
+};
+/**
+ * Chart card configurations
+ */
+declare const chartCard: {
+    /** Default border radius */
+    readonly borderRadius: "rounded-xl";
+    /** Default padding */
+    readonly padding: "p-4";
+    /** Background */
+    readonly background: "bg-[rgb(var(--bg-surface))]";
+    /** Border */
+    readonly border: "border border-[rgb(var(--bd-default))]";
+};
+/**
+ * Donut chart configurations
+ */
+declare const donutConfig: {
+    /** Inner radius percentage for donut hole */
+    readonly innerRadius: 60;
+    /** Outer radius percentage */
+    readonly outerRadius: 80;
+};
+/**
+ * Bar chart configurations
+ */
+declare const barConfig: {
+    /** Default bar radius */
+    readonly barRadius: 4;
+    /** Max bar width */
+    readonly maxBarWidth: 40;
+};
+/**
+ * Color palette for charts
+ * Using CSS variables where possible, hex fallbacks for chart libraries
+ */
+declare const chartColors: {
+    readonly primary: "#5470c6";
+    readonly success: "#52c41a";
+    readonly warning: "#faad14";
+    readonly error: "#f5222d";
+    readonly info: "#1890ff";
+    readonly muted: "#8c8c8c";
+    /** Extended palette for multi-series */
+    readonly palette: readonly ["#5470c6", "#91cc75", "#fac858", "#ee6666", "#73c0de", "#3ba272", "#fc8452", "#9a60b4", "#ea7ccc"];
+};
+/**
+ * Helper to get responsive chart height
+ * Returns different heights based on viewport considerations
+ */
+declare function getChartHeight(size?: keyof typeof chartHeights): number;
+/**
+ * Helper to build grid classes
+ */
+declare function getGridClasses(layout: keyof typeof gridLayouts): string;
+
+interface APIConfigModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfigured?: () => void;
+}
+declare function APIConfigModal({ isOpen, onClose, onConfigured }: APIConfigModalProps): react_jsx_runtime.JSX.Element;
+
+interface GlobalAPIConfigModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfigured?: () => void;
+}
+declare function GlobalAPIConfigModal({ isOpen, onClose, onConfigured }: GlobalAPIConfigModalProps): react_jsx_runtime.JSX.Element;
+
+interface ImageModalDetail {
+    label: string;
+    value: string | number;
+}
+interface ImageModalProps {
+    title?: string;
+    children: React__default.ReactNode;
+    preview?: React__default.ReactNode;
+    previewClassName?: string;
+    previewContainerClassName?: string;
+    isOpen?: boolean;
+    onClose?: () => void;
+    details?: ImageModalDetail[];
+    onPreviewClick?: () => void;
+    isPdfMode?: boolean;
+    pdfUrl?: string;
+    onDownloadPdf?: () => void;
+    cleanMode?: boolean;
+    enableZoom?: boolean;
+    viewBoxWidthMM?: number;
+    viewBoxHeightMM?: number;
+    exportFilename?: string;
+    extraExportButtons?: React__default.ReactNode;
+}
+declare function ImageModal({ isOpen: controlledIsOpen, onClose: controlledOnClose, title, children, preview, previewClassName, previewContainerClassName, details, onPreviewClick, isPdfMode, pdfUrl, onDownloadPdf, cleanMode, enableZoom, viewBoxWidthMM, viewBoxHeightMM, exportFilename, extraExportButtons }: ImageModalProps): react_jsx_runtime.JSX.Element;
+
+interface ThreeDModalDetail {
+    label: string;
+    value: string | number;
+}
+interface ThreeDModalProps {
+    /** Card title shown above the preview */
+    title?: string;
+    /** @deprecated Pass renderContent instead */
+    children?: React__default.ReactNode;
+    /** Render function for 3D content */
+    renderContent?: () => React__default.ReactNode;
+    /** Fallback when there's no data to render */
+    placeholder?: string;
+    /** Whether to show the 3D content (false = show placeholder) */
+    hasData?: boolean;
+    /** Preview card height — default 13.75rem to match planning modal cards */
+    previewHeight?: string;
+    /** Additional className for the preview card container */
+    className?: string;
+    /** Metadata row shown below the header in the expanded modal */
+    details?: ThreeDModalDetail[];
+    /** Extra actions rendered next to the expand/close icon in headers */
+    headerActions?: React__default.ReactNode;
+    /** When provided, shows a refresh button next to the expand icon */
+    onRefresh?: () => void;
+}
+declare function ThreeDModal({ title, children, renderContent, placeholder, hasData, previewHeight, className, details, headerActions, onRefresh, }: ThreeDModalProps): react_jsx_runtime.JSX.Element;
+
+interface DeviceInfo {
+    id: string;
+    name: string;
+    type: 'desktop' | 'mobile' | 'tablet';
+    browser?: string;
+    os?: string;
+    lastUsed: Date;
+    isCurrent: boolean;
+}
+interface TaskStatus {
+    overdue: number;
+    dueSoon: number;
+    total: number;
+}
+interface LogoutModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onLogout: () => void;
+    onLogoutEverywhere: () => void;
+    sessionData: {
+        duration: string;
+        startTime: Date;
+        tasks: TaskStatus;
+        activeDevices: DeviceInfo[];
+        isInactivityWarning?: boolean;
+        timeUntilAutoLogout?: string;
+    };
+    onExtendSession?: () => void;
+    onViewTasks?: () => void;
+    className?: string;
+}
+declare function LogoutModal({ isOpen, onClose, onLogout, sessionData, onViewTasks, className }: LogoutModalProps): react_jsx_runtime.JSX.Element;
+
+interface StandardModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React__default.ReactNode;
+    subtitle?: string;
+    badge?: {
+        label: string;
+        variant?: 'default' | 'outline' | 'secondary' | 'destructive';
+    };
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    className?: string;
+    showFooter?: boolean;
+    footerActions?: React__default.ReactNode;
+    onSave?: () => void;
+    onCancel?: () => void;
+    saveLabel?: string;
+    cancelLabel?: string;
+    saveIcon?: LucideIcon;
+    cancelIcon?: LucideIcon;
+    saving?: boolean;
+    ariaDescribedBy?: string;
+    ariaDescription?: string;
+}
+declare function StandardModal({ isOpen, onClose, title, subtitle, badge, children, size, className, showFooter, footerActions, onSave, onCancel, saveLabel, cancelLabel, saveIcon: SaveIcon, cancelIcon: CancelIcon, saving, ariaDescribedBy, ariaDescription }: StandardModalProps): react_jsx_runtime.JSX.Element;
+
+type EditableCellType = 'text' | 'number' | 'decimal';
+interface EditableCellProps {
+    value: string | number;
+    onSave: (value: string | number) => void;
+    type?: EditableCellType;
+    step?: string;
+    className?: string;
+    placeholder?: string;
+    disabled?: boolean;
+}
+/**
+ * Unified Editable Cell Component
+ * Supports text, number, and decimal editing
+ *
+ * @example
+ * // Text editing
+ * <EditableCell value="John" onSave={handleSave} type="text" />
+ *
+ * // Integer editing
+ * <EditableCell value={100} onSave={handleSave} type="number" />
+ *
+ * // Decimal editing
+ * <EditableCell value={99.99} onSave={handleSave} type="decimal" step="0.01" />
+ */
+declare function EditableCell({ value, onSave, type, step, className, placeholder, disabled }: EditableCellProps): react_jsx_runtime.JSX.Element;
+declare const EditableTextCell: (props: Omit<EditableCellProps, "type"> & {
+    onSave: (value: string) => void;
+}) => react_jsx_runtime.JSX.Element;
+declare const EditableDecimalCell: (props: Omit<EditableCellProps, "type" | "step"> & {
+    step?: string;
+    onSave: (value: number) => void;
+}) => react_jsx_runtime.JSX.Element;
+
+interface QuantityInputPopupProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (quantity: number) => void;
+    triggerRef: React$1.RefObject<HTMLElement>;
+    className?: string;
+}
+declare function QuantityInputPopup({ isOpen, onClose, onConfirm, triggerRef, className }: QuantityInputPopupProps): react_jsx_runtime.JSX.Element;
+
+type ColorMode = 'light' | 'dark';
+type ThemeVariant = 'default' | 'red' | 'green' | 'purple' | 'orange' | 'black' | 'custom';
+type FontFamily = 'system' | 'roboto' | 'openSans' | 'lato' | 'poppins' | 'montserrat' | 'nunito' | 'sourceSansPro' | 'workSans' | 'ubuntu';
+type FontSize = 'small' | 'normal' | 'large' | 'extraLarge';
+type Theme = {
+    variant: ThemeVariant;
+    mode: ColorMode;
+    fontFamily?: FontFamily;
+    fontSize?: FontSize;
+    fontScale?: number;
+};
+interface CustomThemeColors {
+    accent: string;
+    accentHover: string;
+    accentSubtle: string;
+    accentMuted: string;
+}
+interface CustomTheme extends CustomThemeColors {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface ThemeContextValue {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+    setVariant: (variant: ThemeVariant) => void;
+    setMode: (mode: ColorMode) => void;
+    toggleMode: () => void;
+    setFontFamily: (family: FontFamily) => void;
+    setFontSize: (size: FontSize) => void;
+    setFontScale: (scale: number) => void;
+    customTheme: CustomTheme | null;
+    setCustomTheme: (colors: CustomThemeColors, name?: string) => void;
+    removeCustomTheme: () => void;
+    isDark: boolean;
+    isSystemPreference: boolean;
+    availableThemes: ThemeVariant[];
+    currentThemeClass: string;
+}
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+    enableSystem?: boolean;
+    attribute?: 'class' | 'data-theme';
+    defaultMode?: ColorMode;
+}
+
+declare const ThemeContext: React__default.Context<ThemeContextValue>;
+/**
+ * Theme Provider Component
+ *
+ * Provides theme context to the entire application.
+ * Should be placed at the root of your app, typically in layout.tsx
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider defaultTheme={{ variant: 'blue', mode: 'light' }}>
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ */
+declare function ThemeProvider({ children, defaultTheme, storageKey, enableSystem, attribute, defaultMode }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Theme Script Component
+ *
+ * Injects a script to prevent flash of incorrect theme on page load.
+ * Should be placed in the <head> of your document, typically in layout.tsx
+ *
+ * @example
+ * ```tsx
+ * <html>
+ *   <head>
+ *     <ThemeScript />
+ *   </head>
+ *   <body>...</body>
+ * </html>
+ * ```
+ */
+declare function ThemeScript({ storageKey, defaultTheme, defaultMode }: {
+    storageKey?: string;
+    defaultTheme?: string;
+    defaultMode?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface GlobalAlertContextType {
+    showSuccess: (title: string, description: string, autoCloseOrActions?: number | AlertAction[]) => void;
+    showError: (title: string, description: string) => void;
+    showWarning: (title: string, description: string, actions?: AlertAction[]) => void;
+    showInfo: (title: string, description: string, autoCloseOrActions?: number | AlertAction[]) => void;
+    showConfirmation: (title: string, description: string, onConfirm: () => void, onCancel?: () => void) => void;
+    showLoading: (title: string, description: string) => void;
+    showCritical: (title: string, description: string, actions?: AlertAction[]) => void;
+    hideAlert: () => void;
+    showAppStartup: (message?: string) => void;
+    showDataLoading: (message?: string) => void;
+    showFormSaving: (message?: string) => void;
+    showAuthentication: (message?: string) => void;
+    showBackgroundSync: (message?: string, progress?: string) => void;
+    showModalProcessing: (message?: string) => void;
+    showFieldValidation: (message?: string) => void;
+    hideLoading: () => void;
+}
+interface GlobalAlertProviderProps {
+    children: ReactNode;
+}
+declare function GlobalAlertProvider({ children }: GlobalAlertProviderProps): react_jsx_runtime.JSX.Element;
+declare function useGlobalAlert(): GlobalAlertContextType;
+declare function useQuickAlert(): {
+    showSuccess: (title: string, description: string, autoCloseOrActions?: number | AlertAction[]) => void;
+    showError: (title: string, description: string) => void;
+    showWarning: (title: string, description: string, actions?: AlertAction[]) => void;
+    showInfo: (title: string, description: string, autoCloseOrActions?: number | AlertAction[]) => void;
+    showConfirmation: (title: string, description: string, onConfirm: () => void, onCancel?: () => void) => void;
+    showLoading: (title: string, description: string) => void;
+    showCritical: (title: string, description: string, actions?: AlertAction[]) => void;
+    hideAlert: () => void;
+};
+
+interface AppConfigContextType {
+    selectedFinancialYear: string;
+    setSelectedFinancialYear: (fy: string) => void;
+    selectedProductionUnit: string;
+    setSelectedProductionUnit: (unit: string) => void;
+    getFinancialYearSuffix: () => string;
+}
+declare function AppConfigProvider({ children }: {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useAppConfig(): AppConfigContextType;
+
+type Language = 'en' | 'hi' | 'fr' | 'de' | 'es';
+interface LanguageContextType {
+    language: Language;
+    setLanguage: (lang: Language) => void;
+    translations: Record<string, string>;
+    isLoading: boolean;
+    t: (key: string) => string;
+}
+declare function LanguageProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useLanguage(): LanguageContextType;
+
+interface DeviceContextValue {
+    deviceType: 'desktop' | 'mobile' | 'tablet';
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+}
+declare function DeviceProvider({ children }: {
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useDevice(): DeviceContextValue;
+
+type SearchType = 'advanced' | 'new';
+interface SearchPreferences {
+    defaultSearchType: SearchType;
+    setDefaultSearchType: (type: SearchType) => void;
+}
+declare function SearchPreferencesProvider({ children }: {
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useSearchPreferences(): SearchPreferences;
+
+interface PageTitleContextType {
+    title: string;
+    setTitle: (title: string) => void;
+}
+declare const usePageTitle: () => PageTitleContextType;
+interface PageTitleProviderProps {
+    children: React__default.ReactNode;
+}
+declare const PageTitleProvider: React__default.FC<PageTitleProviderProps>;
+
+interface AuthSessionProviderProps {
+    children: React.ReactNode;
+    session: Session | null;
+}
+declare function AuthSessionProvider({ children, session }: AuthSessionProviderProps): react_jsx_runtime.JSX.Element;
+
+interface APIContextType {
+    initialized: boolean;
+}
+declare function useAPI(): APIContextType;
+interface APIProviderProps {
+    children: ReactNode;
+}
+declare function APIProvider({ children }: APIProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function QueryProvider({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { APIConfigModal, APIProvider, ActionsColumn, type ActionsColumnConfig, ActionsMenu, AdvancedFilterModal, Alert, type AlertAction, AlertDescription, AlertTitle, AppConfigProvider, AppShell, type AppShellProps, AreaChart, type AreaChartDataItem, type AreaChartProps, type AreaChartSeries, type AttachedFile, AuthSessionProvider, AutoResizeButton, Badge, type BadgeProps, BarChart, type BarChartDataItem, type BarChartProps, type BarChartSeries, BooleanBadge, type BooleanBadgeProps, BooleanCell, BoxPlotChart, type BoxPlotChartDataItem, type BoxPlotChartProps, type BreakdownItem, BubbleChart, type BubbleChartDataItem, type BubbleChartProps, type BubbleChartSeries, BulletChart, type BulletChartDataItem, type BulletChartProps, Button, type ButtonProps, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, CardView, CellRenderer, ChartCard, type ChartCardProps, DataVisualization as ChartView, Checkbox, CheckboxButton, type CheckboxButtonProps, type CheckboxProps, Collapsible, CollapsibleContent, CollapsibleTrigger, ColumnChooserModal, ColumnContextMenu, CompactFooter, type ComparisonBar, CurrencyProvider, DashboardTooltip, type DashboardTooltipProps, DataGrid, type DataGridProps, DataVisualization, DatePicker, type DatePickerProps, type DateRange, DateTimePicker, type DateTimePickerProps, DeviceProvider, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DonutChart, type DonutChartDataItem, type DonutChartProps, DraggableColumnHeader, DraggableRow, Dropdown, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type DropdownOption, type DropdownProps, DynamicSidebar, type DynamicSidebarProps, EditableCell$1 as EditableCell, type EditableCellProps$1 as EditableCellProps, EditableDecimalCell, EditableTableCell, EditableTextCell, ExpandableRow, ExpansionToggleCell, ExpansionToggleHeader, type FABAction, FileAttachment, type FileAttachmentProps, FilterBadge, FilterBadgeGroup, type FilterBadgeGroupProps, type FilterBadgeItem, type FilterBadgeProps, type FilterBadgeVariant, FilterBar, type FilterBarProps, type FilterConfig, FloatingActionButton, FlowMap, type FlowMapLine, type FlowMapMarker, type FlowMapProps, Footer, type FooterKPI, type FooterProps, FormToggle, type FormToggleProps, FunnelChart, type FunnelChartDataItem, type FunnelChartProps, GanttChart, type GanttChartProps, type GanttTask, GaugeChart, type GaugeChartProps, GeoMap, type GeoMapDataItem, type GeoMapMarker, type GeoMapProps, GlobalAPIConfigModal, GlobalAlertProvider, Grid, type GridProps, type HeaderStepItem, HeaderSteps, HeatmapChart, type HeatmapChartDataItem, type HeatmapChartProps, HistogramChart, type HistogramChartProps, ImageModal, type ImportResult, InlineSearchCell, Input, InputButton, type InputButtonProps, type InputProps, Kpi, KpiBeforeAfter, type KpiBeforeAfterProps, KpiBreakdown, type KpiBreakdownProps, KpiComparison, type KpiComparisonProps, type KpiProps, KpiQuickStats, type KpiQuickStatsProps, KpiRating, type KpiRatingProps, KpiScroll, type KpiScrollItem, type KpiScrollProps, KpiTrend, type KpiTrendProps, Label, LanguageProvider, LineChart, type LineChartDataItem, type LineChartProps, type LineChartSeries, Loading, LoadingOverlay, type LoadingProps, LoadingStates, LogoutModal, EditableCell as MasterEditableCell, Modal, ModalAlert, ModalClose, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalOverlay, ModalPortal, ModalTitle, ModalTrigger, NavigationProgress, Page, PageLoading, type PageLoadingProps, type PageProps, PageTitleProvider, PaginationControls, ParetoChart, type ParetoChartDataItem, type ParetoChartProps, ProcessBreakdown, Progress, QuantityInputPopup, QueryProvider, type QuickStat, RadarChart, type RadarChartIndicator, type RadarChartProps, type RadarChartSeries, TabsRoot as RadixTabs, type RatingBreakdown, type ReportOption, SankeyChart, type SankeyChartProps, type SankeyLink, type SankeyNode, ScatterChart, type ScatterChartDataItem, type ScatterChartProps, type ScatterChartSeries, SearchHighlighter, SearchNavigator, SearchNewModal, SearchPreferencesProvider, SelectionCell, SelectionCell as SelectionCheckbox, Separator, Skeleton, SkeletonFormFields, SkeletonTable, SkeletonText, Sparkline, type SparklineProps, StandardModal, type StandardModalProps, StatsCard, type StatsCardProps, StatsGrid, type StatsGridProps, SummaryRow, Switch, type TabItem, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, Text, type TextProps, Textarea, ThemeContext, ThemeProvider, ThemeScript, ThreeDModal, type TimeFilterSelection, type ToggleOption, Tooltip, TooltipContent, TooltipDetailed, TooltipProvider, TooltipTrigger, TreemapChart, type TreemapChartProps, type TreemapDataItem, UnifiedCurrencyDropdown, type UnifiedCurrencyDropdownProps, WaterfallChart, type WaterfallChartProps, type WaterfallDataItem, advancedSearch, barConfig, chartCard, chartColors, chartHeights, cn, createActionsColumn, createSelectColumn, donutConfig, exportData, exportToCSV, exportToExcel, exportToJSON, exportToPDF, fuzzyMatch, getChartHeight, getGridClasses, gridLayouts, importData, importFromCSV, importFromExcel, importFromJSON, spacing, useAPI, useAppConfig, useCellEditing, useCellRangeSelection, useClipboard, useCurrency, useDataGridState, useDevice, useGlobalAlert, useKeyboardNavigation, useLanguage, useModalAlert, usePageTitle, useQuickAlert, useSearchNavigation, useSearchPreferences };