import * as react from 'react'; import react__default, { ReactNode } from 'react'; import * as react_jsx_runtime from 'react/jsx-runtime'; import { LucideIcon } from 'lucide-react'; interface BirhausButtonProps extends Omit, 'children'> { label?: string; labelEs?: string; labelEn?: string; variant?: 'primary' | 'secondary' | 'destructive' | 'outline' | 'ghost'; size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl'; isPrimaryAction?: boolean; loading?: boolean; loadingText?: string; loadingTextEs?: string; loadingTextEn?: string; destructive?: boolean; undoAction?: () => Promise; undoTimeoutMs?: number; showSuccessState?: boolean; successText?: string; successTextEs?: string; successTextEn?: string; describedBy?: string; describedByEs?: string; describedByEn?: string; icon?: ReactNode; iconPosition?: 'left' | 'right'; fullWidth?: boolean; trackCognitiveLoad?: boolean; cognitiveLoadLevel?: 'low' | 'medium' | 'high'; children?: ReactNode; } declare const BirhausButton: react.ForwardRefExoticComponent>; declare function useBirhausButton(): { loading: boolean; success: boolean; executeAction: (action: () => Promise) => Promise; setLoading: react.Dispatch>; setSuccess: react.Dispatch>; }; interface BirhausBadgeProps extends react.HTMLAttributes { variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; size?: 'sm' | 'md' | 'lg'; } declare function BirhausBadge({ variant, size, className, children, ...props }: BirhausBadgeProps): react_jsx_runtime.JSX.Element; interface BirhausInputProps extends Omit, 'size' | 'prefix' | 'autoSave'> { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; error?: string; errorEs?: string; errorEn?: string; solution?: string; solutionEs?: string; solutionEn?: string; autoSave?: boolean; autoSaveDelay?: number; onAutoSave?: (value: string) => Promise; validateOnChange?: boolean; validateOnBlur?: boolean; validationRules?: ValidationRule$1[]; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'filled' | 'minimal'; prefix?: ReactNode; suffix?: ReactNode; showPasswordToggle?: boolean; showClearButton?: boolean; helpText?: string; helpTextEs?: string; helpTextEn?: string; loading?: boolean; success?: boolean; fieldPriority?: 'required' | 'optional' | 'progressive'; cognitiveWeight?: number; } interface ValidationRule$1 { test: (value: string) => boolean; errorEs: string; errorEn?: string; solutionEs?: string; solutionEn?: string; severity?: 'error' | 'warning' | 'info'; } declare const BirhausInput: react.ForwardRefExoticComponent>; declare const birhausValidationRules: { required: (fieldName: string) => ValidationRule$1; email: () => ValidationRule$1; minLength: (min: number) => ValidationRule$1; paraguayPhone: () => ValidationRule$1; ruc: () => ValidationRule$1; }; interface BirhausSelectOption { value: string; label: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; disabled?: boolean; icon?: ReactNode; group?: string; } interface BirhausSelectProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; options: BirhausSelectOption[]; value?: string | string[]; defaultValue?: string | string[]; onChange?: (value: string | string[]) => void; error?: string; errorEs?: string; errorEn?: string; placeholder?: string; placeholderEs?: string; placeholderEn?: string; multiple?: boolean; maxSelections?: number; searchable?: boolean; searchPlaceholder?: string; searchPlaceholderEs?: string; searchPlaceholderEn?: string; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'filled' | 'minimal'; helpText?: string; helpTextEs?: string; helpTextEn?: string; disabled?: boolean; required?: boolean; loading?: boolean; cognitiveLoadLevel?: 'low' | 'medium' | 'high'; showCognitiveWarning?: boolean; clearable?: boolean; closeOnSelect?: boolean; className?: string; id?: string; } declare const BirhausSelect: react.ForwardRefExoticComponent>; declare function useBirhausSelect(): { value: string | string[]; isOpen: boolean; handleChange: (newValue: string | string[]) => void; clear: () => void; setValue: react.Dispatch>; setIsOpen: react.Dispatch>; }; declare function createBirhausOptionGroups(options: BirhausSelectOption[], groupBy: (option: BirhausSelectOption) => string): Record; interface BirhausCardAction { id: string; label: string; labelEs?: string; labelEn?: string; icon?: ReactNode; onClick: () => void; variant?: 'primary' | 'secondary' | 'destructive'; disabled?: boolean; loading?: boolean; } interface BirhausCardProps extends React.HTMLAttributes { title?: string; titleEs?: string; titleEn?: string; subtitle?: string; subtitleEs?: string; subtitleEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; children?: ReactNode; header?: ReactNode; footer?: ReactNode; aside?: ReactNode; primaryAction?: BirhausCardAction; secondaryActions?: BirhausCardAction[]; collapsible?: boolean; defaultExpanded?: boolean; expandedContent?: ReactNode; status?: 'neutral' | 'success' | 'warning' | 'error' | 'info'; statusMessage?: string; statusMessageEs?: string; statusMessageEn?: string; variant?: 'default' | 'elevated' | 'outlined' | 'minimal'; size?: 'sm' | 'md' | 'lg'; loading?: boolean; skeleton?: boolean; lazyLoad?: boolean; selectable?: boolean; selected?: boolean; onSelect?: () => void; badge?: string | number; badgeVariant?: 'neutral' | 'success' | 'warning' | 'error'; timestamp?: Date; author?: string; category?: string; informationDensity?: 'low' | 'medium' | 'high'; className?: string; } declare const BirhausCard: react.ForwardRefExoticComponent>; declare function useBirhausCard(): { expanded: boolean; selected: boolean; loading: boolean; setExpanded: react.Dispatch>; setSelected: react.Dispatch>; setLoading: react.Dispatch>; toggleExpanded: () => void; toggleSelected: () => void; }; declare function createBirhausCardAction(id: string, labelEs: string, onClick: () => void, options?: { labelEn?: string; icon?: ReactNode; variant?: 'primary' | 'secondary' | 'destructive'; disabled?: boolean; }): BirhausCardAction; interface BirhausDialogAction { id: string; label: string; labelEs?: string; labelEn?: string; onClick: () => void | Promise; variant?: 'primary' | 'secondary' | 'destructive'; disabled?: boolean; loading?: boolean; icon?: ReactNode; } interface BirhausUndoConfig { enabled: boolean; timeoutMs?: number; undoAction: () => void | Promise; messageEs?: string; messageEn?: string; labelEs?: string; labelEn?: string; } interface BirhausDialogProps { open?: boolean; onOpenChange?: (open: boolean) => void; title?: string; titleEs?: string; titleEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; children?: ReactNode; undoConfig?: BirhausUndoConfig; variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; primaryAction?: BirhausDialogAction; secondaryActions?: BirhausDialogAction[]; size?: 'sm' | 'md' | 'lg' | 'xl' | 'full'; position?: 'center' | 'top' | 'bottom'; closeOnOverlayClick?: boolean; closeOnEscape?: boolean; persistent?: boolean; role?: 'dialog' | 'alertdialog'; ariaLabelledBy?: string; ariaDescribedBy?: string; className?: string; overlayClassName?: string; } declare const BirhausDialog: react.ForwardRefExoticComponent>; declare function useBirhausDialog(): { open: boolean; undoActive: boolean; openDialog: () => void; closeDialog: () => void; activateUndo: () => void; deactivateUndo: () => void; setOpen: react.Dispatch>; }; declare function createBirhausDialogAction(id: string, labelEs: string, onClick: () => void | Promise, options?: { labelEn?: string; icon?: ReactNode; variant?: 'primary' | 'secondary' | 'destructive'; disabled?: boolean; }): BirhausDialogAction; interface BirhausTableColumn$1 { id: string; header: string; headerEs?: string; headerEn?: string; accessor: keyof T | ((item: T) => any); sortable?: boolean; filterable?: boolean; searchable?: boolean; cell?: (value: any, item: T) => ReactNode; width?: string | number; align?: 'left' | 'center' | 'right'; isCurrency?: boolean; isPercentage?: boolean; isDate?: boolean; priority?: 'high' | 'medium' | 'low'; hideOnMobile?: boolean; cognitiveWeight?: number; } interface BirhausTableProps { data: T[]; columns: BirhausTableColumn$1[]; emptyMessage?: string; emptyMessageEs?: string; emptyMessageEn?: string; loadingMessage?: string; loadingMessageEs?: string; loadingMessageEn?: string; maxVisibleColumns?: number; showCognitiveWarning?: boolean; sortable?: boolean; filterable?: boolean; searchable?: boolean; selectable?: boolean; loading?: boolean; selectedRows?: Set; onRowSelect?: (id: string | number, selected: boolean) => void; onRowsSelect?: (ids: (string | number)[], selected: boolean) => void; pagination?: { page: number; pageSize: number; total: number; onPageChange: (page: number) => void; onPageSizeChange: (size: number) => void; }; sortConfig?: { key: string; direction: 'asc' | 'desc'; }; onSort?: (key: string, direction: 'asc' | 'desc') => void; filters?: Record; onFilter?: (filters: Record) => void; searchValue?: string; onSearch?: (value: string) => void; getRowId?: (item: T, index: number) => string | number; rowActions?: Array<{ id: string; label: string; labelEs?: string; labelEn?: string; icon?: ReactNode; onClick: (item: T) => void; variant?: 'primary' | 'secondary' | 'destructive'; disabled?: (item: T) => boolean; }>; variant?: 'default' | 'striped' | 'bordered' | 'minimal'; size?: 'sm' | 'md' | 'lg'; className?: string; } declare const BirhausTable: react.ForwardRefExoticComponent & react.RefAttributes>; declare function useBirhausTable(initialData?: T[]): { data: T[]; setData: react.Dispatch>; selectedRows: Set; setSelectedRows: react.Dispatch>>; sortConfig: { key: string; direction: "asc" | "desc"; } | undefined; setSortConfig: react.Dispatch>; filters: Record; setFilters: react.Dispatch>>; searchValue: string; setSearchValue: react.Dispatch>; handleRowSelect: (id: string | number, selected: boolean) => void; handleRowsSelect: (ids: (string | number)[], selected: boolean) => void; clearSelection: () => void; }; interface BirhausCheckboxProps extends Omit, 'size'> { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; indeterminate?: boolean; variant?: 'default' | 'success' | 'warning' | 'error'; size?: 'sm' | 'md' | 'lg'; labelPosition?: 'right' | 'left'; showStateIcon?: boolean; error?: boolean; errorMessage?: string; errorMessageEs?: string; errorMessageEn?: string; success?: boolean; successMessage?: string; successMessageEs?: string; successMessageEn?: string; className?: string; labelClassName?: string; } declare const BirhausCheckbox: react.ForwardRefExoticComponent>; interface BirhausSwitchProps extends Omit { size?: 'sm' | 'md' | 'lg'; showLabels?: boolean; onLabel?: string; onLabelEs?: string; onLabelEn?: string; offLabel?: string; offLabelEs?: string; offLabelEn?: string; } declare const BirhausSwitch: react.ForwardRefExoticComponent>; declare function useBirhausCheckbox(initialChecked?: boolean): { checked: boolean; setChecked: react.Dispatch>; error: boolean; setError: react.Dispatch>; success: boolean; setSuccess: react.Dispatch>; toggle: () => void; reset: () => void; }; interface BirhausTabItem { id: string; label: string; labelEs?: string; labelEn?: string; content: ReactNode; disabled?: boolean; icon?: ReactNode; badge?: string | number; cognitiveWeight?: number; } interface BirhausTabsProps { tabs: BirhausTabItem[]; activeTab?: string; onTabChange?: (tabId: string) => void; maxVisibleTabs?: number; showCognitiveWarning?: boolean; variant?: 'default' | 'pills' | 'underline' | 'bordered'; size?: 'sm' | 'md' | 'lg'; orientation?: 'horizontal' | 'vertical'; activateOnHover?: boolean; lazy?: boolean; overflowBehavior?: 'dropdown' | 'scroll' | 'wrap'; contentPadding?: boolean; className?: string; tabListClassName?: string; tabClassName?: string; contentClassName?: string; } declare const BirhausTabs: react.ForwardRefExoticComponent>; interface BirhausTabProps { id: string; label: string; labelEs?: string; labelEn?: string; disabled?: boolean; icon?: ReactNode; badge?: string | number; cognitiveWeight?: number; children: ReactNode; } declare const BirhausTab: { ({ children }: BirhausTabProps): react_jsx_runtime.JSX.Element; displayName: string; }; declare function useBirhausTabs(initialActiveTab?: string): { activeTab: string; setActiveTab: (tabId: string) => void; tabHistory: string[]; goBack: () => string | null; reset: (defaultTab: string) => void; }; declare function createBirhausTabItem(id: string, labelEs: string, content: ReactNode, options?: { labelEn?: string; icon?: ReactNode; badge?: string | number; disabled?: boolean; cognitiveWeight?: number; }): BirhausTabItem; interface BirhausComboboxOption { value: string; label: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; disabled?: boolean; group?: string; icon?: React.ReactNode; searchTerms?: string[]; } interface BirhausComboboxProps extends Omit, 'size'> { options: BirhausComboboxOption[]; value?: string; onValueChange?: (value: string) => void; placeholder?: string; placeholderEs?: string; placeholderEn?: string; emptyMessage?: string; emptyMessageEs?: string; emptyMessageEn?: string; searchPlaceholder?: string; searchPlaceholderEs?: string; searchPlaceholderEn?: string; maxVisibleOptions?: number; showCognitiveWarning?: boolean; searchable?: boolean; clearable?: boolean; disabled?: boolean; loading?: boolean; filterFunction?: (option: BirhausComboboxOption, search: string) => boolean; variant?: 'default' | 'success' | 'warning' | 'error'; size?: 'sm' | 'md' | 'lg'; error?: boolean; errorMessage?: string; errorMessageEs?: string; errorMessageEn?: string; required?: boolean; dropdownPosition?: 'bottom' | 'top' | 'auto'; className?: string; dropdownClassName?: string; } declare const BirhausCombobox: react.ForwardRefExoticComponent>; declare function useBirhausCombobox(initialValue?: string): { value: string; setValue: react.Dispatch>; isOpen: boolean; setIsOpen: react.Dispatch>; searchTerm: string; setSearchTerm: react.Dispatch>; reset: () => void; }; declare function createBirhausComboboxOption(value: string, labelEs: string, options?: { labelEn?: string; descriptionEs?: string; descriptionEn?: string; disabled?: boolean; group?: string; icon?: React.ReactNode; searchTerms?: string[]; }): BirhausComboboxOption; interface BirhausCalendarProps { label?: string; labelEs?: string; labelEn?: string; value?: Date | null; defaultValue?: Date | null; onChange?: (date: Date | null) => void; minDate?: Date; maxDate?: Date; disabledDates?: Date[]; disabledDaysOfWeek?: number[]; showTodayButton?: boolean; showClearButton?: boolean; showMonthYearSelector?: boolean; enableUndo?: boolean; undoTimeoutMs?: number; onUndo?: (previousDate: Date | null) => void; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'minimal' | 'inline'; describedBy?: string; describedByEs?: string; describedByEn?: string; error?: string; errorEs?: string; errorEn?: string; dateFormat?: 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY-MM-DD'; locale?: 'es' | 'en'; firstDayOfWeek?: 0 | 1; placeholder?: string; placeholderEs?: string; placeholderEn?: string; disabled?: boolean; required?: boolean; cognitiveWeight?: number; trackInteraction?: boolean; onFocus?: () => void; onBlur?: () => void; onMonthChange?: (month: number, year: number) => void; onYearChange?: (year: number) => void; } declare const BirhausCalendar: react.ForwardRefExoticComponent>; declare const useBirhausCalendar: (initialDate?: Date | null) => { selectedDate: Date | null; selectDate: (date: Date | null) => void; clearDate: () => void; undoLastSelection: () => Date | null; canUndo: boolean; undoHistory: Date[]; }; declare const createBirhausDateRange: (start: Date, end: Date) => Date[]; declare const getBirhausWeekdays: (exclude?: number[]) => number[]; declare const getBirhausWeekends: () => number[]; interface BirhausTextareaProps extends Omit, 'autoSave'> { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; error?: string; errorEs?: string; errorEn?: string; solution?: string; solutionEs?: string; solutionEn?: string; autoSave?: boolean; autoSaveDelay?: number; onAutoSave?: (value: string) => Promise; validateOnChange?: boolean; validateOnBlur?: boolean; validationRules?: ValidationRule[]; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'filled' | 'minimal'; maxLength?: number; showCharacterCount?: boolean; characterCountThreshold?: number; autoResize?: boolean; minRows?: number; maxRows?: number; enableUndo?: boolean; undoTimeoutMs?: number; undoThreshold?: number; helpText?: string; helpTextEs?: string; helpTextEn?: string; loading?: boolean; success?: boolean; fieldPriority?: 'required' | 'optional' | 'progressive'; cognitiveWeight?: number; locale?: 'es' | 'en'; } interface ValidationRule { test: (value: string) => boolean; errorEs: string; errorEn: string; solution?: string; solutionEs?: string; solutionEn?: string; } declare const BirhausTextarea: react.ForwardRefExoticComponent>; declare const birhausTextareaValidationRules: { required: () => ValidationRule; minLength: (min: number) => ValidationRule; maxWords: (max: number) => ValidationRule; noSpecialChars: () => ValidationRule; }; declare const useBirhausTextarea: (initialValue?: string) => { value: string; setValue: (newValue: string) => void; undo: () => string | null; redo: () => string | null; canUndo: boolean; canRedo: boolean; wordCount: number; characterCount: number; }; declare const CURRENCIES: { readonly PYG: { readonly symbol: "₲"; readonly name: "Guaraníes"; readonly nameEs: "Guaraníes"; readonly nameEn: "Paraguayan Guaraní"; readonly decimals: 0; readonly thousandsSeparator: "."; readonly decimalSeparator: ","; readonly symbolPosition: "before"; }; readonly USD: { readonly symbol: "$"; readonly name: "Dólares"; readonly nameEs: "Dólares"; readonly nameEn: "US Dollars"; readonly decimals: 2; readonly thousandsSeparator: ","; readonly decimalSeparator: "."; readonly symbolPosition: "before"; }; }; type CurrencyCode = keyof typeof CURRENCIES; interface BirhausCurrencyInputProps extends Omit, 'value' | 'onChange' | 'type' | 'defaultValue' | 'size' | 'autoSave'> { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; error?: string; errorEs?: string; errorEn?: string; value?: number | null; defaultValue?: number | null; onChange?: (value: number | null, currency: CurrencyCode) => void; currency?: CurrencyCode; defaultCurrency?: CurrencyCode; allowCurrencySwitch?: boolean; showCurrencyName?: boolean; exchangeRate?: number; showConversion?: boolean; onCurrencyChange?: (currency: CurrencyCode) => void; minValue?: number; maxValue?: number; requiredMessage?: string; requiredMessageEs?: string; requiredMessageEn?: string; autoSave?: boolean; autoSaveDelay?: number; onAutoSave?: (value: number | null, currency: CurrencyCode) => Promise; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'filled' | 'minimal'; enableUndo?: boolean; undoTimeoutMs?: number; undoThreshold?: number; helpText?: string; helpTextEs?: string; helpTextEn?: string; loading?: boolean; success?: boolean; fieldPriority?: 'required' | 'optional' | 'progressive'; locale?: 'es' | 'en'; } declare const BirhausCurrencyInput: react.ForwardRefExoticComponent>; declare const useBirhausCurrency: (initialValue?: number | null, initialCurrency?: CurrencyCode) => { amount: number | null; currency: "PYG" | "USD"; exchangeRate: number; setExchangeRate: react.Dispatch>; convert: (value: number, fromCurrency: CurrencyCode, toCurrency: CurrencyCode) => number; getFormattedAmount: (currencyCode?: CurrencyCode) => string; updateAmount: (newAmount: number | null, newCurrency?: CurrencyCode) => void; amountInPYG: number | null; amountInUSD: number | null; }; declare const paraguayanCurrencyUtils: { formatPYG: (amount: number) => string; formatUSD: (amount: number) => string; usdToPyg: (usdAmount: number, rate?: number) => number; pygToUsd: (pygAmount: number, rate?: number) => number; validateRUC: (ruc: string) => boolean; calculateIVA: (amount: number) => { baseAmount: number; ivaAmount: number; totalAmount: number; }; }; type ToastVariant = 'success' | 'error' | 'warning' | 'info'; interface BirhausToastData { id: string; variant: ToastVariant; title?: string; titleEs?: string; titleEn?: string; message?: string; messageEs?: string; messageEn?: string; duration?: number; persistent?: boolean; undoAction?: () => void | Promise; undoLabel?: string; undoLabelEs?: string; undoLabelEn?: string; action?: { label: string; labelEs?: string; labelEn?: string; onClick: () => void; }; onDismiss?: (id: string) => void; locale?: 'es' | 'en'; } interface BirhausToastProviderProps { children: ReactNode; maxToasts?: number; defaultLocale?: 'es' | 'en'; position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center'; } declare const BirhausToastProvider: ({ children, maxToasts, defaultLocale, position }: BirhausToastProviderProps) => react_jsx_runtime.JSX.Element; declare const useBirhausToast: () => { addToast: (toast: Omit) => string; dismissToast: (id: string) => void; clearAllToasts: () => void; showSuccess: (message: string, options?: Partial>) => string; showError: (message: string, options?: Partial>) => string; showWarning: (message: string, options?: Partial>) => string; showInfo: (message: string, options?: Partial>) => string; showSaved: (entity?: string, options?: Partial>) => string; showDeleted: (entity?: string, undoAction?: () => void, options?: Partial>) => string; showPaymentSuccess: (amount: string, options?: Partial>) => string; locale: "es" | "en"; toasts: BirhausToastData[]; }; interface BirhausToastStandaloneProps extends Omit { visible?: boolean; onClose?: () => void; } declare const BirhausToastStandalone: react.ForwardRefExoticComponent>; declare const birhausToastMessages: { saved: { es: string; en: string; }; deleted: { es: string; en: string; }; updated: { es: string; en: string; }; created: { es: string; en: string; }; memberAdded: { es: string; en: string; }; memberUpdated: { es: string; en: string; }; memberDeleted: { es: string; en: string; }; donationRecorded: { es: string; en: string; }; paymentProcessed: { es: string; en: string; }; receiptGenerated: { es: string; en: string; }; saveError: { es: string; en: string; }; deleteError: { es: string; en: string; }; networkError: { es: string; en: string; }; validationError: { es: string; en: string; }; }; type AlertVariant = 'success' | 'error' | 'warning' | 'info'; interface BirhausAlertAction { label: string; labelEs?: string; labelEn?: string; onClick: () => void | Promise; variant?: 'primary' | 'secondary'; loading?: boolean; } interface BirhausAlertProps { title?: string; titleEs?: string; titleEn?: string; message?: string; messageEs?: string; messageEn?: string; details?: string; detailsEs?: string; detailsEn?: string; collapsible?: boolean; defaultExpanded?: boolean; variant?: AlertVariant; size?: 'sm' | 'md' | 'lg'; dismissible?: boolean; dismissKey?: string; onDismiss?: () => void; autoHide?: boolean; autoHideDelay?: number; actions?: BirhausAlertAction[]; showIcon?: boolean; customIcon?: ReactNode; role?: 'alert' | 'alertdialog' | 'status'; locale?: 'es' | 'en'; className?: string; children?: ReactNode; } declare const BirhausAlert: react.ForwardRefExoticComponent>; declare const useBirhausAlert: (dismissKey?: string) => { isVisible: boolean; dismiss: () => void; reset: () => void; wasDismissed: boolean; }; declare const birhausAlertPresets: { memberSaved: { variant: "success"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; }; donationRecorded: { variant: "success"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; }; paymentProcessed: { variant: "success"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; }; saveError: { variant: "error"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; dismissible: boolean; }; validationError: { variant: "error"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; dismissible: boolean; }; networkError: { variant: "error"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; dismissible: boolean; }; unsavedChanges: { variant: "warning"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; actions: ({ label: string; labelEs: string; labelEn: string; variant: "primary"; onClick: () => void; } | { label: string; labelEs: string; labelEn: string; variant: "secondary"; onClick: () => void; })[]; }; deleteConfirmation: { variant: "warning"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; actions: ({ label: string; labelEs: string; labelEn: string; variant: "primary"; onClick: () => void; } | { label: string; labelEs: string; labelEn: string; variant: "secondary"; onClick: () => void; })[]; }; backupReminder: { variant: "info"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; detailsEs: string; detailsEn: string; collapsible: boolean; dismissible: boolean; dismissKey: string; }; updateAvailable: { variant: "info"; titleEs: string; titleEn: string; messageEs: string; messageEn: string; actions: ({ label: string; labelEs: string; labelEn: string; variant: "primary"; onClick: () => void; } | { label: string; labelEs: string; labelEn: string; variant: "secondary"; onClick: () => void; })[]; }; }; interface BirhausEmptyStateAction { label: string; labelEs?: string; labelEn?: string; onClick: () => void | Promise; variant?: 'primary' | 'secondary'; icon?: ReactNode; loading?: boolean; } interface BirhausEmptyStateProps { title?: string; titleEs?: string; titleEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; helpText?: string; helpTextEs?: string; helpTextEn?: string; showHelpText?: boolean; icon?: ReactNode; illustration?: ReactNode; size?: 'sm' | 'md' | 'lg'; actions?: BirhausEmptyStateAction[]; scenario?: 'members' | 'donations' | 'events' | 'search' | 'reports' | 'general'; loading?: boolean; error?: boolean; role?: string; locale?: 'es' | 'en'; className?: string; children?: ReactNode; } declare const BirhausEmptyState: react.ForwardRefExoticComponent>; declare const useBirhausEmptyState: (data: any[] | null | undefined, loading?: boolean, error?: Error | null) => { isEmpty: boolean; hasError: boolean; isLoading: boolean; showEmptyState: boolean; errorMessage: string | undefined; }; declare const birhausEmptyStatePresets: { noMembers: { scenario: "members"; actions: { labelEs: string; labelEn: string; variant: "primary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; filteredMembers: { scenario: "search"; titleEs: string; titleEn: string; descriptionEs: string; descriptionEn: string; actions: { labelEs: string; labelEn: string; variant: "secondary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; noDonations: { scenario: "donations"; actions: { labelEs: string; labelEn: string; variant: "primary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; monthlyDonations: { scenario: "reports"; titleEs: string; titleEn: string; descriptionEs: string; descriptionEn: string; actions: { labelEs: string; labelEn: string; variant: "secondary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; noEvents: { scenario: "events"; actions: { labelEs: string; labelEn: string; variant: "primary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; upcomingEvents: { scenario: "events"; titleEs: string; titleEn: string; descriptionEs: string; descriptionEn: string; actions: { labelEs: string; labelEn: string; variant: "primary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; noReportData: { scenario: "reports"; titleEs: string; titleEn: string; descriptionEs: string; descriptionEn: string; helpTextEs: string; helpTextEn: string; actions: { labelEs: string; labelEn: string; variant: "secondary"; icon: react_jsx_runtime.JSX.Element; onClick: () => void; }[]; }; }; interface DateRange { start: Date | null; end: Date | null; } interface PresetRange { id: string; labelEs: string; labelEn: string; getValue: () => DateRange; isDefault?: boolean; } interface BirhausDateRangePickerProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; value?: DateRange; defaultValue?: DateRange; onChange?: (range: DateRange) => void; error?: string; errorEs?: string; errorEn?: string; minDate?: Date; maxDate?: Date; maxRangeDays?: number; presets?: PresetRange[]; showPresets?: boolean; enableCustomRange?: boolean; enableUndo?: boolean; undoTimeoutMs?: number; disabled?: boolean; required?: boolean; placeholder?: string; autoApply?: boolean; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'minimal'; locale?: 'es' | 'en'; reportType?: 'financial' | 'membership' | 'events' | 'custom'; } declare const BirhausDateRangePicker: react.ForwardRefExoticComponent>; declare const useBirhausDateRange: (initialRange?: DateRange) => { range: DateRange; setRange: (newRange: DateRange) => void; undo: () => DateRange | null; redo: () => DateRange | null; canUndo: boolean; canRedo: boolean; daysBetween: number; isValid: boolean | null; }; declare const ipuAdminDatePresets: { financial: () => PresetRange[]; events: () => PresetRange[]; }; interface SearchSuggestion { id: string; text: string; category?: SearchCategory; icon?: React.ReactNode; metadata?: string; } interface SearchCategory { id: string; labelEs: string; labelEn: string; icon: React.ReactNode; color: string; } interface BirhausSearchInputProps extends Omit, 'size'> { label?: string; labelEs?: string; labelEn?: string; placeholderEs?: string; placeholderEn?: string; value?: string; defaultValue?: string; onSearch?: (query: string) => void; onSuggestionSelect?: (suggestion: SearchSuggestion) => void; suggestions?: SearchSuggestion[]; loadingSuggestions?: boolean; maxSuggestions?: number; categories?: SearchCategory[]; selectedCategory?: string; onCategoryChange?: (categoryId: string) => void; enableRecentSearches?: boolean; maxRecentSearches?: number; recentSearches?: string[]; onRecentSearchesChange?: (searches: string[]) => void; enableUndo?: boolean; undoTimeoutMs?: number; debounceMs?: number; minQueryLength?: number; disabled?: boolean; required?: boolean; size?: 'sm' | 'md' | 'lg'; variant?: 'default' | 'minimal' | 'filled'; showIcon?: boolean; locale?: 'es' | 'en'; searchScope?: 'all' | 'members' | 'donations' | 'events' | 'reports'; } declare const BirhausSearchInput: react.ForwardRefExoticComponent>; declare const useBirhausSearch: (initialQuery?: string) => { query: string; setQuery: react.Dispatch>; recentSearches: string[]; setRecentSearches: react.Dispatch>; addToHistory: (searchQuery: string) => void; clearHistory: () => void; isLoading: boolean; setIsLoading: react.Dispatch>; suggestions: SearchSuggestion[]; setSuggestions: react.Dispatch>; performSearch: (searchQuery: string, searchFn?: (query: string) => Promise) => Promise; }; declare const ipuAdminSearchCategories: SearchCategory[]; declare const createIPUAdminSuggestion: (id: string, text: string, category: SearchCategory, metadata?: string) => SearchSuggestion; interface FileItem { id: string; file: File; preview?: string; progress: number; status: 'pending' | 'uploading' | 'completed' | 'error'; error?: string; } interface BirhausFileUploadProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; files?: FileItem[]; defaultFiles?: FileItem[]; onChange?: (files: FileItem[]) => void; onUpload?: (file: File) => Promise; onRemove?: (fileId: string) => Promise; error?: string; errorEs?: string; errorEn?: string; acceptedTypes?: string[]; maxFileSize?: number; maxFiles?: number; uploadType?: 'receipts' | 'reports' | 'photos' | 'documents' | 'custom'; enableUndo?: boolean; undoTimeoutMs?: number; disabled?: boolean; required?: boolean; variant?: 'default' | 'compact' | 'minimal'; size?: 'sm' | 'md' | 'lg'; enableDragDrop?: boolean; locale?: 'es' | 'en'; showPreview?: boolean; previewSize?: 'sm' | 'md' | 'lg'; } declare const BirhausFileUpload: react.ForwardRefExoticComponent>; declare const useBirhausFileUpload: (maxFiles?: number) => { files: FileItem[]; setFiles: react.Dispatch>; addFiles: (newFiles: FileItem[]) => void; removeFile: (fileId: string) => void; updateFileStatus: (fileId: string, updates: Partial) => void; uploadAll: (uploadFn: (file: File) => Promise) => Promise; isUploading: boolean; hasErrors: boolean; allCompleted: boolean; totalProgress: number; }; interface PaginationInfo$1 { currentPage: number; totalPages: number; totalItems: number; itemsPerPage: number; startItem: number; endItem: number; } interface BirhausPaginationProps { label?: string; labelEs?: string; labelEn?: string; currentPage: number; totalItems: number; itemsPerPage: number; onPageChange: (page: number) => void; pageSizeOptions?: number[]; onPageSizeChange?: (pageSize: number) => void; showPageSizeSelector?: boolean; maxVisiblePages?: number; showQuickJump?: boolean; showFirstLast?: boolean; disabled?: boolean; variant?: 'default' | 'minimal' | 'compact'; size?: 'sm' | 'md' | 'lg'; previousLabel?: string; nextLabel?: string; firstLabel?: string; lastLabel?: string; ofLabel?: string; itemsLabel?: string; locale?: 'es' | 'en'; mobileVariant?: 'compact' | 'minimal' | 'hidden'; showItemsInfo?: boolean; showQuickActions?: boolean; } declare const BirhausPagination: react.ForwardRefExoticComponent>; declare const useBirhausPagination: (totalItems: number, initialPageSize?: number) => { currentPage: number; pageSize: number; totalPages: number; startIndex: number; endIndex: number; handlePageChange: (page: number) => void; handlePageSizeChange: (newPageSize: number) => void; reset: () => void; hasNextPage: boolean; hasPreviousPage: boolean; }; declare const ipuAdminPaginationConfig: { members: { defaultPageSize: number; pageSizeOptions: number[]; showQuickJump: boolean; }; donations: { defaultPageSize: number; pageSizeOptions: number[]; showQuickJump: boolean; }; events: { defaultPageSize: number; pageSizeOptions: number[]; showQuickJump: boolean; }; reports: { defaultPageSize: number; pageSizeOptions: number[]; showQuickJump: boolean; }; }; interface CheckboxOption { id: string; value: string; labelEs: string; labelEn: string; description?: string; descriptionEs?: string; descriptionEn?: string; disabled?: boolean; icon?: React.ReactNode; category?: string; } interface CheckboxCategory { id: string; labelEs: string; labelEn: string; description?: string; descriptionEs?: string; descriptionEn?: string; icon?: React.ReactNode; color?: string; } interface BirhausCheckboxGroupProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; options: CheckboxOption[]; value?: string[]; defaultValue?: string[]; onChange?: (values: string[]) => void; error?: string; errorEs?: string; errorEn?: string; categories?: CheckboxCategory[]; showCategories?: boolean; maxItemsPerCategory?: number; disabled?: boolean; required?: boolean; showSelectAll?: boolean; selectAllLabelEs?: string; selectAllLabelEn?: string; variant?: 'default' | 'cards' | 'minimal'; size?: 'sm' | 'md' | 'lg'; layout?: 'vertical' | 'horizontal' | 'grid'; minSelections?: number; maxSelections?: number; locale?: 'es' | 'en'; presetType?: 'permissions' | 'ministries' | 'roles' | 'custom'; } declare const BirhausCheckboxGroup: react.ForwardRefExoticComponent>; declare const useBirhausCheckboxGroup: (options: CheckboxOption[], initialValues?: string[]) => { selectedValues: string[]; setSelectedValues: react.Dispatch>; selectAll: () => void; deselectAll: () => void; toggleOption: (value: string) => void; isSelected: (value: string) => boolean; getSelectedOptions: () => CheckboxOption[]; selectedCount: number; allSelected: boolean; noneSelected: boolean; }; declare const ipuAdminCheckboxOptions: { permissions: () => CheckboxOption[]; ministries: () => CheckboxOption[]; }; interface ProgressMilestone { id: string; value: number; labelEs: string; labelEn: string; description?: string; descriptionEs?: string; descriptionEn?: string; icon?: React.ReactNode; color?: string; reached?: boolean; } interface ProgressMetrics { current: number; target: number; percentage: number; remaining: number; timeElapsed?: number; timeRemaining?: number; averagePerDay?: number; } interface BirhausProgressProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; current: number; target: number; unit?: string; type?: 'linear' | 'circular' | 'stepped' | 'radial'; variant?: 'default' | 'success' | 'warning' | 'error' | 'gradient'; milestones?: ProgressMilestone[]; showMilestones?: boolean; startDate?: Date; endDate?: Date; showTimeMetrics?: boolean; size?: 'sm' | 'md' | 'lg' | 'xl'; showPercentage?: boolean; showValues?: boolean; showAnimation?: boolean; animationDuration?: number; colorThresholds?: { low: number; medium: number; high: number; }; ariaLabel?: string; ariaLabelEs?: string; ariaLabelEn?: string; locale?: 'es' | 'en'; progressType?: 'donation_goal' | 'membership_goal' | 'event_capacity' | 'fundraising' | 'custom'; campaignName?: string; onMilestoneReached?: (milestone: ProgressMilestone) => void; onTargetReached?: () => void; } declare const BirhausProgress: react.ForwardRefExoticComponent>; declare const useBirhausProgress: (target: number, initialValue?: number) => { current: number; setCurrent: (value: number) => void; increment: (amount: number) => void; decrement: (amount: number) => void; reset: () => void; percentage: number; remaining: number; isComplete: boolean; milestones: ProgressMilestone[]; setMilestones: react.Dispatch>; }; declare const ipuAdminProgressPresets: { donationGoal: (target: number, currency?: string) => { type: "linear"; progressType: "donation_goal"; unit: string; showTimeMetrics: boolean; showMilestones: boolean; colorThresholds: { low: number; medium: number; high: number; }; }; membershipGoal: (target: number, locale?: string) => { type: "circular"; progressType: "membership_goal"; unit: string; showMilestones: boolean; colorThresholds: { low: number; medium: number; high: number; }; }; eventCapacity: (target: number, locale?: string) => { type: "linear"; progressType: "event_capacity"; unit: string; showMilestones: boolean; showTimeMetrics: boolean; colorThresholds: { low: number; medium: number; high: number; }; }; }; interface RadioOption { id: string; value: string; labelEs: string; labelEn: string; description?: string; descriptionEs?: string; descriptionEn?: string; disabled?: boolean; icon?: React.ReactNode; badge?: string; badgeEs?: string; badgeEn?: string; recommended?: boolean; } interface BirhausRadioGroupProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; options: RadioOption[]; value?: string; defaultValue?: string; onChange?: (value: string) => void; name: string; error?: string; errorEs?: string; errorEn?: string; disabled?: boolean; required?: boolean; variant?: 'default' | 'cards' | 'minimal' | 'buttons'; size?: 'sm' | 'md' | 'lg'; layout?: 'vertical' | 'horizontal' | 'grid'; showIcons?: boolean; showDescriptions?: boolean; showBadges?: boolean; highlightRecommended?: boolean; maxOptions?: number; locale?: 'es' | 'en'; presetType?: 'payment_methods' | 'member_status' | 'event_types' | 'donation_types' | 'custom'; } declare const BirhausRadioGroup: react.ForwardRefExoticComponent>; declare const useBirhausRadioGroup: (options: RadioOption[], initialValue?: string) => { selectedValue: string; setSelectedValue: (value: string) => void; clearSelection: () => void; getSelectedOption: () => RadioOption | undefined; isSelected: (value: string) => boolean; getNextOption: () => RadioOption; getPreviousOption: () => RadioOption; hasSelection: boolean; }; declare const ipuAdminRadioGroupPresets: { paymentMethods: { variant: "cards"; showIcons: boolean; showDescriptions: boolean; highlightRecommended: boolean; presetType: "payment_methods"; }; memberStatus: { variant: "buttons"; layout: "horizontal"; showBadges: boolean; highlightRecommended: boolean; presetType: "member_status"; }; eventTypes: { variant: "default"; showIcons: boolean; showDescriptions: boolean; presetType: "event_types"; }; donationTypes: { variant: "cards"; showIcons: boolean; showDescriptions: boolean; highlightRecommended: boolean; presetType: "donation_types"; }; }; interface BirhausToggleProps { label?: string; labelEs?: string; labelEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; onLabel?: string; onLabelEs?: string; onLabelEn?: string; offLabel?: string; offLabelEs?: string; offLabelEn?: string; onDescription?: string; onDescriptionEs?: string; onDescriptionEn?: string; offDescription?: string; offDescriptionEs?: string; offDescriptionEn?: string; checked?: boolean; defaultChecked?: boolean; onChange?: (checked: boolean) => void; confirmationRequired?: boolean; confirmationMessageEs?: string; confirmationMessageEn?: string; enableUndo?: boolean; undoTimeoutMs?: number; criticalAction?: boolean; disabled?: boolean; variant?: 'default' | 'success' | 'warning' | 'danger'; size?: 'sm' | 'md' | 'lg'; showStateLabels?: boolean; showStateIcons?: boolean; animationDuration?: number; loading?: boolean; locale?: 'es' | 'en'; settingType?: 'privacy' | 'notifications' | 'permissions' | 'visibility' | 'security' | 'custom'; onAsyncChange?: (checked: boolean) => Promise; } declare const BirhausToggle: react.ForwardRefExoticComponent>; declare const useBirhausToggle: (initialValue?: boolean) => { isOn: boolean; toggle: () => void; turnOn: () => void; turnOff: () => void; setValue: (value: boolean) => void; undo: () => boolean | null; redo: () => boolean | null; canUndo: boolean; canRedo: boolean; }; declare const ipuAdminTogglePresets: { memberVisibility: { settingType: "visibility"; onLabelEs: string; onLabelEn: string; offLabelEs: string; offLabelEn: string; showStateLabels: boolean; enableUndo: boolean; }; donationNotifications: { settingType: "notifications"; onLabelEs: string; onLabelEn: string; offLabelEs: string; offLabelEn: string; showStateIcons: boolean; enableUndo: boolean; }; dataPrivacy: { settingType: "privacy"; variant: "danger"; onLabelEs: string; onLabelEn: string; offLabelEs: string; offLabelEn: string; confirmationRequired: boolean; criticalAction: boolean; enableUndo: boolean; }; adminPermissions: { settingType: "permissions"; variant: "warning"; onLabelEs: string; onLabelEn: string; offLabelEs: string; offLabelEn: string; confirmationRequired: boolean; criticalAction: boolean; enableUndo: boolean; showStateIcons: boolean; }; securityMode: { settingType: "security"; variant: "success"; onLabelEs: string; onLabelEn: string; offLabelEs: string; offLabelEn: string; showStateLabels: boolean; showStateIcons: boolean; enableUndo: boolean; }; }; /** * BIRHAUS DataTable Types * Following BIRHAUS principles with Spanish-first internationalization */ type SortDirection = 'asc' | 'desc' | null; interface BirhausTableColumn { key: string; labelEs: string; labelEn?: string; sortable?: boolean; searchable?: boolean; render?: (item: T, index: number) => ReactNode; className?: string; headerClassName?: string; width?: string; } interface BirhausBulkAction$1 { labelEs: string; labelEn?: string; icon?: React.ComponentType<{ className?: string; }>; onClick: (selectedItems: T[]) => void | Promise; variant?: 'primary' | 'secondary' | 'outline' | 'ghost' | 'destructive'; requireConfirm?: boolean; disabled?: boolean; } interface PaginationInfo { currentPage: number; pageSize: number; totalCount: number; totalPages: number; hasNextPage: boolean; hasPreviousPage: boolean; } interface BirhausDataTableProps { data: T[]; columns: BirhausTableColumn[]; keyField: keyof T; loading?: boolean; error?: string | null; searchPlaceholderEs?: string; searchPlaceholderEn?: string; globalSearch?: boolean; onSearch?: (term: string) => void; totalCount?: number; pageSize?: number; currentPage?: number; onPageChange?: (page: number) => void; pageSizeOptions?: number[]; onPageSizeChange?: (size: number) => void; selectable?: boolean; selectedItems?: T[]; onSelectionChange?: (items: T[]) => void; bulkActions?: BirhausBulkAction$1[]; enableEnhancedBulkActions?: boolean; bulkActionBarPosition?: 'top' | 'bottom'; onBulkActionStart?: (action: BirhausBulkAction$1, items: T[]) => void; onBulkActionComplete?: (action: BirhausBulkAction$1, items: T[], result?: any) => void; onBulkActionError?: (action: BirhausBulkAction$1, items: T[], error: Error) => void; onRowClick?: (item: T) => void; rowActions?: (item: T) => ReactNode; exportable?: boolean; onExport?: (format: string, options: { data: T[]; columns: BirhausTableColumn[]; }) => void | Promise; className?: string; rowClassName?: (item: T, index: number) => string; emptyMessageEs?: string; emptyMessageEn?: string; emptyIcon?: LucideIcon; locale?: 'es' | 'en'; } interface UseBirhausDataTableReturn { data: T[]; setData: (data: T[]) => void; loading: boolean; setLoading: (loading: boolean) => void; error: string | null; setError: (error: string | null) => void; selectedItems: T[]; setSelectedItems: (items: T[]) => void; resetSelection: () => void; currentPage: number; setCurrentPage: (page: number) => void; pageSize: number; setPageSize: (size: number) => void; resetPagination: () => void; searchTerm: string; setSearchTerm: (term: string) => void; totalCount: number; hasSelection: boolean; paginationInfo: PaginationInfo; } interface DataTableMetrics { columnsCount: number; rowsPerPage: number; bulkActionsCount: number; cognitiveLoad: 'low' | 'medium' | 'high'; } /** * BirhausDataTable - Advanced data table component with BIRHAUS principles * * Features: * - Spanish-first labels with English fallbacks * - Miller's Law compliance (max 7±2 items in pagination) * - Cognitive load reduction through progressive disclosure * - Accessibility-first design (WCAG AA+) * - Undo-over-confirm patterns (no confirmation dialogs) */ declare function BirhausDataTable>({ data, columns, keyField, loading, error, searchPlaceholderEs, searchPlaceholderEn, globalSearch, onSearch, totalCount, pageSize, currentPage, onPageChange, pageSizeOptions, onPageSizeChange, selectable, selectedItems, onSelectionChange, bulkActions, onRowClick, rowActions, exportable, onExport, className, rowClassName, emptyMessageEs, emptyMessageEn, emptyIcon: EmptyIcon, locale }: BirhausDataTableProps): react_jsx_runtime.JSX.Element; declare function useBirhausDataTable>(initialData?: T[]): { data: T[]; setData: react__default.Dispatch>; loading: boolean; setLoading: react__default.Dispatch>; error: string | null; setError: react__default.Dispatch>; selectedItems: T[]; setSelectedItems: react__default.Dispatch>; resetSelection: () => void; currentPage: number; setCurrentPage: react__default.Dispatch>; pageSize: number; setPageSize: react__default.Dispatch>; resetPagination: () => void; searchTerm: string; setSearchTerm: react__default.Dispatch>; totalCount: number; hasSelection: boolean; paginationInfo: PaginationInfo; }; /** * Validates cognitive load based on BIRHAUS principles */ declare function validateCognitiveLoad(columns: BirhausTableColumn[], bulkActions?: BirhausBulkAction$1[]): DataTableMetrics; /** * Factory function to create BIRHAUS-compliant table columns */ declare function createBirhausTableColumn(key: string, labelEs: string, labelEn?: string, options?: Partial, 'key' | 'labelEs' | 'labelEn'>>): BirhausTableColumn; /** * Factory function to create BIRHAUS-compliant bulk actions */ declare function createBirhausBulkAction(labelEs: string, onClick: (items: T[]) => void | Promise, labelEn?: string, options?: Partial, 'labelEs' | 'labelEn' | 'onClick'>>): BirhausBulkAction$1; /** * Utility to sort data with nested key support */ declare function sortDataByColumn(data: T[], columnKey: string, direction: 'asc' | 'desc'): T[]; /** * Filter data based on search term and searchable columns */ declare function filterDataBySearch(data: T[], searchTerm: string, columns: BirhausTableColumn[]): T[]; declare const commonColumnTypes: { text: (key: string, labelEs: string, labelEn?: string) => BirhausTableColumn; number: (key: string, labelEs: string, labelEn?: string) => BirhausTableColumn; date: (key: string, labelEs: string, labelEn?: string) => BirhausTableColumn; currency: (key: string, labelEs: string, labelEn?: string) => BirhausTableColumn; boolean: (key: string, labelEs: string, labelEn?: string) => BirhausTableColumn; }; interface BirhausSearchableListProps$1 { items: T[]; getItemKey: (item: T) => string; renderItem?: (item: T, isSelected: boolean) => react.ReactNode; searchKeys?: (keyof T)[]; searchPlaceholderEs?: string; searchPlaceholderEn?: string; debounceMs?: number; onSelect?: (item: T) => void; onMultiSelect?: (items: T[]) => void; multiSelect?: boolean; selectedItems?: T[]; maxSelectable?: number; showSelectedCount?: boolean; showSelectAll?: boolean; height?: number | string; virtualize?: boolean; itemHeight?: number; loading?: boolean; groupBy?: (item: T) => string; sortBy?: (a: T, b: T) => number; className?: string; listClassName?: string; searchClassName?: string; emptyMessageEs?: string; emptyMessageEn?: string; emptySearchMessageEs?: string; emptySearchMessageEn?: string; showCognitiveWarning?: boolean; cognitiveMode?: 'strict' | 'warning' | 'disabled'; selectAllLabelEs?: string; selectAllLabelEn?: string; selectedCountLabelEs?: string; selectedCountLabelEn?: string; maxSelectionLabelEs?: string; maxSelectionLabelEn?: string; } declare function BirhausSearchableList({ items, getItemKey, renderItem, searchKeys, searchPlaceholderEs, searchPlaceholderEn, debounceMs, onSelect, onMultiSelect, multiSelect, selectedItems, maxSelectable, showSelectedCount, showSelectAll, height, virtualize, itemHeight, loading, groupBy, sortBy, className, listClassName, searchClassName, emptyMessageEs, emptyMessageEn, emptySearchMessageEs, emptySearchMessageEn, showCognitiveWarning, cognitiveMode, selectAllLabelEs, selectAllLabelEn, selectedCountLabelEs, selectedCountLabelEn, maxSelectionLabelEs, maxSelectionLabelEn }: BirhausSearchableListProps$1): react_jsx_runtime.JSX.Element; interface BirhausSearchableListItem { [key: string]: any; } interface BirhausSearchableListOption { value: string; labelEs: string; labelEn: string; disabled?: boolean; data?: T; } interface BirhausSearchableListGroup { name: string; items: any[]; expanded?: boolean; } interface BirhausSearchableListCognitiveWarning { type: 'high_item_count' | 'high_selection_limit' | 'virtualization_needed' | 'search_recommended'; message: string; recommendation: string; } interface BirhausSearchableListMetrics { totalItems: number; filteredItems: number; selectedItems: number; groups: number; isVirtualized: boolean; searchActive: boolean; cognitiveScore: number; } interface BirhausSearchableListPerformance { renderTime: number; searchTime: number; virtualItems: number; memoryUsage: 'low' | 'medium' | 'high'; } type BirhausSearchableListSelectHandler = (item: T) => void; type BirhausSearchableListMultiSelectHandler = (items: T[]) => void; type BirhausSearchableListSearchHandler = (term: string) => void; type BirhausSearchableListGroupToggleHandler = (groupName: string, expanded: boolean) => void; type BirhausSearchableListItemRenderer = (item: T, isSelected: boolean, index?: number) => React.ReactNode; type BirhausSearchableListGroupRenderer = (groupName: string, itemCount: number, isExpanded: boolean) => React.ReactNode; type MillersLawCompliantNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; interface BirhausSearchableListValidation { isMillersLawCompliant: boolean; cognitiveLoadScore: number; warnings: BirhausSearchableListCognitiveWarning[]; recommendations: string[]; } interface BirhausSearchableListProps { items: T[]; getItemKey: (item: T) => string; renderItem?: BirhausSearchableListItemRenderer; searchKeys?: (keyof T)[]; searchPlaceholderEs?: string; searchPlaceholderEn?: string; debounceMs?: number; onSearch?: BirhausSearchableListSearchHandler; onSelect?: BirhausSearchableListSelectHandler; onMultiSelect?: BirhausSearchableListMultiSelectHandler; multiSelect?: boolean; selectedItems?: T[]; maxSelectable?: number; showSelectedCount?: boolean; showSelectAll?: boolean; height?: number | string; virtualize?: boolean; itemHeight?: number; loading?: boolean; groupBy?: (item: T) => string; sortBy?: (a: T, b: T) => number; onGroupToggle?: BirhausSearchableListGroupToggleHandler; className?: string; listClassName?: string; searchClassName?: string; itemClassName?: string; emptyMessageEs?: string; emptyMessageEn?: string; emptySearchMessageEs?: string; emptySearchMessageEn?: string; showCognitiveWarning?: boolean; cognitiveMode?: 'strict' | 'warning' | 'disabled'; selectAllLabelEs?: string; selectAllLabelEn?: string; selectedCountLabelEs?: string; selectedCountLabelEn?: string; maxSelectionLabelEs?: string; maxSelectionLabelEn?: string; 'aria-label'?: string; 'aria-describedby'?: string; role?: string; onMetrics?: (metrics: BirhausSearchableListMetrics) => void; onPerformance?: (performance: BirhausSearchableListPerformance) => void; } /** * BIRHAUS Utility Functions for Searchable List * Implements Miller's Law (7±2) and cognitive load principles */ /** * Validates if the list configuration complies with Miller's Law */ declare function validateMillersLawCompliance(items: T[], maxSelectable?: number, groupCount?: number): BirhausSearchableListValidation; /** * Calculate cognitive load metrics for the list */ declare function calculateCognitiveMetrics(items: T[], filteredItems: T[], selectedItems: T[], groups: Map | null, isVirtualized: boolean, searchActive: boolean): BirhausSearchableListMetrics; /** * Auto-configure list based on data size and BIRHAUS principles */ declare function autoConfigureForCognitiveLoad(items: T[], currentProps: Partial>): Partial>; /** * Filter items based on search term and keys */ declare function filterItems(items: T[], searchTerm: string, searchKeys?: (keyof T)[]): T[]; /** * Group items by a grouping function */ declare function groupItems(items: T[], groupBy: (item: T) => string): Map; /** * Get display name for an item (fallback chain) */ declare function getItemDisplayName(item: T, key: string): string; /** * Debounce function for search input */ declare function createDebounce any>(func: T, delay: number): (...args: Parameters) => void; /** * BIRHAUS presets for common use cases */ declare const BirhausSearchableListPresets: { readonly students: { readonly searchKeys: any; readonly maxSelectable: 7; readonly showCognitiveWarning: true; readonly cognitiveMode: "warning"; readonly searchPlaceholderEs: "Buscar estudiantes..."; readonly searchPlaceholderEn: "Search students..."; readonly emptyMessageEs: "No hay estudiantes"; readonly emptyMessageEn: "No students found"; readonly itemHeight: 72; }; readonly churches: { readonly searchKeys: any; readonly groupBy: (item: any) => any; readonly maxSelectable: 5; readonly showCognitiveWarning: true; readonly cognitiveMode: "strict"; readonly searchPlaceholderEs: "Buscar iglesias..."; readonly searchPlaceholderEn: "Search churches..."; readonly emptyMessageEs: "No hay iglesias"; readonly emptyMessageEn: "No churches found"; readonly itemHeight: 80; }; readonly employees: { readonly searchKeys: any; readonly groupBy: (item: any) => any; readonly maxSelectable: 6; readonly showCognitiveWarning: true; readonly cognitiveMode: "warning"; readonly searchPlaceholderEs: "Buscar empleados..."; readonly searchPlaceholderEn: "Search employees..."; readonly emptyMessageEs: "No hay empleados"; readonly emptyMessageEn: "No employees found"; readonly itemHeight: 76; }; readonly transactions: { readonly searchKeys: any; readonly maxSelectable: 10; readonly virtualize: true; readonly showCognitiveWarning: false; readonly cognitiveMode: "disabled"; readonly searchPlaceholderEs: "Buscar transacciones..."; readonly searchPlaceholderEn: "Search transactions..."; readonly emptyMessageEs: "No hay transacciones"; readonly emptyMessageEn: "No transactions found"; readonly itemHeight: 68; }; readonly inventory: { readonly searchKeys: any; readonly groupBy: (item: any) => any; readonly maxSelectable: 8; readonly showCognitiveWarning: true; readonly cognitiveMode: "warning"; readonly searchPlaceholderEs: "Buscar productos..."; readonly searchPlaceholderEn: "Search products..."; readonly emptyMessageEs: "No hay productos"; readonly emptyMessageEn: "No products found"; readonly itemHeight: 84; }; }; interface BirhausResourceCardAvatar$1 { src?: string; initials?: string; icon?: LucideIcon; fallbackColor?: 'default' | 'blue' | 'green' | 'purple' | 'orange' | 'pink'; } interface BirhausResourceCardStatus$1 { labelEs: string; labelEn: string; variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; } interface BirhausResourceCardBadge$1 { labelEs: string; labelEn: string; variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; } interface BirhausResourceCardInfo$1 { labelEs: string; labelEn: string; value: string | number; icon?: LucideIcon; highlight?: boolean; format?: 'text' | 'number' | 'currency' | 'date' | 'phone' | 'email'; } interface BirhausResourceCardAction$1 { keyEs: string; keyEn: string; labelEs: string; labelEn: string; onClick: () => void; icon?: LucideIcon; variant?: 'primary' | 'secondary' | 'ghost' | 'destructive'; condition?: (data: any) => boolean; divider?: boolean; } interface BirhausResourceCardProps$1 { id: string; titleEs: string; titleEn: string; subtitleEs?: string; subtitleEn?: string; descriptionEs?: string; descriptionEn?: string; avatar?: BirhausResourceCardAvatar$1; status?: BirhausResourceCardStatus$1; badges?: BirhausResourceCardBadge$1[]; primaryInfo?: BirhausResourceCardInfo$1[]; secondaryInfo?: BirhausResourceCardInfo$1[]; primaryAction?: BirhausResourceCardAction$1; menuActions?: BirhausResourceCardAction$1[]; onCardClick?: () => void; variant?: 'default' | 'elevated' | 'interactive' | 'compact'; layout?: 'vertical' | 'horizontal'; showAvatar?: boolean; maxPrimaryInfo?: number; maxSecondaryInfo?: number; maxMenuActions?: number; showCognitiveWarning?: boolean; cognitiveMode?: 'strict' | 'warning' | 'disabled'; className?: string; 'aria-label'?: string; 'aria-describedby'?: string; role?: string; data?: any; } declare function BirhausResourceCard({ id, titleEs, titleEn, subtitleEs, subtitleEn, descriptionEs, descriptionEn, avatar, status, badges, primaryInfo, secondaryInfo, primaryAction, menuActions, onCardClick, variant, layout, showAvatar, maxPrimaryInfo, maxSecondaryInfo, maxMenuActions, showCognitiveWarning, cognitiveMode, className, 'aria-label': ariaLabel, 'aria-describedby': ariaDescribedBy, role, data, ...props }: BirhausResourceCardProps$1): react_jsx_runtime.JSX.Element; declare const BirhausResourceCardTemplates: { readonly Student: (props: Partial) => { id?: string | undefined; titleEs?: string | undefined; titleEn?: string | undefined; subtitleEs?: string | undefined; subtitleEn?: string | undefined; descriptionEs?: string | undefined; descriptionEn?: string | undefined; avatar?: BirhausResourceCardAvatar$1 | undefined; status?: BirhausResourceCardStatus$1 | undefined; badges?: BirhausResourceCardBadge$1[] | undefined; primaryInfo?: BirhausResourceCardInfo$1[] | undefined; secondaryInfo?: BirhausResourceCardInfo$1[] | undefined; primaryAction?: BirhausResourceCardAction$1 | undefined; menuActions: BirhausResourceCardAction$1[]; onCardClick?: (() => void) | undefined; variant: "default" | "elevated" | "interactive" | "compact"; layout: "vertical" | "horizontal"; showAvatar: boolean; maxPrimaryInfo: number; maxSecondaryInfo: number; maxMenuActions: number; showCognitiveWarning?: boolean | undefined; cognitiveMode: "strict" | "warning" | "disabled"; className?: string | undefined; 'aria-label'?: string | undefined; 'aria-describedby'?: string | undefined; role?: string | undefined; data?: any; }; readonly Employee: (props: Partial) => { id?: string | undefined; titleEs?: string | undefined; titleEn?: string | undefined; subtitleEs?: string | undefined; subtitleEn?: string | undefined; descriptionEs?: string | undefined; descriptionEn?: string | undefined; avatar?: BirhausResourceCardAvatar$1 | undefined; status?: BirhausResourceCardStatus$1 | undefined; badges?: BirhausResourceCardBadge$1[] | undefined; primaryInfo?: BirhausResourceCardInfo$1[] | undefined; secondaryInfo?: BirhausResourceCardInfo$1[] | undefined; primaryAction?: BirhausResourceCardAction$1 | undefined; menuActions: BirhausResourceCardAction$1[]; onCardClick?: (() => void) | undefined; variant: "default" | "elevated" | "interactive" | "compact"; layout: "vertical" | "horizontal"; showAvatar: boolean; maxPrimaryInfo: number; maxSecondaryInfo: number; maxMenuActions: number; showCognitiveWarning?: boolean | undefined; cognitiveMode: "strict" | "warning" | "disabled"; className?: string | undefined; 'aria-label'?: string | undefined; 'aria-describedby'?: string | undefined; role?: string | undefined; data?: any; }; readonly Course: (props: Partial) => { id?: string | undefined; titleEs?: string | undefined; titleEn?: string | undefined; subtitleEs?: string | undefined; subtitleEn?: string | undefined; descriptionEs?: string | undefined; descriptionEn?: string | undefined; avatar?: BirhausResourceCardAvatar$1 | undefined; status?: BirhausResourceCardStatus$1 | undefined; badges?: BirhausResourceCardBadge$1[] | undefined; primaryInfo?: BirhausResourceCardInfo$1[] | undefined; secondaryInfo?: BirhausResourceCardInfo$1[] | undefined; primaryAction: BirhausResourceCardAction$1; menuActions?: BirhausResourceCardAction$1[] | undefined; onCardClick?: (() => void) | undefined; variant: "default" | "elevated" | "interactive" | "compact"; layout: "vertical" | "horizontal"; showAvatar: boolean; maxPrimaryInfo: number; maxSecondaryInfo: number; maxMenuActions: number; showCognitiveWarning?: boolean | undefined; cognitiveMode: "strict" | "warning" | "disabled"; className?: string | undefined; 'aria-label'?: string | undefined; 'aria-describedby'?: string | undefined; role?: string | undefined; data?: any; }; readonly Contract: (props: Partial) => { id?: string | undefined; titleEs?: string | undefined; titleEn?: string | undefined; subtitleEs?: string | undefined; subtitleEn?: string | undefined; descriptionEs?: string | undefined; descriptionEn?: string | undefined; avatar?: BirhausResourceCardAvatar$1 | undefined; status?: BirhausResourceCardStatus$1 | undefined; badges?: BirhausResourceCardBadge$1[] | undefined; primaryInfo?: BirhausResourceCardInfo$1[] | undefined; secondaryInfo?: BirhausResourceCardInfo$1[] | undefined; primaryAction?: BirhausResourceCardAction$1 | undefined; menuActions: BirhausResourceCardAction$1[]; onCardClick?: (() => void) | undefined; variant: "default" | "elevated" | "interactive" | "compact"; layout: "vertical" | "horizontal"; showAvatar: boolean; maxPrimaryInfo: number; maxSecondaryInfo: number; maxMenuActions: number; showCognitiveWarning?: boolean | undefined; cognitiveMode: "strict" | "warning" | "disabled"; className?: string | undefined; 'aria-label'?: string | undefined; 'aria-describedby'?: string | undefined; role?: string | undefined; data?: any; }; }; /** * BIRHAUS BulkActionBar Types * Following BIRHAUS principles with Spanish-first internationalization */ type BulkActionState = 'idle' | 'executing' | 'completed' | 'error'; type BulkActionVariant = 'primary' | 'secondary' | 'outline' | 'ghost' | 'destructive'; interface BirhausBulkAction { /** Unique identifier for the action */ id: string; /** Spanish label (required - Spanish-first principle) */ labelEs: string; /** English label (optional fallback) */ labelEn?: string; /** Icon component */ icon?: React.ComponentType<{ className?: string; }>; /** Action handler function */ onClick: (selectedItems: T[]) => void | Promise<{ undoAction?: () => void | Promise; }>; /** Button variant */ variant?: BulkActionVariant; /** Whether the action is disabled */ disabled?: boolean; /** Whether this action supports undo (BIRHAUS undo-over-confirm) */ undoable?: boolean; /** How long the undo option stays available (ms) */ undoTimeout?: number; /** Whether to clear selection after successful completion */ clearSelectionOnComplete?: boolean; /** Minimum number of items required for this action */ minItems?: number; /** Maximum number of items allowed for this action */ maxItems?: number; /** Custom validation function */ validate?: (items: T[]) => { valid: boolean; message?: string; }; } interface UndoAction { /** Unique identifier */ id: string; /** Spanish label for undo action */ labelEs: string; /** English label for undo action */ labelEn?: string; /** The undo function */ action: () => void | Promise; /** How long this undo option is available */ timeout: number; } interface ProgressInfo { /** Current progress count */ current: number; /** Total items to process */ total: number; /** Optional message describing current operation */ message?: string; /** Whether the operation can be cancelled */ cancellable?: boolean; } interface ActionValidationResult { /** Whether the action is valid */ valid: boolean; /** Optional message explaining why invalid */ message?: string; /** Additional metadata */ metadata?: Record; } interface BirhausBulkActionBarProps { /** Number of currently selected items */ selectedCount: number; /** Total number of items available for selection */ totalCount?: number; /** Array of selected items */ selectedItems?: T[]; /** Whether all items are selected */ isAllSelected?: boolean; /** Array of available bulk actions (max 4 for Miller's Law compliance) */ actions?: BirhausBulkAction[]; /** Handler for selecting all items */ onSelectAll?: () => void; /** Handler for clearing selection */ onClearSelection?: () => void; /** Position of the action bar */ position?: 'top' | 'bottom'; /** Whether the bar should stick to the viewport */ sticky?: boolean; /** Whether to show progress indicator */ showProgress?: boolean; /** Progress information */ progressInfo?: ProgressInfo; /** Handler for cancelling ongoing operation */ onCancelOperation?: () => void; /** Array of available undo actions */ undoActions?: UndoAction[]; /** Handler for executing undo actions */ onUndo?: (undoAction: UndoAction) => void | Promise; /** Current locale (Spanish-first) */ locale?: 'es' | 'en'; /** Additional CSS classes */ className?: string; /** Disable entrance/exit animations */ disableAnimation?: boolean; /** ARIA label for the bulk action bar */ ariaLabel?: string; /** ARIA live region politeness level */ ariaLiveRegion?: 'polite' | 'assertive' | 'off'; /** Custom content to render alongside actions */ customContent?: ReactNode; /** Custom validation function for actions */ onValidateAction?: (action: BirhausBulkAction, items: T[]) => Promise; /** Called when an action starts executing */ onActionStart?: (action: BirhausBulkAction, items: T[]) => void; /** Called when an action completes successfully */ onActionComplete?: (action: BirhausBulkAction, items: T[], result?: any) => void; /** Called when an action encounters an error */ onActionError?: (action: BirhausBulkAction, items: T[], error: Error) => void; } interface UseBulkSelectionOptions { /** Maximum number of items that can be selected (Miller's Law compliance) */ maxSelection?: number; /** Whether selection should persist across data changes */ persistSelection?: boolean; /** Custom key field for item identification */ keyField?: string; } interface UseBulkSelectionReturn { /** Currently selected items */ selectedItems: T[]; /** Number of selected items */ selectedCount: number; /** Select a single item */ selectItem: (item: T) => void; /** Deselect a single item */ deselectItem: (itemId: string | number) => void; /** Select all provided items */ selectAll: (items: T[]) => void; /** Clear all selections */ clearSelection: () => void; /** Check if an item is selected */ isSelected: (itemId: string | number) => boolean; /** Toggle selection of an item */ toggleSelection: (item: T) => void; /** Check if all items are selected */ isAllSelected: (totalItems: T[]) => boolean; /** Get selection statistics */ getSelectionStats: () => { selected: number; total: number; percentage: number; isMaxReached: boolean; }; /** Bulk operations */ selectRange: (startIndex: number, endIndex: number, items: T[]) => void; selectByFilter: (predicate: (item: T) => boolean, items: T[]) => void; /** Undo/redo support */ undo: () => void; redo: () => void; canUndo: boolean; canRedo: boolean; } interface BulkActionBarMetrics { /** Number of actions (should be <= 4 for Miller's Law) */ actionsCount: number; /** Cognitive complexity level */ cognitiveLoad: 'low' | 'medium' | 'high'; /** Whether 4-3-1 rule is violated */ violates431Rule: boolean; /** Spanish language coverage percentage */ spanishCoverage: number; /** Whether undo patterns are implemented */ hasUndoPatterns: boolean; /** Accessibility score (0-100) */ accessibilityScore: number; } interface BulkActionConfigFactory { createAction: (config: Omit, 'id'> & { id: string; }) => BirhausBulkAction; createPresetAction: (preset: string, config: any) => BirhausBulkAction; validateCognitiveLoad: (actions: BirhausBulkAction[]) => BulkActionBarMetrics; validateBirhausCompliance: (actions: BirhausBulkAction[]) => { millersLaw: boolean; spanishFirst: boolean; undoPatterns: boolean; accessibility: boolean; cognitiveLoad: BulkActionBarMetrics['cognitiveLoad']; }; } interface DataTableBulkActionConfig { /** Whether bulk actions are enabled */ enabled: boolean; /** Position of the bulk action bar relative to table */ position: 'top' | 'bottom' | 'both'; /** Actions available when items are selected */ actions: BirhausBulkAction[]; /** Whether to show progress during bulk operations */ showProgress: boolean; /** Custom validation for bulk actions */ validateSelection?: (items: T[]) => ActionValidationResult; } /** * BirhausBulkActionBar - Advanced bulk action component with BIRHAUS principles * * Features: * - Spanish-first labels with English fallbacks * - Miller's Law compliance (max 4 bulk actions per bar) * - 4-3-1 cognitive rule (4 nav items max, 3 contextual, 1 primary) * - Undo-over-confirm patterns (no confirmation dialogs) * - Progress tracking for batch operations * - Accessibility-first design (WCAG AA+) */ declare function BirhausBulkActionBar({ selectedCount, totalCount, selectedItems, isAllSelected, actions, onSelectAll, onClearSelection, position, sticky, showProgress, progressInfo, onCancelOperation, undoActions, onUndo, locale, className, disableAnimation, ariaLabel, ariaLiveRegion, customContent, onValidateAction, onActionStart, onActionComplete, onActionError }: BirhausBulkActionBarProps): react_jsx_runtime.JSX.Element | null; /** * useBulkSelection - Hook for managing bulk selection with BIRHAUS principles * * Features: * - Miller's Law compliance (max selection limits) * - Undo/redo support for selection operations * - Range selection for efficiency * - Filter-based selection * - Persistent selection across data changes */ declare function useBulkSelection>(options?: UseBulkSelectionOptions): UseBulkSelectionReturn; /** * useBulkOperations - Hook for managing bulk operations with progress tracking */ declare function useBulkOperations(): { isExecuting: boolean; progress: { current: number; total: number; }; error: Error | null; cancelled: boolean; executeWithProgress: (items: T[], operation: (item: T, index: number) => Promise, options?: { batchSize?: number; onProgress?: (current: number, total: number) => void; onError?: (error: Error, item: T, index: number) => void; }) => Promise; cancel: () => void; reset: () => void; }; /** * useBulkActionValidation - Hook for validating bulk actions according to BIRHAUS principles */ declare function useBulkActionValidation(): { validateMillersLaw: (actionsCount: number) => boolean; validateSpanishFirst: (actions: Array<{ labelEs?: string; labelEn?: string; }>) => boolean; validateSelectionSize: (selectedCount: number, maxRecommended?: number) => { valid: boolean; message: string; } | { valid: boolean; message?: undefined; }; }; /** * BIRHAUS Bulk Action Presets * Pre-configured actions following BIRHAUS principles * - Spanish-first labels * - Undo-over-confirm patterns * - Miller's Law compliance * - Accessibility-first design */ /** * Export action with format options */ declare const createExportAction: (onExport: (items: T[], format?: string) => Promise, options?: { formats?: ("csv" | "xlsx" | "json" | "pdf")[]; defaultFormat?: string; }) => BirhausBulkAction; /** * Delete action with undo support (BIRHAUS undo-over-confirm) */ declare const createDeleteAction: (onDelete: (items: T[]) => Promise<{ undoAction: () => Promise; }>, count?: number) => BirhausBulkAction; /** * Archive action with undo support */ declare const createArchiveAction: (onArchive: (items: T[]) => Promise<{ undoAction?: () => Promise; }>, options?: { undoable?: boolean; }) => BirhausBulkAction; /** * Email/notification action */ declare const createEmailAction: (onEmail: (items: T[]) => Promise, options?: { label?: { es: string; en?: string; }; template?: string; }) => BirhausBulkAction; /** * Tag/label action */ declare const createTagAction: (onTag: (items: T[], tag?: string) => Promise, tag?: string) => BirhausBulkAction; /** * Approve action */ declare const createApproveAction: (onApprove: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; /** * Reject action */ declare const createRejectAction: (onReject: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; /** * Status update action */ declare const createStatusUpdateAction: (onUpdateStatus: (items: T[], status: string) => Promise<{ undoAction?: () => Promise; }>, status: string, statusLabel?: { es: string; en?: string; }) => BirhausBulkAction; /** * Download action */ declare const createDownloadAction: (onDownload: (items: T[]) => Promise) => BirhausBulkAction; /** * Copy action */ declare const createCopyAction: (onCopy: (items: T[]) => Promise) => BirhausBulkAction; /** * Edit action */ declare const createEditAction: (onEdit: (items: T[]) => Promise, options?: { singleOnly?: boolean; maxItems?: number; }) => BirhausBulkAction; /** * Assign action (for user/group assignments) */ declare const createAssignAction: (onAssign: (items: T[], assignee?: string) => Promise, assignee?: string) => BirhausBulkAction; /** * Favorite/star action */ declare const createFavoriteAction: (onFavorite: (items: T[], favorite: boolean) => void | Promise, isFavorite?: boolean) => BirhausBulkAction; /** * Hide/show visibility action */ declare const createVisibilityAction: (onToggleVisibility: (items: T[], visible: boolean) => void | Promise, makeVisible?: boolean) => BirhausBulkAction; /** * Priority action */ declare const createPriorityAction: (onSetPriority: (items: T[], priority: "high" | "medium" | "low") => void | Promise, priority: "high" | "medium" | "low") => BirhausBulkAction; /** * Permission action (for access control) */ declare const createPermissionAction: (onUpdatePermissions: (items: T[], permission: string, grant: boolean) => void | Promise, permission: string, grant?: boolean) => BirhausBulkAction; /** * Collection of all presets implementing BulkActionPresets interface */ declare const BulkActionPresets: { export: (onExport: (items: T[], format?: string) => Promise, options?: { formats?: ("csv" | "xlsx" | "json" | "pdf")[]; defaultFormat?: string; }) => BirhausBulkAction; delete: (onDelete: (items: T[]) => Promise<{ undoAction: () => Promise; }>, count?: number) => BirhausBulkAction; archive: (onArchive: (items: T[]) => Promise<{ undoAction?: () => Promise; }>, options?: { undoable?: boolean; }) => BirhausBulkAction; email: (onEmail: (items: T[]) => Promise, options?: { label?: { es: string; en?: string; }; template?: string; }) => BirhausBulkAction; tag: (onTag: (items: T[], tag?: string) => Promise, tag?: string) => BirhausBulkAction; approve: (onApprove: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; reject: (onReject: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; updateStatus: (onUpdateStatus: (items: T[], status: string) => Promise<{ undoAction?: () => Promise; }>, status: string, statusLabel?: { es: string; en?: string; }) => BirhausBulkAction; }; /** * Extended presets for additional functionality */ declare const ExtendedBulkActionPresets: { download: (onDownload: (items: T[]) => Promise) => BirhausBulkAction; copy: (onCopy: (items: T[]) => Promise) => BirhausBulkAction; edit: (onEdit: (items: T[]) => Promise, options?: { singleOnly?: boolean; maxItems?: number; }) => BirhausBulkAction; assign: (onAssign: (items: T[], assignee?: string) => Promise, assignee?: string) => BirhausBulkAction; favorite: (onFavorite: (items: T[], favorite: boolean) => void | Promise, isFavorite?: boolean) => BirhausBulkAction; visibility: (onToggleVisibility: (items: T[], visible: boolean) => void | Promise, makeVisible?: boolean) => BirhausBulkAction; priority: (onSetPriority: (items: T[], priority: "high" | "medium" | "low") => void | Promise, priority: "high" | "medium" | "low") => BirhausBulkAction; permission: (onUpdatePermissions: (items: T[], permission: string, grant: boolean) => void | Promise, permission: string, grant?: boolean) => BirhausBulkAction; export: (onExport: (items: T[], format?: string) => Promise, options?: { formats?: ("csv" | "xlsx" | "json" | "pdf")[]; defaultFormat?: string; }) => BirhausBulkAction; delete: (onDelete: (items: T[]) => Promise<{ undoAction: () => Promise; }>, count?: number) => BirhausBulkAction; archive: (onArchive: (items: T[]) => Promise<{ undoAction?: () => Promise; }>, options?: { undoable?: boolean; }) => BirhausBulkAction; email: (onEmail: (items: T[]) => Promise, options?: { label?: { es: string; en?: string; }; template?: string; }) => BirhausBulkAction; tag: (onTag: (items: T[], tag?: string) => Promise, tag?: string) => BirhausBulkAction; approve: (onApprove: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; reject: (onReject: (items: T[]) => Promise<{ undoAction?: () => Promise; }>) => BirhausBulkAction; updateStatus: (onUpdateStatus: (items: T[], status: string) => Promise<{ undoAction?: () => Promise; }>, status: string, statusLabel?: { es: string; en?: string; }) => BirhausBulkAction; }; /** * Factory function for creating custom bulk action configurations */ declare function createBulkActionConfig(): { createAction: (config: Omit, "id"> & { id: string; }) => BirhausBulkAction; createPresetAction: (preset: keyof typeof ExtendedBulkActionPresets, ...args: any[]) => BirhausBulkAction; validateCognitiveLoad: (actions: BirhausBulkAction[]) => { actionsCount: number; cognitiveLoad: "low" | "medium" | "high"; violates431Rule: boolean; spanishCoverage: number; hasUndoPatterns: boolean; accessibilityScore: number; }; validateBirhausCompliance: (actions: BirhausBulkAction[]) => { millersLaw: boolean; spanishFirst: boolean; undoPatterns: boolean; accessibility: boolean; cognitiveLoad: "low" | "medium" | "high"; }; }; /** * BIRHAUS Status Badge Types * Comprehensive type definitions for all status contexts */ type StudentStatus = 'active' | 'inactive' | 'graduated' | 'suspended' | 'pending'; type PaymentStatus = 'paid' | 'pending' | 'overdue' | 'partial' | 'refunded'; type CourseStatus = 'active' | 'completed' | 'upcoming' | 'cancelled' | 'draft'; type ContractStatus = 'active' | 'expired' | 'cancelled' | 'pending' | 'suspended'; type AttendanceStatus = 'present' | 'absent' | 'late' | 'excused' | 'holiday'; type GenericStatus = 'success' | 'error' | 'warning' | 'info' | 'default'; type StatusType = StudentStatus | PaymentStatus | CourseStatus | ContractStatus | AttendanceStatus | GenericStatus; type StatusCategory = 'student' | 'payment' | 'course' | 'contract' | 'attendance' | 'generic'; interface BirhausStatusBadgeProps { status: StatusType; labelEs?: string; labelEn?: string; size?: 'xs' | 'sm' | 'md' | 'lg'; variant?: 'solid' | 'soft' | 'outline' | 'ghost'; showIcon?: boolean; onClick?: () => void; className?: string; locale?: 'es' | 'en'; } interface UseBirhausStatusBadgeReturn { status: StatusType; setStatus: (status: StatusType) => void; previousStatus: StatusType | null; canUndo: boolean; undoStatusChange: () => void; } declare function BirhausStatusBadge({ status, labelEs, labelEn, size, variant, showIcon, className, onClick, locale }: BirhausStatusBadgeProps): react_jsx_runtime.JSX.Element; declare function BirhausStudentStatusBadge({ status, ...props }: Omit & { status: Extract; }): react_jsx_runtime.JSX.Element; declare function BirhausPaymentStatusBadge({ status, amount, currency, ...props }: Omit & { status: Extract; amount?: number; currency?: string; }): react_jsx_runtime.JSX.Element; declare function BirhausCourseStatusBadge({ status, ...props }: Omit & { status: Extract; }): react_jsx_runtime.JSX.Element; declare function BirhausContractStatusBadge({ status, ...props }: Omit & { status: Extract; }): react_jsx_runtime.JSX.Element; declare function BirhausAttendanceStatusBadge({ status, ...props }: Omit & { status: Extract; }): react_jsx_runtime.JSX.Element; declare function BirhausStatusGroup({ children, className, orientation, spacing }: { children: react__default.ReactNode; className?: string; orientation?: 'horizontal' | 'vertical'; spacing?: 'tight' | 'normal' | 'loose'; }): react_jsx_runtime.JSX.Element; declare function getBirhausStatusColor(status: StatusType): { bg: string; text: string; border: string; }; declare function getBirhausStatusIcon(status: StatusType): react__default.ComponentType<{ className?: string; }>; declare function getBirhausStatusLabel(status: StatusType, locale?: 'es' | 'en'): string; declare function getStatusCategory(status: StatusType): StatusCategory; declare function useBirhausStatusBadge(initialStatus?: StatusType): { status: StatusType; setStatus: (newStatus: StatusType) => void; previousStatus: StatusType | null; canUndo: boolean; undoStatusChange: () => void; }; /** * BIRHAUS Stat Card Types * Following BIRHAUS principles with Spanish-first internationalization */ type StatTrend = 'up' | 'down' | 'neutral'; type StatColor = 'blue' | 'green' | 'purple' | 'indigo' | 'amber' | 'red' | 'gray' | 'teal'; type StatVariant = 'default' | 'elevated' | 'outlined' | 'minimal'; type StatSize = 'compact' | 'default' | 'large'; interface BirhausStatCardProps { tituloEs: string; tituloEn?: string; subtituloEs?: string; subtituloEn?: string; value: string | number; trend?: StatTrend; trendValue?: string; trendLabelEs?: string; trendLabelEn?: string; icon?: LucideIcon; color?: StatColor; variant?: StatVariant; size?: StatSize; loading?: boolean; onClick?: () => void; className?: string; locale?: 'es' | 'en'; 'aria-label'?: string; 'aria-describedby'?: string; } interface StatMetrics { value: number; formatted: string; trend: StatTrend | null; trendPercentage: number | null; targetProgress: number | null; } interface UseBirhausStatCardReturn { value: number; setValue: (newValue: number) => void; previousValue: number | undefined; loading: boolean; setLoading: (loading: boolean) => void; lastUpdated: Date; refresh: () => void; metrics: StatMetrics; } declare function BirhausStatCard({ tituloEs, tituloEn, subtituloEs, subtituloEn, value, trend, trendValue, trendLabelEs, trendLabelEn, icon: Icon, color, variant, size, onClick, loading, className, locale, 'aria-label': ariaLabel, 'aria-describedby': ariaDescribedBy }: BirhausStatCardProps): react_jsx_runtime.JSX.Element; declare function createStatMetrics(value: number, previousValue?: number, target?: number): StatMetrics; declare const birhausStatCardPresets: { readonly revenue: { readonly color: StatColor; readonly tituloEs: "Ingresos"; readonly tituloEn: "Revenue"; }; readonly expenses: { readonly color: StatColor; readonly tituloEs: "Gastos"; readonly tituloEn: "Expenses"; }; readonly profit: { readonly color: StatColor; readonly tituloEs: "Ganancia"; readonly tituloEn: "Profit"; }; readonly totalStudents: { readonly color: StatColor; readonly tituloEs: "Total de Estudiantes"; readonly tituloEn: "Total Students"; }; readonly activeStudents: { readonly color: StatColor; readonly tituloEs: "Estudiantes Activos"; readonly tituloEn: "Active Students"; }; readonly newEnrollments: { readonly color: StatColor; readonly tituloEs: "Nuevas Inscripciones"; readonly tituloEn: "New Enrollments"; }; readonly totalCourses: { readonly color: StatColor; readonly tituloEs: "Total de Cursos"; readonly tituloEn: "Total Courses"; }; readonly activeCourses: { readonly color: StatColor; readonly tituloEs: "Cursos Activos"; readonly tituloEn: "Active Courses"; }; readonly attendance: { readonly color: StatColor; readonly tituloEs: "Asistencia"; readonly tituloEn: "Attendance"; }; readonly completion: { readonly color: StatColor; readonly tituloEs: "Finalización"; readonly tituloEn: "Completion"; }; }; declare function useBirhausStatCard(initialValue?: number, refreshInterval?: number): { value: number; setValue: (newValue: number) => void; previousValue: number | undefined; loading: boolean; setLoading: react__default.Dispatch>; lastUpdated: Date; refresh: () => void; metrics: StatMetrics; }; /** * BIRHAUS Quick Filter Component * * Toggle-able filter chip implementing BIRHAUS principles: * - Spanish-first labels with English fallbacks * - Clear active/inactive visual states * - Accessibility compliance (WCAG AA+) * - Count badges for cognitive load transparency * - Consistent with BIRHAUS color scheme * - Performance optimized with minimal re-renders */ interface BirhausQuickFilterProps { label?: string; labelEs?: string; labelEn?: string; icon?: string | LucideIcon; count?: number; active?: boolean; disabled?: boolean; loading?: boolean; onClick?: () => void | Promise; ariaLabel?: string; ariaLabelEs?: string; ariaLabelEn?: string; locale?: 'es' | 'en'; variant?: 'default' | 'primary' | 'secondary'; size?: 'sm' | 'md' | 'lg'; className?: string; } declare const BirhausQuickFilter: react.ForwardRefExoticComponent>; declare function useBirhausQuickFilter(initialFilters?: Array<{ key: string; labelEs: string; labelEn?: string; active?: boolean; }>): { filters: { key: string; labelEs: string; labelEn?: string; active?: boolean; }[]; setFilters: react.Dispatch>; toggleFilter: (key: string) => void; setFilterActive: (key: string, active: boolean) => void; clearAllFilters: () => void; activeFilters: { key: string; labelEs: string; labelEn?: string; active?: boolean; }[]; hasActiveFilters: boolean; activeCount: number; }; declare const birhausQuickFilterPresets: { studentStatus: { key: string; labelEs: string; labelEn: string; icon: string; }[]; paymentStatus: { key: string; labelEs: string; labelEn: string; icon: string; }[]; courseStatus: { key: string; labelEs: string; labelEn: string; icon: string; }[]; timePeriod: { key: string; labelEs: string; labelEn: string; icon: string; }[]; }; /** * BIRHAUS Filter Bar Component * * Comprehensive filtering interface implementing BIRHAUS principles: * - Progressive disclosure (search -> quick filters -> advanced filters) * - Spanish-first labels and messages * - Miller's Law compliance (max 7±2 quick filters) * - 4-3-1 cognitive rule for filter organization * - Clear visual feedback for active filters * - Accessibility compliance (WCAG AA+) * - Undo-over-confirm patterns */ interface FilterConfig { id: string; labelEs: string; labelEn?: string; type: 'select' | 'multiselect' | 'date' | 'daterange' | 'number' | 'text'; options?: Array<{ value: string; labelEs: string; labelEn?: string; }>; value?: any; onChange: (value: any) => void; placeholder?: string; placeholderEs?: string; placeholderEn?: string; } interface BirhausQuickFilterConfig extends Omit { key: string; onClick?: () => void | Promise; } interface BirhausFilterBarProps { search?: { value: string; onChange: (value: string) => void; placeholder?: string; placeholderEs?: string; placeholderEn?: string; debounceMs?: number; }; quickFilters?: BirhausQuickFilterConfig[]; advancedFilters?: FilterConfig[]; showAdvancedFilters?: boolean; onToggleAdvancedFilters?: (show: boolean) => void; customFilters?: ReactNode; results?: { count: number; labelEs?: string; labelEn?: string; totalCount?: number; }; onClearAll?: () => void | Promise; onExport?: () => void | Promise; clearAllLabelEs?: string; clearAllLabelEn?: string; advancedFiltersLabelEs?: string; advancedFiltersLabelEn?: string; quickFiltersLabelEs?: string; quickFiltersLabelEn?: string; showingLabelEs?: string; showingLabelEn?: string; loading?: boolean; locale?: 'es' | 'en'; variant?: 'default' | 'minimal' | 'card'; className?: string; children?: ReactNode; } declare const BirhausFilterBar: react.ForwardRefExoticComponent>; declare function useBirhausFilterBar(initialFilters?: Record): { filters: Record; searchTerm: string; showAdvanced: boolean; setFilters: react.Dispatch>>; setSearchTerm: react.Dispatch>; setShowAdvanced: react.Dispatch>; updateFilter: (key: string, value: any) => void; clearFilter: (key: string) => void; clearAllFilters: () => void; activeFilters: [string, any][]; hasActiveFilters: boolean; activeFiltersCount: number; }; declare const birhausFilterBarPresets: { studentManagement: { quickFilters: { key: string; labelEs: string; labelEn: string; icon: string; }[]; advancedFilters: ({ id: string; labelEs: string; labelEn: string; type: "select"; options: never[]; } | { id: string; labelEs: string; labelEn: string; type: "daterange"; options?: undefined; })[]; }; financialManagement: { quickFilters: { key: string; labelEs: string; labelEn: string; icon: string; }[]; advancedFilters: ({ id: string; labelEs: string; labelEn: string; type: "number"; options?: undefined; } | { id: string; labelEs: string; labelEn: string; type: "select"; options: never[]; })[]; }; }; /** * BIRHAUS Container Component * * Responsive container implementing BIRHAUS principles: * - Consistent spacing and max-width constraints * - 8-point grid system alignment * - BIRHAUS performance guidelines (optimal content width) * - Accessibility compliance with semantic structure * - Responsive design with mobile-first approach */ interface BirhausContainerProps { children: ReactNode; size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full'; padding?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl'; centered?: boolean; as?: 'div' | 'section' | 'article' | 'main' | 'aside' | 'header' | 'footer'; className?: string; } declare const BirhausContainer: react.ForwardRefExoticComponent>; declare function useBirhausContainer(): { sizes: { xs: string; sm: string; md: string; lg: string; xl: string; '2xl': string; full: string; }; optimalReadingWidth: string; breakpoints: { mobile: string; tablet: string; desktop: string; wide: string; }; }; declare const birhausContainerPresets: { page: { size: "xl"; padding: "lg"; centered: boolean; }; content: { size: "lg"; padding: "md"; centered: boolean; }; sidebar: { size: "sm"; padding: "sm"; centered: boolean; }; fullWidth: { size: "full"; padding: "lg"; centered: boolean; }; modal: { size: "md"; padding: "md"; centered: boolean; }; mobile: { size: "sm"; padding: "sm"; centered: boolean; }; }; /** * BIRHAUS Page Header Component * * Premium page header implementing BIRHAUS principles: * - Spanish-first titles and descriptions * - 4-3-1 cognitive rule for actions (max 4 primary, 3 secondary, 1 main) * - Accessibility compliance with semantic markup * - Elegant gradient design with glassmorphism * - Breadcrumb navigation with Spanish labels * - Progressive disclosure for complex headers */ interface BreadcrumbItem { labelEs: string; labelEn?: string; href?: string; icon?: LucideIcon; current?: boolean; } interface BirhausPageHeaderAction { labelEs: string; labelEn?: string; icon?: LucideIcon; onClick: () => void | Promise; variant?: 'primary' | 'secondary' | 'ghost'; disabled?: boolean; loading?: boolean; } interface BirhausPageHeaderProps { title?: string; titleEs?: string; titleEn?: string; description?: string; descriptionEs?: string; descriptionEn?: string; icon?: LucideIcon; breadcrumbs?: BreadcrumbItem[]; actions?: BirhausPageHeaderAction[]; variant?: 'default' | 'minimal' | 'hero' | 'compact'; level?: 1 | 2 | 3 | 4 | 5 | 6; locale?: 'es' | 'en'; className?: string; gradient?: 'blue' | 'indigo' | 'purple' | 'gray' | 'emerald'; children?: ReactNode; } declare const BirhausPageHeader: react.ForwardRefExoticComponent>; declare function useBirhausPageHeader(): { createBreadcrumb: (labelEs: string, labelEn?: string, href?: string, options?: Partial) => BreadcrumbItem; createAction: (labelEs: string, onClick: () => void, options?: Partial) => BirhausPageHeaderAction; homeBreadcrumb: { labelEs: string; labelEn: string; href: string; icon: LucideIcon; }; }; declare const birhausPageHeaderPresets: { dashboard: { variant: "hero"; gradient: "blue"; titleEs: string; titleEn: string; }; listPage: { variant: "default"; gradient: "indigo"; }; detailPage: { variant: "compact"; gradient: "gray"; }; settings: { variant: "minimal"; titleEs: string; titleEn: string; }; reports: { variant: "default"; gradient: "emerald"; titleEs: string; titleEn: string; }; }; /** * BIRHAUS Page Layout Component * * Complete page layout system implementing BIRHAUS principles: * - Progressive disclosure (header -> content -> sidebar) * - Spanish-first navigation and labels * - Miller's Law compliance for navigation sections * - Accessibility-first semantic structure * - Responsive design with mobile-first approach * - Cognitive load optimization through layout patterns * - Performance-optimized with sticky positioning */ interface BirhausPageLayoutProps { children: ReactNode; header?: Omit; breadcrumbs?: ReactNode; tabs?: ReactNode; sidebar?: ReactNode; sidebarPosition?: 'left' | 'right'; sidebarWidth?: 'sm' | 'md' | 'lg'; sidebarSticky?: boolean; containerSize?: BirhausContainerProps['size']; containerPadding?: BirhausContainerProps['padding']; variant?: 'default' | 'fullwidth' | 'centered' | 'dashboard'; background?: 'default' | 'gray' | 'white' | 'gradient'; loading?: boolean; loadingMessage?: string; loadingMessageEs?: string; loadingMessageEn?: string; skipToContentLabel?: string; skipToContentLabelEs?: string; skipToContentLabelEn?: string; locale?: 'es' | 'en'; className?: string; headerClassName?: string; contentClassName?: string; sidebarClassName?: string; collapsibleSidebar?: boolean; onSidebarToggle?: (collapsed: boolean) => void; } declare const BirhausPageLayout: react.ForwardRefExoticComponent>; declare function useBirhausPageLayout(): { sidebarVisible: boolean; setSidebarVisible: react.Dispatch>; toggleSidebar: () => void; hideSidebar: () => void; showSidebar: () => void; currentTab: string | null; setCurrentTab: react.Dispatch>; getResponsiveContainer: (isMobile: boolean) => "sm" | "xl"; getResponsivePadding: (isMobile: boolean) => "sm" | "lg"; }; declare const birhausPageLayoutPresets: { dashboard: { variant: "dashboard"; background: "default"; containerSize: "xl"; header: { variant: "hero"; gradient: "blue"; titleEs: string; titleEn: string; }; }; listView: { variant: "default"; background: "default"; containerSize: "xl"; header: { variant: "default"; gradient: "indigo"; }; sidebarPosition: "left"; sidebarWidth: "sm"; }; detailView: { variant: "default"; background: "white"; containerSize: "lg"; header: { variant: "compact"; gradient: "gray"; }; }; settings: { variant: "default"; background: "gray"; containerSize: "lg"; header: { variant: "minimal"; titleEs: string; titleEn: string; }; sidebarPosition: "left"; sidebarWidth: "sm"; }; analytics: { variant: "dashboard"; background: "gradient"; containerSize: "xl"; header: { variant: "hero"; gradient: "emerald"; titleEs: string; titleEn: string; }; }; modal: { variant: "centered"; background: "white"; containerSize: "md"; containerPadding: "md"; header: { variant: "minimal"; }; }; }; interface BirhausResourceCardAvatar { src?: string; initials?: string; icon?: LucideIcon; fallbackColor?: 'default' | 'blue' | 'green' | 'purple' | 'orange' | 'pink'; } interface BirhausResourceCardStatus { labelEs: string; labelEn: string; variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; } interface BirhausResourceCardBadge { labelEs: string; labelEn: string; variant?: 'default' | 'success' | 'warning' | 'error' | 'info'; priority?: number; } interface BirhausResourceCardInfo { labelEs: string; labelEn: string; value: string | number; icon?: LucideIcon; highlight?: boolean; format?: 'text' | 'number' | 'currency' | 'date' | 'phone' | 'email' | 'percentage'; tooltip?: string; sensitive?: boolean; } interface BirhausResourceCardAction { keyEs: string; keyEn: string; labelEs: string; labelEn: string; onClick: () => void; icon?: LucideIcon; variant?: 'primary' | 'secondary' | 'ghost' | 'danger'; condition?: (data: any) => boolean; divider?: boolean; disabled?: boolean; loading?: boolean; } interface BirhausResourceCardProps { id: string; titleEs: string; titleEn: string; subtitleEs?: string; subtitleEn?: string; descriptionEs?: string; descriptionEn?: string; avatar?: BirhausResourceCardAvatar; status?: BirhausResourceCardStatus; badges?: BirhausResourceCardBadge[]; primaryInfo?: BirhausResourceCardInfo[]; secondaryInfo?: BirhausResourceCardInfo[]; primaryAction?: BirhausResourceCardAction; menuActions?: BirhausResourceCardAction[]; onCardClick?: () => void; variant?: 'default' | 'elevated' | 'interactive' | 'compact'; layout?: 'vertical' | 'horizontal'; showAvatar?: boolean; maxPrimaryInfo?: number; maxSecondaryInfo?: number; maxMenuActions?: number; maxBadges?: number; showCognitiveWarning?: boolean; cognitiveMode?: 'strict' | 'warning' | 'disabled'; className?: string; 'aria-label'?: string; 'aria-describedby'?: string; role?: string; data?: any; responsiveBreakpoint?: 'sm' | 'md' | 'lg'; mobileLayout?: 'vertical' | 'horizontal' | 'compact'; } interface BirhausResourceCardTemplate { showAvatar?: boolean; layout?: BirhausResourceCardProps['layout']; variant?: BirhausResourceCardProps['variant']; maxPrimaryInfo?: number; maxSecondaryInfo?: number; maxMenuActions?: number; cognitiveMode?: BirhausResourceCardProps['cognitiveMode']; menuActions?: BirhausResourceCardAction[]; primaryAction?: BirhausResourceCardAction; } interface BirhausResourceCardTemplateConfig { Student: (props: Partial) => BirhausResourceCardTemplate; Employee: (props: Partial) => BirhausResourceCardTemplate; Course: (props: Partial) => BirhausResourceCardTemplate; Contract: (props: Partial) => BirhausResourceCardTemplate; Church: (props: Partial) => BirhausResourceCardTemplate; Product: (props: Partial) => BirhausResourceCardTemplate; Transaction: (props: Partial) => BirhausResourceCardTemplate; Project: (props: Partial) => BirhausResourceCardTemplate; } interface BirhausResourceCardMetrics { primaryInfoCount: number; secondaryInfoCount: number; actionCount: number; badgeCount: number; cognitiveScore: number; violations: BirhausResourceCardViolation[]; } interface BirhausResourceCardViolation { type: 'excessive_primary_info' | 'excessive_secondary_info' | 'excessive_actions' | 'excessive_badges' | 'missing_spanish_labels'; severity: 'warning' | 'error'; message: string; recommendation: string; } interface BirhausResourceCardContext { language: 'es' | 'en'; cognitiveMode: BirhausResourceCardProps['cognitiveMode']; responsiveMode: boolean; theme: 'light' | 'dark'; } interface BirhausResourceCardState { isHovered: boolean; isExpanded: boolean; selectedActions: string[]; cognitiveWarnings: BirhausResourceCardViolation[]; } type BirhausResourceCardClickHandler = (cardId: string, data?: any) => void; type BirhausResourceCardActionHandler = (actionKey: string, cardId: string, data?: any) => void; type BirhausResourceCardHoverHandler = (cardId: string, isHovered: boolean) => void; type BirhausResourceCardVariant = BirhausResourceCardProps['variant']; type BirhausResourceCardLayout = BirhausResourceCardProps['layout']; type BirhausResourceCardCognitiveMode = BirhausResourceCardProps['cognitiveMode']; interface BirhausResourceCardFactory { createCard: (data: T) => BirhausResourceCardProps; validateData: (data: T) => boolean; transformData: (data: T) => BirhausResourceCardProps; template: keyof BirhausResourceCardTemplateConfig; } interface BirhausResourceCardAnimation { hover: { scale?: number; y?: number; transition?: { duration?: number; ease?: string; }; }; click: { scale?: number; transition?: { duration?: number; ease?: string; }; }; expand: { height?: string | number; transition?: { duration?: number; ease?: string; }; }; } interface BirhausResourceCardPerformance { renderTime: number; interactionTime: number; memoryUsage: 'low' | 'medium' | 'high'; rerenderCount: number; } interface BirhausResourceCardCollection { items: T[]; template: keyof BirhausResourceCardTemplateConfig; cognitiveMode: BirhausResourceCardCognitiveMode; maxItems: number; sortBy?: keyof T; filterBy?: Partial; } interface BirhausResourceCardGrid { columns: 1 | 2 | 3 | 4; gap: 'sm' | 'md' | 'lg'; responsive: boolean; maxCards: number; } /** * BIRHAUS Performance Budgets * * These constants define the performance and cognitive load limits * that all BIRHAUS components must adhere to. */ declare const BIRHAUS_PERFORMANCE: { /** * Bundle and asset size limits (in bytes) */ readonly BUDGETS: { readonly MAX_BUNDLE_SIZE: 200000; readonly MAX_COMPONENT_SIZE: 50000; readonly MAX_THEME_SIZE: 25000; readonly MAX_ICON_SIZE: 2000; readonly MAX_IMAGE_SIZE: 100000; readonly MAX_FONT_SIZE: 50000; }; /** * Core Web Vitals and performance metrics */ readonly WEB_VITALS: { readonly MAX_TTI: 2000; readonly MAX_FCP: 1000; readonly MAX_LCP: 2500; readonly MAX_CLS: 0.1; readonly MAX_INP: 200; readonly MAX_TBT: 300; readonly MIN_FID: 100; }; /** * Cognitive load and UX performance limits */ readonly COGNITIVE: { readonly MAX_ANIMATION_DURATION: 300; readonly MIN_ANIMATION_DURATION: 150; readonly MAX_TRANSITION_DURATION: 200; readonly MIN_TOUCH_TARGET: 44; readonly MIN_CONTRAST_RATIO: 4.5; readonly MAX_SIMULTANEOUS_ANIMATIONS: 2; readonly MAX_MODAL_STACK: 2; readonly MAX_TOAST_STACK: 3; }; /** * Network and loading performance */ readonly NETWORK: { readonly MAX_API_RESPONSE_TIME: 1000; readonly MAX_CONCURRENT_REQUESTS: 6; readonly MAX_RETRY_ATTEMPTS: 3; readonly CACHE_TTL: 300000; readonly OFFLINE_CACHE_SIZE: 50000000; }; /** * Memory and resource usage */ readonly MEMORY: { readonly MAX_DOM_NODES: 1500; readonly MAX_EVENT_LISTENERS: 100; readonly MAX_COMPONENT_INSTANCES: 50; readonly MAX_STATE_SIZE: 1000000; readonly MEMORY_LEAK_THRESHOLD: 10000000; }; /** * Accessibility performance */ readonly ACCESSIBILITY: { readonly MAX_TAB_STOPS: 20; readonly MIN_FOCUS_INDICATOR: 2; readonly MAX_HEADING_LEVELS: 6; readonly MIN_COLOR_CONTRAST: 4.5; readonly MIN_COLOR_CONTRAST_LARGE: 3; readonly MAX_ALT_TEXT_LENGTH: 125; }; }; /** * Lighthouse scoring weights for Birhaus Score calculation */ declare const BIRHAUS_SCORING: { readonly WEIGHTS: { readonly PERFORMANCE: 0.4; readonly ACCESSIBILITY: 0.3; readonly COGNITIVE_LOAD: 0.2; readonly SPANISH_COVERAGE: 0.1; }; readonly PENALTIES: { readonly CONFIRMATION_DIALOG: -10; readonly MILLER_LAW_VIOLATION: -5; readonly MISSING_SPANISH_LABEL: -2; readonly ACCESSIBILITY_VIOLATION: -3; readonly PERFORMANCE_BUDGET_EXCEEDED: -5; }; readonly BONUSES: { readonly UNDO_PATTERN_IMPLEMENTED: 5; readonly PROGRESSIVE_DISCLOSURE: 3; readonly SPANISH_FIRST_DESIGN: 2; readonly WCAG_AAA_COMPLIANCE: 5; readonly PERFORMANCE_EXCELLENCE: 3; }; }; /** * Type definitions for performance monitoring */ interface PerformanceMetrics { bundleSize: number; componentSize: number; ttiduration: number; fcp: number; lcp: number; cls: number; inp: number; domNodes: number; memoryUsage: number; apiResponseTime: number; accessibilityScore: number; } interface CognitiveLoadMetrics { navigationItems: number; formFields: number; selectOptions: number; modalStack: number; confirmationDialogs: number; undoPatterns: number; millerLawViolations: number; } interface BirhausScore { total: number; performance: number; accessibility: number; cognitiveLoad: number; spanishCoverage: number; violations: string[]; recommendations: string[]; timestamp: Date; } /** * Default Birhaus performance configuration */ declare const DEFAULT_BIRHAUS_CONFIG: { readonly strictMode: true; readonly cognitiveLoadTracking: true; readonly performanceBudgets: true; readonly accessibilityValidation: true; readonly spanishFirst: true; readonly undoOverConfirm: true; readonly millerLawEnforcement: true; readonly progressiveDisclosure: true; }; /** * Environment-specific configurations */ declare const BIRHAUS_ENV_CONFIG: { readonly development: { readonly strictMode: true; readonly showWarnings: true; readonly detailedLogging: true; readonly performanceMonitoring: true; readonly cognitiveLoadTracking: true; readonly performanceBudgets: true; readonly accessibilityValidation: true; readonly spanishFirst: true; readonly undoOverConfirm: true; readonly millerLawEnforcement: true; readonly progressiveDisclosure: true; }; readonly production: { readonly strictMode: false; readonly showWarnings: false; readonly detailedLogging: false; readonly performanceMonitoring: true; readonly analyticsEnabled: true; readonly cognitiveLoadTracking: true; readonly performanceBudgets: true; readonly accessibilityValidation: true; readonly spanishFirst: true; readonly undoOverConfirm: true; readonly millerLawEnforcement: true; readonly progressiveDisclosure: true; }; readonly testing: { readonly strictMode: true; readonly showWarnings: false; readonly detailedLogging: false; readonly performanceMonitoring: false; readonly cognitiveLoadTracking: true; readonly performanceBudgets: true; readonly accessibilityValidation: true; readonly spanishFirst: true; readonly undoOverConfirm: true; readonly millerLawEnforcement: true; readonly progressiveDisclosure: true; }; }; /** * Security utilities for BIRHAUS components * * Provides safe object access patterns to prevent object injection vulnerabilities * while maintaining type safety and performance. */ /** * Type guard to validate that a key exists in an object */ declare function validateObjectKey>(key: string, obj: T): key is Extract; /** * Safe object property access with fallback */ declare function safeAccess, F>(obj: T, key: string, fallback: F): T[Extract] | F; /** * Safe array access with bounds checking */ declare function safeArrayAccess(array: T[], index: number, fallback: T): T; /** * Validate variant against allowed values with type safety */ declare function validateVariant(variant: string, allowedVariants: readonly T[], fallback: T): T; /** * Safe CSS class lookup with validation * Common pattern for component styling */ declare function safeClassLookup>(classes: T, key: string, fallback: string): string; /** * Common BIRHAUS component variants for reuse */ declare const BIRHAUS_VARIANTS: readonly ["default", "primary", "secondary", "success", "warning", "error", "info"]; type BirhausVariant = typeof BIRHAUS_VARIANTS[number]; /** * Common BIRHAUS component sizes for reuse */ declare const BIRHAUS_SIZES: readonly ["sm", "md", "lg", "xl"]; type BirhausSize = typeof BIRHAUS_SIZES[number]; /** * Validate BIRHAUS variant with type safety */ declare function validateBirhausVariant(variant: string): BirhausVariant; /** * Validate BIRHAUS size with type safety */ declare function validateBirhausSize(size: string): BirhausSize; /** * Safe theme color access * Prevents theme object injection vulnerabilities */ declare function safeThemeAccess>(theme: T, path: string, fallback: string): string; export { type ActionValidationResult, type AlertVariant, type AttendanceStatus, BIRHAUS_ENV_CONFIG, BIRHAUS_PERFORMANCE, BIRHAUS_SCORING, BIRHAUS_SIZES, BIRHAUS_VARIANTS, BirhausAlert, type BirhausAlertAction, type BirhausAlertProps, BirhausAttendanceStatusBadge, BirhausBadge, type BirhausBadgeProps, type BirhausBulkAction$1 as BirhausBulkAction, BirhausBulkActionBar, type BirhausBulkActionBarProps, BirhausButton, type BirhausButtonProps, BirhausCalendar, type BirhausCalendarProps, BirhausCard, type BirhausCardAction, type BirhausCardProps, BirhausCheckbox, BirhausCheckboxGroup, type BirhausCheckboxGroupProps, type BirhausCheckboxProps, BirhausCombobox, type BirhausComboboxOption, type BirhausComboboxProps, BirhausContainer, type BirhausContainerProps, BirhausContractStatusBadge, BirhausCourseStatusBadge, BirhausCurrencyInput, type BirhausCurrencyInputProps, BirhausDataTable, type BirhausDataTableProps, BirhausDateRangePicker, type BirhausDateRangePickerProps, BirhausDialog, type BirhausDialogAction, type BirhausDialogProps, BirhausEmptyState, type BirhausEmptyStateAction, type BirhausEmptyStateProps, BirhausFileUpload, type BirhausFileUploadProps, BirhausFilterBar, type BirhausFilterBarProps, BirhausInput, type BirhausInputProps, BirhausPageHeader, type BirhausPageHeaderAction, type BirhausPageHeaderProps, BirhausPageLayout, type BirhausPageLayoutProps, BirhausPagination, type BirhausPaginationProps, BirhausPaymentStatusBadge, BirhausProgress, type BirhausProgressProps, BirhausQuickFilter, type BirhausQuickFilterConfig, type BirhausQuickFilterProps, BirhausRadioGroup, type BirhausRadioGroupProps, BirhausResourceCard, type BirhausResourceCardAction, type BirhausResourceCardActionHandler, type BirhausResourceCardAnimation, type BirhausResourceCardAvatar, type BirhausResourceCardBadge, type BirhausResourceCardClickHandler, type BirhausResourceCardCognitiveMode, type BirhausResourceCardCollection, type BirhausResourceCardContext, type BirhausResourceCardFactory, type BirhausResourceCardGrid, type BirhausResourceCardHoverHandler, type BirhausResourceCardInfo, type BirhausResourceCardLayout, type BirhausResourceCardMetrics, type BirhausResourceCardPerformance, type BirhausResourceCardProps, type BirhausResourceCardState, type BirhausResourceCardStatus, type BirhausResourceCardTemplate, type BirhausResourceCardTemplateConfig, BirhausResourceCardTemplates, type BirhausResourceCardVariant, type BirhausResourceCardViolation, type BirhausScore, BirhausSearchInput, type BirhausSearchInputProps, BirhausSearchableList, type BirhausSearchableListCognitiveWarning, type BirhausSearchableListGroup, type BirhausSearchableListGroupRenderer, type BirhausSearchableListGroupToggleHandler, type BirhausSearchableListItem, type BirhausSearchableListItemRenderer, type BirhausSearchableListMetrics, type BirhausSearchableListMultiSelectHandler, type BirhausSearchableListOption, type BirhausSearchableListPerformance, BirhausSearchableListPresets, type BirhausSearchableListProps, type BirhausSearchableListSearchHandler, type BirhausSearchableListSelectHandler, type BirhausSearchableListValidation, BirhausSelect, type BirhausSelectOption, type BirhausSelectProps, type BirhausSize, BirhausStatCard, type BirhausStatCardProps, BirhausStatusBadge, type BirhausStatusBadgeProps, BirhausStatusGroup, BirhausStudentStatusBadge, BirhausSwitch, type BirhausSwitchProps, BirhausTab, type BirhausTabItem, type BirhausTabProps, BirhausTable, type BirhausTableColumn$1 as BirhausTableColumn, type BirhausTableProps, BirhausTabs, type BirhausTabsProps, BirhausTextarea, type BirhausTextareaProps, type BirhausToastData, BirhausToastProvider, type BirhausToastProviderProps, BirhausToastStandalone, BirhausToggle, type BirhausToggleProps, type BirhausUndoConfig, type BirhausVariant, type BreadcrumbItem, type BirhausBulkAction as BulkAction, type BulkActionBarMetrics, type BulkActionConfigFactory, BulkActionPresets, type BulkActionState, type BulkActionVariant, type CheckboxCategory, type CheckboxOption, type CognitiveLoadMetrics, type ContractStatus, type CourseStatus, DEFAULT_BIRHAUS_CONFIG, type DataTableBulkActionConfig, type DataTableMetrics, type DateRange, ExtendedBulkActionPresets, type FileItem, type FilterConfig, type GenericStatus, type MillersLawCompliantNumber, type PaginationInfo$1 as PaginationInfo, type PaymentStatus, type PerformanceMetrics, type PresetRange, type ProgressInfo, type ProgressMetrics, type ProgressMilestone, type RadioOption, type SearchCategory, type SearchSuggestion, type SortDirection, type StatColor, type StatMetrics, type StatSize, type StatTrend, type StatVariant, type StatusCategory, type StatusType, type StudentStatus, type ValidationRule as TextareaValidationRule, type ToastVariant, type UndoAction, type UseBirhausDataTableReturn, type UseBirhausStatCardReturn, type UseBirhausStatusBadgeReturn, type UseBulkSelectionOptions, type UseBulkSelectionReturn, type ValidationRule$1 as ValidationRule, autoConfigureForCognitiveLoad, birhausAlertPresets, birhausContainerPresets, birhausEmptyStatePresets, birhausFilterBarPresets, birhausPageHeaderPresets, birhausPageLayoutPresets, birhausQuickFilterPresets, birhausStatCardPresets, birhausTextareaValidationRules, birhausToastMessages, birhausValidationRules, calculateCognitiveMetrics, commonColumnTypes, createApproveAction, createArchiveAction, createAssignAction, createBirhausBulkAction, createBirhausCardAction, createBirhausComboboxOption, createBirhausDateRange, createBirhausDialogAction, createBirhausOptionGroups, createBirhausTabItem, createBirhausTableColumn, createBulkActionConfig, createCopyAction, createDebounce, createDeleteAction, createDownloadAction, createEditAction, createEmailAction, createExportAction, createFavoriteAction, createIPUAdminSuggestion, createPermissionAction, createPriorityAction, createRejectAction, createStatMetrics, createStatusUpdateAction, createTagAction, createVisibilityAction, filterDataBySearch, filterItems, getBirhausStatusColor, getBirhausStatusIcon, getBirhausStatusLabel, getBirhausWeekdays, getBirhausWeekends, getItemDisplayName, getStatusCategory, groupItems, ipuAdminCheckboxOptions, ipuAdminDatePresets, ipuAdminPaginationConfig, ipuAdminProgressPresets, ipuAdminRadioGroupPresets, ipuAdminSearchCategories, ipuAdminTogglePresets, paraguayanCurrencyUtils, safeAccess, safeArrayAccess, safeClassLookup, safeThemeAccess, sortDataByColumn, useBirhausAlert, useBirhausButton, useBirhausCalendar, useBirhausCard, useBirhausCheckbox, useBirhausCheckboxGroup, useBirhausCombobox, useBirhausContainer, useBirhausCurrency, useBirhausDataTable, useBirhausDateRange, useBirhausDialog, useBirhausEmptyState, useBirhausFileUpload, useBirhausFilterBar, useBirhausPageHeader, useBirhausPageLayout, useBirhausPagination, useBirhausProgress, useBirhausQuickFilter, useBirhausRadioGroup, useBirhausSearch, useBirhausSelect, useBirhausStatCard, useBirhausStatusBadge, useBirhausTable, useBirhausTabs, useBirhausTextarea, useBirhausToast, useBirhausToggle, useBulkActionValidation, useBulkOperations, useBulkSelection, validateBirhausSize, validateBirhausVariant, validateCognitiveLoad, validateMillersLawCompliance, validateObjectKey, validateVariant };