@tamyla/ui-components-react/dist/index.d.ts

React-based UI component library with Factory Bridge pattern - integrates seamlessly with @tamyla/ui-components. Enhanced AI agent discoverability with structured component registry, comprehensive Storybook (8 components), and detailed guides.

import * as immer from 'immer';
import * as redux_persist_es_types from 'redux-persist/es/types';
import * as _reduxjs_toolkit from '@reduxjs/toolkit';
import { PayloadAction } from '@reduxjs/toolkit';
import * as redux_thunk from 'redux-thunk';
import * as redux from 'redux';
import * as React from 'react';
import React__default, { Component, ReactNode, ErrorInfo, ComponentType, LazyExoticComponent } from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as styled_components from 'styled-components';
import * as redux_persist from 'redux-persist';
import { TypedUseSelectorHook } from 'react-redux';

/**
 * Common Type Definitions for UI Components
 * Eliminates 'any' types with proper type safety
 */
type ComponentProps = Record<string, string | number | boolean | null | undefined | string[] | number[] | object>;
type ComponentState = Record<string, string | number | boolean | null | undefined | object>;
interface BaseComponentConfig {
    id: string;
    type: 'atom' | 'molecule' | 'organism';
    name: string;
    props: ComponentProps;
    state: ComponentState;
    isVisible: boolean;
    isDisabled: boolean;
    lastUpdated: string;
}
interface ComponentRegistryEntry {
    type: 'atom' | 'molecule' | 'organism';
    defaultProps: ComponentProps;
    stateSchema: ComponentState;
}
interface UIComponentState {
    isVisible: boolean;
    isExpanded: boolean;
    data: unknown;
}
type SearchResult$2 = {
    id: string;
    title: string;
    type: string;
    data?: unknown;
};
type FilterValue = string | number | boolean | string[] | number[];
interface ComponentUpdatePayload {
    componentId: string;
    props: ComponentProps;
}
interface ComponentStateUpdatePayload {
    componentId: string;
    stateUpdates: ComponentState;
}
interface FactoryConfig$1 {
    name?: string;
    version?: string;
    dependencies?: string[];
    [key: string]: unknown;
}
interface ComponentFactory$1 {
    create: (config?: FactoryConfig$1) => unknown;
    update?: (config: FactoryConfig$1) => void;
    destroy?: () => void;
    enableTradingPortalPatterns?: () => void;
    [key: string]: unknown;
}
interface ReduxState {
    [key: string]: unknown;
}

interface ComponentConfig extends BaseComponentConfig {
}
interface ComponentSliceState {
    components: {
        [componentId: string]: ComponentConfig;
    };
    activeComponent: string | null;
    componentRegistry: {
        [componentName: string]: ComponentRegistryEntry;
    };
}
declare const componentActions: _reduxjs_toolkit.CaseReducerActions<{
    registerComponent: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<{
        id: string;
        name: string;
        props?: ComponentProps;
        initialState?: ComponentState;
    }>) => void;
    unregisterComponent: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<string>) => void;
    updateComponentProps: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<ComponentUpdatePayload>) => void;
    updateComponentState: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<ComponentStateUpdatePayload>) => void;
    setComponentVisibility: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<{
        componentId: string;
        isVisible: boolean;
    }>) => void;
    setComponentDisabled: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<{
        componentId: string;
        isDisabled: boolean;
    }>) => void;
    setActiveComponent: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<string | null>) => void;
    registerComponentType: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<{
        name: string;
        config: ComponentRegistryEntry;
    }>) => void;
    unregisterComponentType: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<string>) => void;
    batchUpdateComponents: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<{
        updates: Array<{
            componentId: string;
            props?: ComponentProps;
            state?: ComponentState;
            isVisible?: boolean;
            isDisabled?: boolean;
        }>;
    }>) => void;
    resetComponent: (state: immer.WritableDraft<ComponentSliceState>, action: PayloadAction<string>) => void;
    resetAllComponents: (state: immer.WritableDraft<ComponentSliceState>) => void;
}, "components">;

interface ThemeState {
    mode: 'light' | 'dark' | 'auto';
    currentTheme: 'light' | 'dark';
    primaryColor: string;
    fontSize: 'sm' | 'md' | 'lg';
    animations: boolean;
    reducedMotion: boolean;
    highContrast: boolean;
    customColors: {
        [key: string]: string;
    };
}
declare const themeActions: _reduxjs_toolkit.CaseReducerActions<{
    setThemeMode: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<"light" | "dark" | "auto">) => void;
    setPrimaryColor: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<string>) => void;
    setFontSize: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<"sm" | "md" | "lg">) => void;
    toggleAnimations: (state: immer.WritableDraft<ThemeState>) => void;
    setAnimations: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<boolean>) => void;
    setReducedMotion: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<boolean>) => void;
    setHighContrast: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<boolean>) => void;
    setCustomColor: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<{
        key: string;
        value: string;
    }>) => void;
    removeCustomColor: (state: immer.WritableDraft<ThemeState>, action: PayloadAction<string>) => void;
    resetCustomColors: (state: immer.WritableDraft<ThemeState>) => void;
    resetTheme: () => ThemeState;
}, "theme">;

interface Notification$1 {
    id: string;
    type: 'success' | 'error' | 'warning' | 'info';
    title: string;
    message: string;
    timestamp: string;
    autoClose?: boolean;
    duration?: number;
}
interface Modal$1 {
    isOpen: boolean;
    data?: unknown;
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
}
interface UIState {
    sidebar: {
        isOpen: boolean;
        isMobile: boolean;
        activeSection: string;
        pinnedItems: string[];
    };
    modals: {
        [key: string]: Modal$1;
    };
    loading: {
        global: boolean;
        components: {
            [key: string]: boolean;
        };
    };
    notifications: Notification$1[];
    search: {
        query: string;
        filters: {
            [key: string]: FilterValue;
        };
        results: SearchResult$2[];
        isSearching: boolean;
    };
    viewport: {
        width: number;
        height: number;
        isMobile: boolean;
        isTablet: boolean;
        isDesktop: boolean;
    };
    componentStates: {
        [componentId: string]: UIComponentState;
    };
}
declare const uiActions: _reduxjs_toolkit.CaseReducerActions<{
    toggleSidebar: (state: immer.WritableDraft<UIState>) => void;
    setSidebarOpen: (state: immer.WritableDraft<UIState>, action: PayloadAction<boolean>) => void;
    setActiveSection: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    pinSidebarItem: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    unpinSidebarItem: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    openModal: (state: immer.WritableDraft<UIState>, action: PayloadAction<{
        id: string;
        data?: unknown;
        size?: Modal$1["size"];
    }>) => void;
    closeModal: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    closeAllModals: (state: immer.WritableDraft<UIState>) => void;
    setGlobalLoading: (state: immer.WritableDraft<UIState>, action: PayloadAction<boolean>) => void;
    setComponentLoading: (state: immer.WritableDraft<UIState>, action: PayloadAction<{
        component: string;
        loading: boolean;
    }>) => void;
    addNotification: (state: immer.WritableDraft<UIState>, action: PayloadAction<Omit<Notification$1, "id" | "timestamp">>) => void;
    removeNotification: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    clearNotifications: (state: immer.WritableDraft<UIState>) => void;
    setSearchQuery: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
    setSearchFilter: (state: immer.WritableDraft<UIState>, action: PayloadAction<{
        key: string;
        value: FilterValue;
    }>) => void;
    clearSearchFilters: (state: immer.WritableDraft<UIState>) => void;
    setSearchResults: (state: immer.WritableDraft<UIState>, action: PayloadAction<SearchResult$2[]>) => void;
    setSearching: (state: immer.WritableDraft<UIState>, action: PayloadAction<boolean>) => void;
    updateViewport: (state: immer.WritableDraft<UIState>, action: PayloadAction<{
        width: number;
        height: number;
    }>) => void;
    setComponentState: (state: immer.WritableDraft<UIState>, action: PayloadAction<{
        componentId: string;
        updates: Partial<UIState["componentStates"][string]>;
    }>) => void;
    removeComponentState: (state: immer.WritableDraft<UIState>, action: PayloadAction<string>) => void;
}, "ui">;

interface User {
    id: string;
    email: string;
    name: string;
    avatar?: string;
    role: 'user' | 'admin';
    preferences: {
        notifications: boolean;
        theme: 'light' | 'dark' | 'auto';
        language: string;
    };
    profile: {
        firstName?: string;
        lastName?: string;
        company?: string;
        phone?: string;
    };
}
interface AuthState {
    user: User | null;
    token: string | null;
    isAuthenticated: boolean;
    loading: boolean;
    error: string | null;
    sessionExpiry: string | null;
}
declare const authActions: _reduxjs_toolkit.CaseReducerActions<{
    loginStart: (state: immer.WritableDraft<AuthState>) => void;
    loginSuccess: (state: immer.WritableDraft<AuthState>, action: PayloadAction<{
        user: User;
        token: string;
        expiresAt?: string;
    }>) => void;
    loginFailure: (state: immer.WritableDraft<AuthState>, action: PayloadAction<string>) => void;
    logout: (state: immer.WritableDraft<AuthState>) => void;
    updateUser: (state: immer.WritableDraft<AuthState>, action: PayloadAction<Partial<User>>) => void;
    updateUserProfile: (state: immer.WritableDraft<AuthState>, action: PayloadAction<Partial<User["profile"]>>) => void;
    updateUserPreferences: (state: immer.WritableDraft<AuthState>, action: PayloadAction<Partial<User["preferences"]>>) => void;
    clearError: (state: immer.WritableDraft<AuthState>) => void;
    setLoading: (state: immer.WritableDraft<AuthState>, action: PayloadAction<boolean>) => void;
    refreshToken: (state: immer.WritableDraft<AuthState>, action: PayloadAction<{
        token: string;
        expiresAt?: string;
    }>) => void;
}, "auth">;

/**
 * Enhanced Card Component - shadcn/ui inspired with Redux integration
 *
 * A versatile card component that combines shadcn/ui design patterns with enterprise features
 * including optional Redux state tracking, analytics, and interactive behaviors.
 *
 * @example
 * ```tsx
 * // Basic usage
 * <Card>
 *   <Card.Header>
 *     <Card.Title>Card Title</Card.Title>
 *   </Card.Header>
 *   <Card.Content>
 *     // Create compound component with proper typing
const CardWithCompound = Card as CardComponent;
CardWithCompound.Header = CardHeader;
CardWithCompound.Title = CardTitle;
CardWithCompound.Content = CardContent;

// Export memoized version
export const MemoizedCard = React.memo(CardWithCompound);
MemoizedCard.displayName = 'MemoizedCard';

export default CardWithCompound;ntent goes here
 *   </Card.Content>
 * </Card>
 *
 * // With variants and Redux tracking
 * <Card
 *   variant="elevated"
 *   componentId="my-card"
 *   enableStateTracking
 *   enableAnalytics
 * >
 *   <Card.Content>Interactive card content</Card.Content>
 * </Card>
 * ```
 */

/**
 * Props for the Card component
 *
 * Extends all standard HTML div attributes with additional card-specific features
 */
interface CardProps extends React__default.HTMLAttributes<HTMLDivElement> {
    /**
     * Visual style variant of the card
     * @default 'default'
     */
    variant?: 'default' | 'outlined' | 'elevated' | 'filled';
    /**
     * Padding size for the card content
     * @default 'default'
     */
    padding?: 'none' | 'xs' | 'sm' | 'default' | 'lg';
    /**
     * Header content for the card (alternative to Card.Header)
     */
    header?: React__default.ReactNode;
    /**
     * Footer content for the card (alternative to Card.Footer)
     */
    footer?: React__default.ReactNode;
    /**
     * Whether to enable Redux state tracking for this card
     * @default false
     */
    enableStateTracking?: boolean;
    /**
     * Unique identifier for the card component (used for state tracking)
     */
    componentId?: string;
    /**
     * Whether the card should be interactive (clickable)
     * @default false
     */
    interactive?: boolean;
    /**
     * Callback fired when card is expanded
     */
    onExpand?: () => void;
    /**
     * Callback fired when card is collapsed
     */
    onCollapse?: () => void;
    /**
     * Whether to enable analytics tracking for card interactions
     * @default false
     */
    enableAnalytics?: boolean;
    /**
     * Custom analytics event name for tracking
     */
    analyticsEvent?: string;
    /**
     * Render as a different element (shadcn/ui pattern)
     * @default false
     */
    asChild?: boolean;
}
/**
 * Card header sub-component
 *
 * Provides consistent spacing and styling for card headers.
 * Typically contains the card title and any header actions.
 *
 * @example
 * ```tsx
 * <Card>
 *   <Card.Header>
 *     <Card.Title>Card Title</Card.Title>
 *     <Button size="sm">Action</Button>
 *   </Card.Header>
 * </Card>
 * ```
 */
interface CardHeaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
/**
 * Card title sub-component
 *
 * Provides consistent typography styling for card titles.
 * Renders as an h3 element for proper semantic structure.
 *
 * @example
 * ```tsx
 * <Card.Header>
 *   <Card.Title>My Card Title</Card.Title>
 * </Card.Header>
 * ```
 */
interface CardTitleProps extends React__default.HTMLAttributes<HTMLHeadingElement> {
}
/**
 * Card content sub-component
 *
 * Provides consistent spacing for card content areas.
 * Removes top padding to align with card headers.
 *
 * @example
 * ```tsx
 * <Card.Content>
 *   <p>This is the main content of the card.</p>
 * </Card.Content>
 * ```
 */
interface CardContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
}

/**
 * Standardized Component Props - shadcn/ui inspired
 * Provides consistent prop interfaces across all components
 */

type ComponentVariant = 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost';
type ComponentSize = 'xs' | 'sm' | 'default' | 'lg';
interface StandardizedComponentProps {
    variant?: ComponentVariant;
    size?: ComponentSize;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    componentId?: string;
}
interface StandardizedInputProps extends StandardizedComponentProps {
    error?: boolean;
    errorMessage?: string;
    helpText?: string;
    startIcon?: React__default.ReactNode;
    endIcon?: React__default.ReactNode;
    label?: string;
    required?: boolean;
}

/**
 * Enhanced Input Component - shadcn/ui inspired with Redux integration
 * Combines shadcn/ui patterns with your enterprise features
 */

interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size'>, StandardizedInputProps {
    variant?: ComponentVariant;
    size?: ComponentSize;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    error?: boolean;
    errorMessage?: string;
    helpText?: string;
    startIcon?: React__default.ReactNode;
    endIcon?: React__default.ReactNode;
    label?: string;
    required?: boolean;
}

/**
 * Enhanced Button Component - shadcn/ui inspired with Redux integration
 *
 * A versatile button component that combines shadcn/ui design patterns with enterprise features
 * including optional Redux integration, analytics tracking, and dynamic theming.
 *
 * @example
 * ```tsx
 * // Basic usage
 * <Button>Click me</Button>
 *
 * // With variant and size
 * <Button variant="primary" size="lg">Large Button</Button>
 *
 * // With Redux analytics
 * <Button enableAnalytics analyticsEvent="save_click">Save</Button>
 *
 * // With icons
 * <Button leftIcon={<SaveIcon />}>Save</Button>
 *
 * // Loading state
 * <Button isLoading loadingText="Saving...">Save</Button>
 * ```
 */

/**
 * Props for the Button component
 *
 * Extends all standard HTML button attributes with additional features
 */
interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    /**
     * Visual style variant of the button
     * @default 'default'
     */
    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
    /**
     * Size variant of the button
     * @default 'default'
     */
    size?: 'xs' | 'sm' | 'default' | 'lg' | 'icon';
    /**
     * Whether the button is in a loading state
     * @default false
     */
    isLoading?: boolean;
    /**
     * Icon to display on the left side of the button content
     */
    leftIcon?: React__default.ReactNode;
    /**
     * Icon to display on the right side of the button content
     */
    rightIcon?: React__default.ReactNode;
    /**
     * Whether to enable analytics tracking for button clicks
     * @default false
     */
    enableAnalytics?: boolean;
    /**
     * Custom analytics event name for tracking
     * @default undefined
     */
    analyticsEvent?: string;
    /**
     * Text to display when button is in loading state
     * @default undefined
     */
    loadingText?: string;
    /**
     * Whether to automatically adjust variant based on theme mode
     * @default false
     */
    useThemeVariant?: boolean;
}

interface Props {
    children: ReactNode;
    fallback?: ReactNode;
    onError?: (error: Error, errorInfo: ErrorInfo) => void;
}
interface State {
    hasError: boolean;
    error?: Error;
}
declare class ErrorBoundary$1 extends Component<Props, State> {
    constructor(props: Props);
    static getDerivedStateFromError(error: Error): State;
    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
    render(): string | number | boolean | Iterable<React__default.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
}

/**
 * StatusIndicator Component - React wrapper for ui-components StatusIndicatorFactory
 */

interface StatusIndicatorProps {
    status?: 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'warning';
    size?: 'xs' | 'sm' | 'md' | 'lg';
    showLabel?: boolean;
    label?: string;
    animated?: boolean;
    pulseEffect?: boolean;
    tradingStatus?: 'order-pending' | 'order-filled' | 'order-cancelled' | 'market-open' | 'market-closed';
    onClick?: (_: React__default.MouseEvent<HTMLDivElement>) => void;
    onMouseEnter?: (_: React__default.MouseEvent<HTMLDivElement>) => void;
    onMouseLeave?: (_: React__default.MouseEvent<HTMLDivElement>) => void;
    className?: string;
}
declare const StatusIndicator: React__default.FC<StatusIndicatorProps>;

interface ButtonPrimaryProps {
    children?: React__default.ReactNode;
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    fullWidth?: boolean;
    icon?: string;
    iconPosition?: 'left' | 'right';
    className?: string;
}
declare const ButtonPrimary: React__default.FC<ButtonPrimaryProps>;

/**
 * Factory System Type Definitions
 * Provides proper TypeScript types for @tamyla/ui-components integration
 */

interface BaseFactoryComponent {
    element: HTMLElement;
    destroy(): void;
    update(config: Record<string, unknown>): void;
}
type FactoryCreator<TConfig = Record<string, unknown>> = (config?: TConfig) => BaseFactoryComponent;
interface ComponentFactory<TConfig = Record<string, unknown>> {
    create: FactoryCreator<TConfig>;
    createPrimary?: FactoryCreator<TConfig>;
    createSecondary?: FactoryCreator<TConfig>;
    createOutline?: FactoryCreator<TConfig>;
    createGhost?: FactoryCreator<TConfig>;
}
interface ComponentEventData {
    type: string;
    target: string;
    data?: unknown;
    timestamp: number;
}
type ComponentEventHandler = (event: ComponentEventData) => void;
interface FactoryConfig {
    id?: string;
    className?: string;
    style?: Record<string, string>;
    disabled?: boolean;
    variant?: 'default' | 'primary' | 'secondary' | 'outline' | 'ghost';
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
}
interface ButtonFactoryConfig extends FactoryConfig {
    text?: string;
    onClick?: () => void;
    loading?: boolean;
    icon?: string;
}
interface InputFactoryConfig extends FactoryConfig {
    placeholder?: string;
    value?: string;
    type?: 'text' | 'email' | 'password' | 'number';
    required?: boolean;
    pattern?: string;
}
interface CardFactoryConfig extends FactoryConfig {
    title?: string;
    content?: string;
    header?: boolean;
    footer?: boolean;
}
interface UIComponentsModule$1 {
    ButtonFactory: ComponentFactory<ButtonFactoryConfig>;
    InputFactory: ComponentFactory<InputFactoryConfig>;
    CardFactory: ComponentFactory<CardFactoryConfig>;
    Button: FactoryCreator<ButtonFactoryConfig>;
    Input: FactoryCreator<InputFactoryConfig>;
    Card: FactoryCreator<CardFactoryConfig>;
    createComponent: <TConfig>(type: string, config?: TConfig) => BaseFactoryComponent;
    destroyComponent: (component: BaseFactoryComponent) => void;
}
interface FactoryBridgeProps {
    componentType: keyof UIComponentsModule$1;
    config?: Record<string, unknown>;
    children?: React__default.ReactNode;
    className?: string;
    onEvent?: ComponentEventHandler;
    onMount?: (component: BaseFactoryComponent) => void;
    onUnmount?: () => void;
}

declare const ReactButtonSecondary: React__default.FC<object & FactoryBridgeProps>;

interface ButtonGhostProps {
    children?: React__default.ReactNode;
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    fullWidth?: boolean;
    icon?: string;
    iconPosition?: 'left' | 'right';
    className?: string;
}
declare const ButtonGhost: React__default.FC<ButtonGhostProps>;

interface ButtonDangerProps {
    children?: React__default.ReactNode;
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    fullWidth?: boolean;
    icon?: string;
    iconPosition?: 'left' | 'right';
    className?: string;
}
declare const ButtonDanger: React__default.FC<ButtonDangerProps>;

interface ButtonSuccessProps {
    children?: React__default.ReactNode;
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    fullWidth?: boolean;
    icon?: string;
    iconPosition?: 'left' | 'right';
    className?: string;
}
declare const ButtonSuccess: React__default.FC<ButtonSuccessProps>;

interface ButtonWithIconProps {
    children?: React__default.ReactNode;
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    fullWidth?: boolean;
    icon: string;
    iconPosition?: 'left' | 'right';
    variant?: 'primary' | 'secondary' | 'ghost' | 'danger' | 'success';
    className?: string;
}
declare const ButtonWithIcon: React__default.FC<ButtonWithIconProps>;

interface ButtonIconOnlyProps {
    onClick?: (_event: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    loading?: boolean;
    size?: 'sm' | 'md' | 'lg';
    icon: string;
    variant?: 'primary' | 'secondary' | 'ghost' | 'danger' | 'success';
    'aria-label': string;
    tooltip?: string;
    className?: string;
}
declare const ButtonIconOnly: React__default.FC<ButtonIconOnlyProps>;

/**
 * InputGroup Component - React wrapper for InputGroupFactory
 */
interface InputGroupProps {
    inputs?: Array<{
        type?: string;
        name?: string;
        placeholder?: string;
        required?: boolean;
    }>;
    layout?: 'horizontal' | 'vertical' | 'inline';
    spacing?: 'tight' | 'normal' | 'loose';
    validation?: boolean;
    className?: string;
}
declare const InputGroup: (props: InputGroupProps) => React.ReactNode;

/**
 * Enhanced Form Components - shadcn/ui inspired with Redux integration
 * Combines shadcn/ui patterns with your enterprise features
 */

type HTMLLabelElement = globalThis.HTMLLabelElement;
type HTMLParagraphElement$2 = globalThis.HTMLParagraphElement;
type HTMLTextAreaElement = globalThis.HTMLTextAreaElement;
interface FormItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const FormItem: React__default.ForwardRefExoticComponent<FormItemProps & React__default.RefAttributes<HTMLDivElement>>;
interface FormLabelProps extends React__default.LabelHTMLAttributes<HTMLLabelElement> {
}
declare const FormLabel: React__default.ForwardRefExoticComponent<FormLabelProps & React__default.RefAttributes<globalThis.HTMLLabelElement>>;
interface FormControlProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const FormControl: React__default.ForwardRefExoticComponent<FormControlProps & React__default.RefAttributes<HTMLDivElement>>;
interface FormDescriptionProps extends React__default.HTMLAttributes<HTMLParagraphElement$2> {
}
declare const FormDescription: React__default.ForwardRefExoticComponent<FormDescriptionProps & React__default.RefAttributes<globalThis.HTMLParagraphElement>>;
interface FormMessageProps extends React__default.HTMLAttributes<HTMLParagraphElement$2> {
}
declare const FormMessage: React__default.ForwardRefExoticComponent<FormMessageProps & React__default.RefAttributes<globalThis.HTMLParagraphElement>>;
interface FormFieldProps {
    name: string;
    error?: string;
    isRequired?: boolean;
    children: React__default.ReactNode;
}
declare const FormField: React__default.FC<FormFieldProps>;
interface FormInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size'> {
    name: string;
    label?: string;
    description?: string;
    error?: string;
    isRequired?: boolean;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    variant?: 'default' | 'filled' | 'ghost';
    size?: 'sm' | 'default' | 'lg';
    startIcon?: React__default.ReactNode;
    endIcon?: React__default.ReactNode;
}
declare const FormInput: React__default.ForwardRefExoticComponent<FormInputProps & React__default.RefAttributes<HTMLInputElement>>;
interface FormTextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
    name: string;
    label?: string;
    description?: string;
    error?: string;
    isRequired?: boolean;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const FormTextarea: React__default.ForwardRefExoticComponent<FormTextareaProps & React__default.RefAttributes<globalThis.HTMLTextAreaElement>>;

/**
 * Missing Form Components - Select, Checkbox, Radio, Switch, Slider
 * shadcn/ui inspired with Redux integration
 */

type HTMLSelectElement = globalThis.HTMLSelectElement;
interface SelectProps extends React__default.SelectHTMLAttributes<HTMLSelectElement> {
    options: Array<{
        value: string;
        label: string;
        disabled?: boolean;
    }>;
    placeholder?: string;
    error?: string;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<globalThis.HTMLSelectElement>>;
interface CheckboxProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type'> {
    label?: string;
    error?: string;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLInputElement>>;
interface RadioGroupProps {
    value?: string;
    onValueChange?: (value: string) => void;
    disabled?: boolean;
    className?: string;
    children: React__default.ReactNode;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const RadioGroup: React__default.FC<RadioGroupProps>;
interface RadioGroupItemProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type'> {
    value: string;
}
declare const RadioGroupItem: React__default.ForwardRefExoticComponent<RadioGroupItemProps & React__default.RefAttributes<HTMLInputElement>>;
interface SwitchProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type'> {
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & React__default.RefAttributes<HTMLInputElement>>;
interface SliderProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type'> {
    min?: number;
    max?: number;
    step?: number;
    value?: number;
    onValueChange?: (value: number) => void;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Slider: React__default.ForwardRefExoticComponent<SliderProps & React__default.RefAttributes<HTMLInputElement>>;

/**
 * User Feedback & Status Components - Alert, Progress, Badge
 * shadcn/ui inspired with Redux integration
 */

type HTMLHeadingElement$1 = globalThis.HTMLHeadingElement;
type HTMLParagraphElement$1 = globalThis.HTMLParagraphElement;
interface AlertProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: 'default' | 'destructive' | 'success' | 'warning' | 'info';
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    autoClose?: boolean;
    duration?: number;
}
declare const Alert: React__default.ForwardRefExoticComponent<AlertProps & React__default.RefAttributes<HTMLDivElement>>;
interface AlertTitleProps extends React__default.HTMLAttributes<HTMLHeadingElement$1> {
}
declare const AlertTitle: React__default.ForwardRefExoticComponent<AlertTitleProps & React__default.RefAttributes<globalThis.HTMLParagraphElement>>;
interface AlertDescriptionProps extends React__default.HTMLAttributes<HTMLParagraphElement$1> {
}
declare const AlertDescription: React__default.ForwardRefExoticComponent<AlertDescriptionProps & React__default.RefAttributes<globalThis.HTMLParagraphElement>>;
interface ProgressProps extends React__default.HTMLAttributes<HTMLDivElement> {
    value?: number;
    max?: number;
    variant?: 'default' | 'success' | 'warning' | 'destructive';
    size?: 'sm' | 'default' | 'lg';
    showValue?: boolean;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Progress: React__default.ForwardRefExoticComponent<ProgressProps & React__default.RefAttributes<HTMLDivElement>>;
interface BadgeProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: 'default' | 'secondary' | 'destructive' | 'outline' | 'success' | 'warning';
    size?: 'xs' | 'sm' | 'default' | 'lg';
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Badge: React__default.ForwardRefExoticComponent<BadgeProps & React__default.RefAttributes<HTMLDivElement>>;
interface AvatarProps extends React__default.HTMLAttributes<HTMLDivElement> {
    src?: string;
    alt?: string;
    fallback?: string;
    size?: 'xs' | 'sm' | 'default' | 'lg' | 'xl';
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Avatar: React__default.ForwardRefExoticComponent<AvatarProps & React__default.RefAttributes<HTMLDivElement>>;

/**
 * Data Display Components - Table, Calendar
 * shadcn/ui inspired with Redux integration
 */

type HTMLTableElement = globalThis.HTMLTableElement;
type HTMLTableSectionElement = globalThis.HTMLTableSectionElement;
type HTMLTableRowElement = globalThis.HTMLTableRowElement;
type HTMLTableCellElement = globalThis.HTMLTableCellElement;
type HTMLTableCaptionElement = globalThis.HTMLTableCaptionElement;
interface TableProps extends React__default.HTMLAttributes<HTMLTableElement> {
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Table: React__default.ForwardRefExoticComponent<TableProps & React__default.RefAttributes<globalThis.HTMLTableElement>>;
interface TableHeaderProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
}
declare const TableHeader: React__default.ForwardRefExoticComponent<TableHeaderProps & React__default.RefAttributes<globalThis.HTMLTableSectionElement>>;
interface TableBodyProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
}
declare const TableBody: React__default.ForwardRefExoticComponent<TableBodyProps & React__default.RefAttributes<globalThis.HTMLTableSectionElement>>;
interface TableFooterProps extends React__default.HTMLAttributes<HTMLTableSectionElement> {
}
declare const TableFooter: React__default.ForwardRefExoticComponent<TableFooterProps & React__default.RefAttributes<globalThis.HTMLTableSectionElement>>;
interface TableRowProps extends React__default.HTMLAttributes<HTMLTableRowElement> {
}
declare const TableRow: React__default.ForwardRefExoticComponent<TableRowProps & React__default.RefAttributes<globalThis.HTMLTableRowElement>>;
interface TableHeadProps extends React__default.ThHTMLAttributes<HTMLTableCellElement> {
}
declare const TableHead: React__default.ForwardRefExoticComponent<TableHeadProps & React__default.RefAttributes<globalThis.HTMLTableCellElement>>;
interface TableCellProps extends React__default.TdHTMLAttributes<HTMLTableCellElement> {
}
declare const TableCell: React__default.ForwardRefExoticComponent<TableCellProps & React__default.RefAttributes<globalThis.HTMLTableCellElement>>;
interface TableCaptionProps extends React__default.HTMLAttributes<HTMLTableCaptionElement> {
}
declare const TableCaption: React__default.ForwardRefExoticComponent<TableCaptionProps & React__default.RefAttributes<globalThis.HTMLTableCaptionElement>>;
interface CalendarProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
    selected?: Date;
    onDateSelect?: (date: Date | undefined) => void;
    mode?: 'single' | 'multiple' | 'range';
    disabled?: (date: Date) => boolean;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Calendar: React__default.ForwardRefExoticComponent<CalendarProps & React__default.RefAttributes<HTMLDivElement>>;

/**
 * Loading & Feedback Components - Skeleton, HoverCard, Popover
 * shadcn/ui inspired with Redux integration
 */

interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Skeleton: React__default.ForwardRefExoticComponent<SkeletonProps & React__default.RefAttributes<HTMLDivElement>>;
interface HoverCardProps extends React__default.HTMLAttributes<HTMLDivElement> {
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const HoverCard: React__default.ForwardRefExoticComponent<HoverCardProps & React__default.RefAttributes<HTMLDivElement>>;
interface HoverCardTriggerProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const HoverCardTrigger: React__default.ForwardRefExoticComponent<HoverCardTriggerProps & React__default.RefAttributes<HTMLDivElement>>;
interface HoverCardContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
    side?: 'top' | 'right' | 'bottom' | 'left';
    align?: 'start' | 'center' | 'end';
    size?: 'sm' | 'default' | 'lg';
}
declare const HoverCardContent: React__default.ForwardRefExoticComponent<HoverCardContentProps & React__default.RefAttributes<HTMLDivElement>>;
interface PopoverProps extends React__default.HTMLAttributes<HTMLDivElement> {
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
}
declare const Popover: React__default.ForwardRefExoticComponent<PopoverProps & React__default.RefAttributes<HTMLDivElement>>;
interface PopoverTriggerProps extends React__default.HTMLAttributes<HTMLButtonElement> {
}
declare const PopoverTrigger: React__default.ForwardRefExoticComponent<PopoverTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
interface PopoverContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
    side?: 'top' | 'right' | 'bottom' | 'left';
    align?: 'start' | 'center' | 'end';
    isOpen?: boolean;
    size?: 'sm' | 'default' | 'lg';
}
declare const PopoverContent: React__default.ForwardRefExoticComponent<PopoverContentProps & React__default.RefAttributes<HTMLDivElement>>;

/**
 * ActionCard Component - Enhanced React wrapper for ActionCardFactory
 * Features: Redux integration, styled-components, accessibility, analytics
 */

interface ActionCardProps {
    title?: string;
    description?: string;
    icon?: string;
    variant?: 'default' | 'primary' | 'success' | 'warning' | 'danger';
    size?: 'sm' | 'md' | 'lg';
    interactive?: boolean;
    elevation?: boolean;
    disabled?: boolean;
    loading?: boolean;
    points?: number;
    level?: string;
    progress?: number;
    badge?: string;
    onClick?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
    onMouseEnter?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
    onMouseLeave?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
    onFocus?: (event: React__default.FocusEvent<HTMLDivElement>) => void;
    onBlur?: (event: React__default.FocusEvent<HTMLDivElement>) => void;
    className?: string;
    style?: React__default.CSSProperties;
    'data-testid'?: string;
}
declare const ActionCard: React__default.FC<ActionCardProps>;

/**
 * ContentCard Component - Enhanced React wrapper for ContentCardFactory
 * Features: Redux integration, styled-components, accessibility, performance optimization
 */

interface ContentCardProps {
    title?: string;
    content?: string;
    image?: string;
    tags?: string[];
    author?: string;
    date?: string;
    readTime?: string;
    variant?: 'default' | 'featured' | 'compact';
    size?: 'sm' | 'md' | 'lg';
    interactive?: boolean;
    onClick?: (event: React__default.MouseEvent<HTMLElement>) => void;
    onMouseEnter?: (event: React__default.MouseEvent<HTMLElement>) => void;
    onMouseLeave?: (event: React__default.MouseEvent<HTMLElement>) => void;
    onFocus?: (event: React__default.FocusEvent<HTMLElement>) => void;
    onBlur?: (event: React__default.FocusEvent<HTMLElement>) => void;
    className?: string;
    style?: React__default.CSSProperties;
    'data-testid'?: string;
}
declare const ContentCard: React__default.FC<ContentCardProps>;

/**
 * FileList Component - Enhanced React wrapper for FileListFactory
 * Features: Drag & drop, Redux integration, file validation, progress tracking
 */

interface FileItemData {
    id: string;
    name: string;
    size: number;
    type: string;
    url?: string;
    uploadProgress?: number;
    lastModified?: number;
    error?: string;
}
interface FileListProps {
    files?: FileItemData[];
    allowUpload?: boolean;
    allowDelete?: boolean;
    allowDownload?: boolean;
    maxFiles?: number;
    acceptedTypes?: string[];
    maxFileSize?: number;
    onFileAdd?: (files: FileList) => void;
    onFileRemove?: (fileId: string) => void;
    onFileDownload?: (fileId: string) => void;
    onDragOver?: (event: React__default.DragEvent<HTMLDivElement>) => void;
    onDragLeave?: (event: React__default.DragEvent<HTMLDivElement>) => void;
    onDrop?: (event: React__default.DragEvent<HTMLDivElement>) => void;
    onUploadProgress?: (fileId: string, progress: number) => void;
    onUploadError?: (fileId: string, error: string) => void;
    className?: string;
    style?: React__default.CSSProperties;
    'data-testid'?: string;
}
declare const FileList: React__default.FC<FileListProps>;

/**
 * Notification Component - Enhanced React wrapper for NotificationFactory
 * Features: Redux integration, animations, accessibility, auto-dismiss
 */

interface NotificationProps {
    type?: 'success' | 'error' | 'warning' | 'info';
    title?: string;
    message?: string;
    duration?: number;
    closable?: boolean;
    actions?: Array<{
        label: string;
        action: () => void;
        variant?: 'primary' | 'secondary';
    }>;
    onClose?: () => void;
    className?: string;
    style?: React__default.CSSProperties;
    'data-testid'?: string;
}
declare const Notification: React__default.FC<NotificationProps>;

/**
 * Seaconst SearchContainer = styled.div`
  width: 100%;
  max-width: 100%;
  margin: 0 auto;

  @media (min-width: ${responsiveSizes.sm}px) {
    max-width: ${600}px;
  }
`;lecule - Enhanced search with Factory Bridge integration
 */

interface SearchSuggestion {
    id: string;
    text: string;
    category?: string;
}
interface SearchEvent {
    detail?: {
        query?: string;
    };
    target?: {
        value?: string;
    };
}
interface SuggestionEvent {
    detail?: SearchSuggestion;
}
interface SearchBarProps$1 {
    placeholder?: string;
    onSearch?: (query: string) => void;
    onSuggestionSelect?: (suggestion: SearchSuggestion) => void;
    voiceEnabled?: boolean;
    clearable?: boolean;
    showSuggestions?: boolean;
    onTmylSearch?: (event: SearchEvent) => void;
    onTmylSearchSuggestion?: (event: SuggestionEvent) => void;
    className?: string;
}
declare const SearchBar$1: React__default.FC<SearchBarProps$1>;

/**
 * SearchBar Component - React wrapper for SearchBarFactory
 */
interface SearchBarProps {
    placeholder?: string;
    size?: 'sm' | 'md' | 'lg';
    variant?: 'primary' | 'secondary' | 'ghost';
    disabled?: boolean;
    loading?: boolean;
    voiceEnabled?: boolean;
    clearable?: boolean;
    showSubmitButton?: boolean;
    suggestions?: string[];
    showSuggestions?: boolean;
    maxSuggestions?: number;
    onSearch?: (query: string) => void;
    onChange?: (value: string) => void;
    className?: string;
}
declare const SearchBar: React.FC<SearchBarProps & FactoryBridgeProps>;

/**
 * Enhanced Dialog Component - shadcn/ui inspired with Redux integration
 * Combines shadcn/ui patterns with your enterprise features
 */

interface DialogProps {
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    children: React__default.ReactNode;
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    componentId?: string;
}
declare const Dialog: React__default.FC<DialogProps>;
interface DialogTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    asChild?: boolean;
}
declare const DialogTrigger: React__default.ForwardRefExoticComponent<DialogTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
interface DialogContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
    size?: 'sm' | 'default' | 'lg' | 'xl';
}
declare const DialogContent: React__default.ForwardRefExoticComponent<DialogContentProps & React__default.RefAttributes<HTMLDivElement>>;
interface DialogHeaderProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const DialogHeader: React__default.ForwardRefExoticComponent<DialogHeaderProps & React__default.RefAttributes<HTMLDivElement>>;
interface DialogTitleProps extends React__default.HTMLAttributes<HTMLHeadingElement> {
}
declare const DialogTitle: React__default.ForwardRefExoticComponent<DialogTitleProps & React__default.RefAttributes<HTMLHeadingElement>>;
interface DialogDescriptionProps extends React__default.HTMLAttributes<HTMLParagraphElement> {
}
declare const DialogDescription: React__default.ForwardRefExoticComponent<DialogDescriptionProps & React__default.RefAttributes<HTMLParagraphElement>>;
interface DialogFooterProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const DialogFooter: React__default.ForwardRefExoticComponent<DialogFooterProps & React__default.RefAttributes<HTMLDivElement>>;
interface DialogCloseProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    asChild?: boolean;
}
declare const DialogClose: React__default.ForwardRefExoticComponent<DialogCloseProps & React__default.RefAttributes<HTMLButtonElement>>;

/**
 * Enhanced Navigation Component - shadcn/ui inspired with Redux integration
 * Combines shadcn/ui navigation patterns with your enterprise features
 */

interface NavigationItem$1 {
    id: string;
    label: string;
    href?: string;
    icon?: React__default.ReactNode;
    badge?: string | number;
    children?: NavigationItem$1[];
    disabled?: boolean;
}
interface NavigationProps extends React__default.HTMLAttributes<HTMLElement> {
    items?: NavigationItem$1[];
    activeItem?: string;
    onItemClick?: (item: NavigationItem$1) => void;
    variant?: 'default' | 'pills' | 'underline';
    size?: 'sm' | 'default' | 'lg';
    orientation?: 'horizontal' | 'vertical';
    enableAnalytics?: boolean;
    analyticsEvent?: string;
    componentId?: string;
}
declare const Navigation: React__default.ForwardRefExoticComponent<NavigationProps & React__default.RefAttributes<HTMLElement>>;
interface NavigationMenuProps extends React__default.HTMLAttributes<HTMLDivElement> {
    children: React__default.ReactNode;
}
declare const NavigationMenu: React__default.FC<NavigationMenuProps>;
interface NavigationMenuItemProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const NavigationMenuItem: React__default.FC<NavigationMenuItemProps>;
interface NavigationMenuTriggerProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
}
declare const NavigationMenuTrigger: React__default.ForwardRefExoticComponent<NavigationMenuTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
interface NavigationMenuContentProps extends React__default.HTMLAttributes<HTMLDivElement> {
}
declare const NavigationMenuContent: React__default.FC<NavigationMenuContentProps>;

interface DashboardWidget {
    id: string;
    component: string;
    props?: Record<string, string | number | boolean | object>;
}
interface SearchFilters$1 {
    [key: string]: string | number | boolean | string[];
}
interface SearchResult$1 {
    id: string;
    title: string;
    description?: string;
    url?: string;
    score: number;
    type: string;
    metadata?: Record<string, string | number | boolean>;
}
interface DashboardItem {
    id: string;
    title: string;
    type: string;
    metadata?: Record<string, string | number | boolean>;
}
interface DashboardActionData {
    action: string;
    widgetId: string;
    payload?: Record<string, string | number | boolean | object>;
}
interface DashboardProps {
    type?: 'search' | 'content' | 'knowledge' | 'media';
    title?: string;
    description?: string;
    widgets?: DashboardWidget[];
    layout?: 'grid' | 'list' | 'cards' | 'vertical' | 'horizontal';
    size?: 'default' | 'compact' | 'large' | 'expanded';
    searchAPI?: (query: string, filters: SearchFilters$1) => Promise<SearchResult$1[]>;
    onResults?: (results: SearchResult$1[]) => void;
    onError?: (error: Error) => void;
    onSelection?: (item: DashboardItem) => void;
    onWidgetAction?: (action: string, data: DashboardActionData) => void;
    className?: string;
    style?: React__default.CSSProperties;
}
declare const DashboardSearch: React__default.FC<DashboardProps & FactoryBridgeProps>;
declare const DashboardContent: React__default.FC<DashboardProps & FactoryBridgeProps>;
declare const DashboardKnowledge: React__default.FC<DashboardProps & FactoryBridgeProps>;
declare const DashboardMedia: React__default.FC<DashboardProps & FactoryBridgeProps>;
declare const Dashboard: React__default.FC<DashboardProps>;

/**
 * SearchInterface Component - React wrapper for SearchInterfaceFactory
 */
interface FilterOption {
    value: string;
    label: string;
}
interface Filter {
    name: string;
    label: string;
    type: 'select' | 'checkbox' | 'range';
    options?: FilterOption[];
}
interface SearchFilters {
    [key: string]: string | number | boolean | string[];
}
interface SearchResult {
    id: string;
    title: string;
    description?: string;
    url?: string;
    score: number;
    type: string;
    metadata?: Record<string, unknown>;
}
interface SearchItem {
    id: string;
    title: string;
    type: string;
    metadata?: Record<string, unknown>;
}
interface SearchInterfaceProps {
    title?: string;
    description?: string;
    searchProps?: Record<string, unknown>;
    filters?: Filter[];
    initialQuery?: string;
    initialFilters?: SearchFilters;
    searchAPI?: (query: string, filters: SearchFilters) => Promise<SearchResult[]>;
    onSearch?: (query: string, filters: SearchFilters) => void;
    onResults?: (results: SearchResult[]) => void;
    onError?: (error: Error) => void;
    onSelection?: (item: SearchItem) => void;
    showHeader?: boolean;
    showFilters?: boolean;
    showResultsActions?: boolean;
    layout?: 'vertical' | 'horizontal';
    size?: 'default' | 'compact' | 'large';
    debounceMs?: number;
    pageSize?: number;
    enableVoiceSearch?: boolean;
    enableFiltering?: boolean;
    enableSorting?: boolean;
    trackAnalytics?: boolean;
    className?: string;
}
declare const SearchInterface: React.FC<SearchInterfaceProps & FactoryBridgeProps>;

/**
 * Reward System Component - React wrapper