import { Animation as Animation_2 } from './Button.type';
import { AnimationProps } from 'app-studio';
import { ButtonProps as ButtonProps_2 } from 'app-studio';
import { CheckboxStyles } from './Checkbox.type';
import { CloseButtonPosition } from './Modal.type';
import { CloseButtonPosition as CloseButtonPosition_2 } from './Drawer.type';
import { Country } from './CountryPicker.type';
import { CountryPickerStyles } from './CountryPicker.type';
import { DatePickerStyles } from './DatePicker.type';
import { default as default_2 } from 'react';
import { default as default_3 } from 'lucide-react/dynamicIconImports';
import { Dispatch } from 'react';
import { Elevation } from '../../../utils/elevation';
import { Elevation as Elevation_2 } from '../../../../utils/elevation';
import { FormikConfig } from 'formik';
import { IconPosition } from './Button.type';
import { ImageProps } from 'app-studio';
import { InputProps } from 'app-studio';
import { LoaderPosition } from './Button.type';
import { LoaderType } from './Loader.type';
import { Option as Option_2 } from './Select.type';
import { Option as Option_3 } from './Selector.type';
import { Placement } from './Drawer.type';
import { Position as Position_4 } from './Modal.type';
import { RadioStyles } from './Radio.type';
import { ReactNode } from 'react';
import { SelectorStyles } from './Selector.type';
import { SelectStyles } from './Select.type';
import { SetStateAction } from 'react';
import { Shadow } from 'app-studio';
import { Shape as Shape_10 } from './CountryPicker.type';
import { Shape as Shape_11 } from './DatePicker.type';
import { Shape as Shape_20 } from './Modal.type';
import { Shape as Shape_3 } from './Button.type';
import { Shape as Shape_5 } from './Select.type';
import { Shape as Shape_6 } from './Selector.type';
import { Shape as Shape_8 } from './TextField.type';
import { Size as Size_11 } from './TextField.type';
import { Size as Size_12 } from './Checkbox.type';
import { Size as Size_14 } from './CountryPicker.type';
import { Size as Size_15 } from './DatePicker.type';
import { Size as Size_18 } from './Radio.type';
import { Size as Size_23 } from './Link.type';
import { Size as Size_24 } from './Modal.type';
import { Size as Size_25 } from './Drawer.type';
import { Size as Size_3 } from './Loader.type';
import { Size as Size_4 } from './Button.type';
import { Size as Size_7 } from './Select.type';
import { Size as Size_8 } from './Switch.type';
import { Size as Size_9 } from './Selector.type';
import { Speed } from './Loader.type';
import { StoreApi } from 'zustand';
import { Styles } from './Link.type';
import { SwitchStyles } from './Switch.type';
import { Tab } from './Tabs.type';
import { TabsStyles } from './Tabs.type';
import { TabsVariant } from './Tabs.type';
import { TextDecorationStyle } from './Link.type';
import { TextFieldStyles } from './TextField.type';
import { TextPosition } from './Loader.type';
import { TextProps } from 'app-studio';
import { UseBoundStore } from 'zustand';
import { Variant as Variant_10 } from './TextField.type';
import { Variant as Variant_12 } from './CountryPicker.type';
import { Variant as Variant_13 } from './DatePicker.type';
import { Variant as Variant_4 } from './Button.type';
import { Variant as Variant_7 } from './Select.type';
import { Variant as Variant_8 } from './Selector.type';
import { ViewProps } from 'app-studio';

export declare const Accordion: AccordionComponentType;

export declare interface AccordionComponentType extends default_2.FC<AccordionProps> {
    Item: default_2.FC<AccordionItemProps>;
    Trigger: default_2.FC<AccordionTriggerProps & {
        value?: string;
        isExpanded?: boolean;
        isDisabled?: boolean;
        triggerId?: string;
        contentId?: string;
    }>;
    Content: default_2.FC<AccordionContentProps>;
}

export declare interface AccordionContentProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
}

export declare interface AccordionItemProps extends Omit<ViewProps, 'value'> {
    value: string;
    children: default_2.ReactNode;
    isDisabled?: boolean;
    views?: {
        item?: ViewProps;
        trigger?: ViewProps;
        content?: ViewProps;
        icon?: ViewProps;
    };
}

export declare interface AccordionProps extends Omit<ViewProps, 'value' | 'defaultValue' | 'onChange'> {
    children?: default_2.ReactNode;
    type?: AccordionType;
    defaultValue?: string | string[];
    value?: string | string[];
    onValueChange?: (value: string | string[] | undefined) => void;
    collapsible?: boolean;
    shape?: Shape;
    variant?: Variant;
    views?: AccordionStyles;
}

declare interface AccordionStyles {
    container?: ViewProps;
    item?: ViewProps;
    header?: ViewProps;
    trigger?: ViewProps;
    content?: ViewProps;
    icon?: ViewProps;
}

export declare interface AccordionTriggerProps extends ViewProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
        icon?: ViewProps;
    };
    asChild?: boolean;
}

declare type AccordionType = 'single' | 'multiple';

export declare const Alert: (props: AlertProps) => default_2.JSX.Element;

export declare interface AlertProps extends ViewProps {
    icon?: default_2.ReactNode;
    title?: string;
    description?: string | default_2.ReactNode;
    children?: default_2.ReactNode;
    variant?: Variant_2;
    severity?: string;
    status?: string;
    onClose?: () => void;
    views?: AlertStyles;
}

declare type AlertStyles = {
    container?: ViewProps;
    title?: ViewProps;
    description?: ViewProps;
    icon?: ViewProps;
};

declare type Alignment = 'start' | 'center' | 'end';

declare type Alignment_2 = 'start' | 'center' | 'end';

declare type Alignment_3 = 'start' | 'center' | 'end';

export declare const ArrowIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const AspectRatio: ({ ratio, children, ...props }: AspectRatioProps) => default_2.JSX.Element;

export declare interface AspectRatioProps extends ViewProps {
    ratio?: number;
    views?: {
        container?: ViewProps;
        center?: ViewProps;
        view?: ViewProps;
    };
}

declare interface Attachment {
    id: string;
    name: string;
    size?: number;
    type?: string;
    url?: string;
}

export declare const AttachmentGroup: default_2.FC<AttachmentGroupProps>;

declare interface AttachmentGroupProps {
    files: File[];
    sandboxId?: string;
    onRemove: (index: number) => void;
    layout?: 'inline' | 'grid';
    maxHeight?: string;
    showPreviews?: boolean;
    views?: {
        container?: any;
        item?: any;
        name?: any;
        size?: any;
        removeButton?: any;
    };
}

export declare const AttachmentIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const AttachmentPreview: default_2.FC<AttachmentPreviewProps>;

declare interface AttachmentPreviewProps {
    files: Array<{
        name: string;
        size: number;
        type: string;
        url?: string;
    }>;
    onRemove?: (index: number) => void;
    maxHeight?: string;
    views?: {
        container?: any;
        item?: any;
        name?: any;
        removeButton?: any;
    };
}

export declare const AudioIcon: default_2.FC<Omit<IconProps, "name">>;

export declare function AudioInput(props: AudioInputProps): default_2.JSX.Element;

export declare interface AudioInputProps extends ViewProps {
    onAudio: (file: File) => void;
}

export declare interface AudioInputViewProps extends AudioInputProps {
    recording: boolean;
    paused: boolean;
    audioBlob: Blob | null;
    analyserNode: AnalyserNode | null;
    duration: number;
    error: string | null;
    startRecording: () => void;
    stopRecording: () => void;
    pauseRecording: () => void;
    resumeRecording: () => void;
    resetRecording: () => void;
    handleFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
}

export declare const AudioWaveform: default_2.FC<AudioWaveformProps>;

declare interface AudioWaveformProps extends ViewProps {
    analyserNode: AnalyserNode | null;
    isPaused: boolean;
}

export declare interface AuroraBackgroundProps extends BackgroundProps {
    showRadialGradient?: boolean;
}

export declare const Avatar: (props: AvatarProps) => default_2.JSX.Element;

export declare interface AvatarProps {
    src?: string;
    size?: Size;
    fallback?: string;
    views?: AvatarStyles;
    onClick?: Function;
    children?: React.ReactNode;
}

declare type AvatarStyles = {
    container?: ViewProps;
    image?: ViewProps;
    fallback?: ViewProps;
};

export declare interface AvatarViewProps extends AvatarProps {
    imageError: boolean;
    setImageError: React.Dispatch<React.SetStateAction<boolean>>;
}

export declare const Background: default_2.ForwardRefExoticComponent<BackgroundProps & default_2.RefAttributes<HTMLDivElement>> & {
    Layout: default_2.FC<BackgroundLayoutProps>;
    Aurora: default_2.FC<AuroraBackgroundProps>;
    Meteors: default_2.FC<MeteorsProps>;
    Wall: default_2.FC<WallProps>;
    Particles: default_2.FC<ParticlesProps>;
    Grid: default_2.FC<GridProps>;
    Ripples: default_2.FC<RipplesProps>;
    Image: default_2.FC<BackgroundImageProps>;
    Video: default_2.FC<BackgroundVideoProps>;
    Gradient: default_2.FC<BackgroundGradientProps>;
    Overlay: default_2.FC<BackgroundOverlayProps>;
};

export declare interface BackgroundGradientProps extends GradientProps {
}

export declare interface BackgroundImageProps extends Omit<BackgroundProps, 'position' | 'overlay'> {
    src: string;
    backgroundSize?: BackgroundSize;
    backgroundPosition?: BackgroundPosition;
    backgroundRepeat?: BackgroundRepeat;
    backgroundAttachment?: 'scroll' | 'fixed' | 'local';
    imageOpacity?: number;
    blendMode?: BlendMode;
    overlay?: ReactNode;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
        image?: ViewProps;
    };
}

export declare interface BackgroundLayoutProps extends BackgroundProps {
    shape?: 'square' | 'rounded' | 'pill';
    designProps?: any;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
        back?: ViewProps;
        front?: ViewProps;
    };
}

export declare interface BackgroundOverlayProps extends ViewProps {
    contentPosition?: 'left' | 'right' | 'center' | 'bottom' | 'top';
}

declare type BackgroundPosition = 'center' | 'top' | 'right' | 'bottom' | 'left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | string;

export declare interface BackgroundProps extends ViewProps {
    children?: ReactNode;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
    };
    shape?: 'square' | 'rounded' | 'pill';
    decorationRotation?: number;
    decorationScale?: number;
    decorationOpacity?: number;
}

declare type BackgroundRepeat = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | 'space' | 'round';

declare type BackgroundSize = 'auto' | 'cover' | 'contain' | string;

export declare interface BackgroundStyles {
    container?: ViewProps;
    content?: ViewProps;
    aurora?: ViewProps;
    meteors?: ViewProps;
    image?: ViewProps;
    video?: ViewProps;
    gradient?: ViewProps;
}

export declare interface BackgroundVideoProps extends Omit<BackgroundProps, 'position' | 'overlay'> {
    src: string;
    autoPlay?: boolean;
    loop?: boolean;
    muted?: boolean;
    playsInline?: boolean;
    overlay?: ReactNode;
    blendMode?: BlendMode;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
        video?: ViewProps;
    };
}

export declare const BackIcon: (props: IconProps) => default_2.JSX.Element;

export declare const Badge: (props: BadgeProps) => default_2.JSX.Element;

export declare interface BadgeProps extends Omit<ViewProps, 'content' | 'position'> {
    content?: string | number;
    children?: React.ReactNode;
    icon?: React.ReactNode;
    pastil?: boolean | string;
    pastilContent?: React.ReactNode;
    action?: React.ReactNode;
    variant?: Variant_3;
    position?: Position;
    size?: Size_2;
    shape?: Shape_2;
    views?: BadgeStyles;
    /**
     * Auto-derive a foreground color from the badge's background color
     * (used by examples that loop over theme tokens for the `content` prop).
     */
    isAuto?: boolean;
    config?: Record<string, unknown>;
}

declare type BadgeStyles = {
    container?: ViewProps;
    text?: ViewProps;
    icon?: ViewProps;
    pastil?: ViewProps;
    pastilContent?: ViewProps;
    action?: ViewProps;
};

export declare const BatteryIcon: default_2.FC<Omit<IconProps, "name">>;

declare type BlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion';

export declare const BluetoothIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface BodyProps extends ViewProps {
    views?: {
        view?: ViewProps;
    };
    buttonColor?: any;
    buttonSize?: any;
    variant?: string;
}

export declare const BoldArrowIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const BookmarkIcon: default_2.FC<Omit<IconProps, "name">>;

export declare type BrandAccentTreatment = 'flat' | 'gradient' | 'stripe' | 'glow' | 'halftone';

export declare type BrandCornerStyle = 'sharp' | 'soft' | 'pill';

export declare type BrandDensity = 'tight' | 'comfortable' | 'spacious';

export declare interface BrandPersonality {
    cornerStyle: BrandCornerStyle;
    typeWeight: BrandTypeWeight;
    typeCase: BrandTypeCase;
    typeStyle: BrandTypeStyle;
    letterSpacing: string;
    accentTreatment: BrandAccentTreatment;
    signatureMotif: string;
    density: BrandDensity;
    surfaceTone: BrandSurfaceTone;
    cardRadius: number;
    pillRadius: number;
    badgeRadius: number;
    voice: string;
}

export declare type BrandSurfaceTone = 'paper' | 'glass' | 'matte' | 'mono';

export declare type BrandTypeCase = 'normal' | 'uppercase';

export declare type BrandTypeStyle = 'normal' | 'italic';

export declare type BrandTypeWeight = 'light' | 'regular' | 'bold' | 'black';

declare type BreakpointBehavior = 'collapse' | 'overlay' | 'hide';

export declare const Button: default_2.FC<ButtonProps>;

export declare interface ButtonProps extends Omit<ButtonProps_2, 'size' | 'onClick' | 'variant' | 'shadow'> {
    children?: default_2.ReactNode;
    to?: string;
    isLoading?: boolean;
    loaderProps?: LoaderProps;
    loaderPosition?: LoaderPosition;
    icon?: default_2.ReactNode;
    iconPosition?: IconPosition;
    isDisabled?: boolean;
    isFilled?: boolean;
    isAuto?: boolean;
    isIconRounded?: boolean;
    onClick?: (...args: any) => any;
    isExternal?: boolean;
    isIcon?: boolean;
    size?: Size_4;
    shadow?: Shadow | Elevation | ViewProps;
    shape?: Shape_3;
    ariaLabel?: string;
    variant?: Variant_4 | string;
    animation?: Animation_2;
    color?: string;
    textColor?: string;
    reversed?: boolean;
    borderMovingDuration?: number;
    borderMovingGradientColors?: string[];
    isHovered?: boolean;
    animatedStrokeAccentColor?: string;
    animatedStrokeTextColor?: string;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
        loader?: ViewProps;
        icon?: ViewProps;
        link?: ViewProps;
    };
    config?: any;
    keys?: any[];
    label?: default_2.ReactNode;
    leftIcon?: default_2.ReactNode;
    rightIcon?: default_2.ReactNode;
    startIcon?: default_2.ReactNode;
    endIcon?: default_2.ReactNode;
}

export declare const CalendarIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CameraIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Card: CardType;

export declare interface CardContentProps extends ViewProps {
    children: React.ReactNode;
    views?: ViewProps;
}

export declare interface CardFooterProps extends ViewProps {
    children: React.ReactNode;
    views?: ViewProps;
}

export declare interface CardHeaderProps extends ViewProps {
    children: React.ReactNode;
    views?: ViewProps;
}

export declare interface CardProps extends ViewProps {
    variant?: Variant_5;
    size?: Size_5;
    shape?: Shape_4;
    children?: React.ReactNode;
    header?: React.ReactNode;
    footer?: React.ReactNode;
    isFullWidth?: boolean;
    views?: CardStyles;
    config?: any;
}

declare interface CardStyles {
    container?: ViewProps;
    header?: ViewProps;
    content?: ViewProps;
    footer?: ViewProps;
}

export declare interface CardType extends React.FC<CardProps> {
    Header: React.FC<CardHeaderProps>;
    Content: React.FC<CardContentProps>;
    Footer: React.FC<CardFooterProps>;
}

export declare const Carousel: CarouselType;

export declare interface CarouselContentProps extends ViewProps {
    children: React.ReactNode;
    views?: Pick<CarouselStyles, 'content' | 'innerContainer'>;
}

export declare interface CarouselItemProps extends ViewProps {
    children: React.ReactNode;
    views?: Pick<CarouselStyles, 'item'>;
}

export declare interface CarouselNextProps extends Omit<ButtonProps, 'views'> {
    views?: Pick<CarouselStyles, 'nextButton'>;
}

export declare interface CarouselPreviousProps extends Omit<ButtonProps, 'views'> {
    views?: Pick<CarouselStyles, 'prevButton'>;
}

export declare interface CarouselProps extends Omit<ViewProps, 'position' | 'onChange' | 'direction' | 'transitionDuration'> {
    children?: React.ReactNode[];
    defaultActiveIndex?: number;
    activeIndex?: number;
    onChange?: (index: number) => void;
    showNavigation?: boolean;
    navigationPosition?: NavigationPosition;
    prevButton?: React.ReactNode;
    nextButton?: React.ReactNode;
    showIndicators?: boolean;
    indicatorPosition?: IndicatorPosition;
    indicatorVariant?: IndicatorVariant;
    autoPlay?: boolean;
    autoPlayInterval?: number;
    pauseOnHover?: boolean;
    infinite?: boolean;
    direction?: SlideDirection;
    transitionDuration?: number;
    stepIndices?: number[];
    views?: CarouselStyles;
}

export declare interface CarouselSlideProps extends ViewProps {
    children: React.ReactNode;
    isActive?: boolean;
    index?: number;
    views?: ViewProps;
}

declare interface CarouselStyles {
    container?: ViewProps;
    slide?: ViewProps;
    slideWrapper?: ViewProps;
    prevButton?: ViewProps;
    nextButton?: ViewProps;
    indicators?: ViewProps;
    indicator?: ViewProps;
    activeIndicator?: ViewProps;
    content?: ViewProps;
    innerContainer?: ViewProps;
    item?: ViewProps;
}

export declare interface CarouselType extends React.FC<CarouselProps> {
    Slide: React.FC<CarouselSlideProps>;
    Content: React.FC<CarouselContentProps>;
    Item: React.FC<CarouselItemProps>;
    Previous: React.FC<CarouselPreviousProps>;
    Next: React.FC<CarouselNextProps>;
}

export declare const Chart: default_2.FC<ChartProps>;

export declare const CHART_COLORS: {
    blue: string;
    green: string;
    purple: string;
    orange: string;
    red: string;
    teal: string;
    pink: string;
    indigo: string;
    yellow: string;
    cyan: string;
};

declare interface ChartData {
    labels: string[];
    series: ChartSeries[];
}

declare interface ChartDataPoint {
    label: string;
    value: number;
    color?: string;
}

export declare const ChartIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface ChartProps extends Omit<ViewProps, 'animationDuration'> {
    type: ChartType;
    data?: ChartData;
    dataPoints?: ChartDataPoint[];
    title?: string;
    showLegend?: boolean;
    legendPosition?: 'top' | 'right' | 'bottom' | 'left';
    showGrid?: boolean;
    showTooltips?: boolean;
    animated?: boolean;
    animationDuration?: number;
    responsive?: boolean;
    aspectRatio?: number;
    width?: number | string;
    height?: number | string;
    views?: ChartStyles;
    onDataPointClick?: (dataPoint: ChartDataPoint | null, index: number) => void;
    onSeriesClick?: (seriesName: string, index: number) => void;
    isLoading?: boolean;
    error?: React.ReactNode;
    noData?: boolean | React.ReactNode;
    loadingIndicator?: React.ReactNode;
    errorIndicator?: React.ReactNode;
    noDataIndicator?: React.ReactNode;
    'aria-label'?: string;
}

declare interface ChartSeries {
    name: string;
    data: number[];
    color?: string;
}

declare interface ChartStyles {
    container?: ViewProps;
    chart?: ViewProps;
    legend?: ViewProps;
    legendItem?: ViewProps;
    tooltip?: ViewProps;
    axis?: ViewProps;
    grid?: ViewProps;
    bar?: ViewProps;
    line?: ViewProps;
    point?: ViewProps;
    pie?: ViewProps;
    area?: ViewProps;
    axisLabel?: ViewProps;
    axisLine?: ViewProps;
    axisTick?: ViewProps;
    loadingOverlay?: ViewProps;
    errorOverlay?: ViewProps;
    noDataOverlay?: ViewProps;
}

declare type ChartType = 'bar' | 'line' | 'pie' | 'donut' | 'area';

export declare const ChatInput: default_2.ForwardRefExoticComponent<ChatInputProps & default_2.RefAttributes<HTMLElement>>;

/**
 * Props for the ChatInput component
 */
export declare interface ChatInputProps extends Omit<ViewProps, 'onChange' | 'onSubmit' | 'loading'> {
    /**
     * Get the pending files
     */
    getPendingFiles?: () => File[];
    /**
     * Clear the pending files
     */
    clearPendingFiles?: () => void;
    /**
     * Callback function when the form is submitted
     */
    onSubmit?: (message: string, options?: {
        model_name?: string;
        enable_thinking?: boolean;
    }) => void;
    /**
     * Placeholder text for the input
     */
    placeholder?: string;
    /**
     * Whether the input is in a loading state
     */
    loading?: boolean;
    /**
     * Whether the input is disabled
     */
    disabled?: boolean;
    /**
     * Whether the input is disabled (camelCase alias for `disabled`)
     */
    isDisabled?: boolean;
    /**
     * Visible row count for the input
     */
    lines?: number;
    /**
     * Optional right-side affordance rendered inside the input
     */
    rightElement?: React.ReactNode;
    /**
     * Optional key handler for the editable area
     */
    onKeyDown?: (e: React.KeyboardEvent) => void;
    /**
     * Error state or value used by form wrappers
     */
    error?: any;
    /**
     * Whether an agent is currently running
     */
    isAgentRunning?: boolean;
    /**
     * Whether an agent is currently running (alias for `isAgentRunning`)
     */
    isWorkerRunning?: boolean;
    /**
     * Callback function to stop the agent
     */
    onStopAgent?: () => void;
    /**
     * Callback function to stop the worker (alias for `onStopAgent`)
     */
    onStopWorker?: () => void;
    /**
     * Whether to auto focus the input
     */
    autoFocus?: boolean;
    /**
     * Controlled value for the input
     */
    value?: string;
    /**
     * Callback function when the input value changes
     */
    onChange?: (value: string) => void;
    /**
     * Callback function when the file browser is opened
     */
    onFileBrowse?: () => void;
    /**
     * ID of the sandbox
     */
    sandboxId?: string;
    /**
     * Callback when file upload progress changes
     */
    onUploadProgress?: (progress: number) => void;
    /**
     * Callback when file upload succeeds
     */
    onUploadSuccess?: (data: any) => void;
    /**
     * Callback when file upload fails
     */
    onUploadError?: (error: any) => void;
    /**
     * Function to execute file upload. Parent should provide this.
     * Should return an object with a loading property.
     */
    onFileUpload?: (file: File) => void;
    /**
     * Whether to hide the attachment button
     */
    hideAttachments?: boolean;
    /**
     * Enable audio recording button
     */
    enableAudioRecording?: boolean;
    /**
     * Callback when audio recording starts
     */
    onAudioRecordingStart?: () => void;
    /**
     * Callback when audio recording stops
     */
    onAudioRecordingStop?: (audio: Blob) => void;
    /**
     * Title for the chat input
     */
    title?: string;
    /**
     * Whether to show the guide tip
     */
    showGuideTip?: boolean;
    /**
     * URL for the guide video
     */
    guideVideoUrl?: string;
    /**
     * Callback function when the guide tip is closed
     */
    onGuideClose?: () => void;
    /**
     * List of prompt examples
     */
    promptExamples?: PromptExample[];
    /**
     * List of suggestions for auto-completion
     */
    suggestions?: Suggestion[];
    /**
     * Callback function when a prompt example is selected
     */
    onPromptExampleSelect?: (example: PromptExample) => void;
    /**
     * Data for mention auto-completion
     */
    mentionData?: Array<{
        id: string;
        name: string;
        avatar?: string;
        description?: string;
    }>;
    /**
     * Trigger character for mentions (default: '@')
     */
    mentionTrigger?: string;
    /**
     * Callback function when a mention is selected
     */
    onMentionSelect?: (mention: {
        id: string;
        name: string;
        avatar?: string;
        description?: string;
    }) => void;
    /**
     * Error message to display at the bottom
     */
    errorMessage?: string;
    /**
     * Size of the input
     */
    size?: Size_19;
    /**
     * Shape of the input
     */
    shape?: Shape_14;
    /**
     * Variant of the input
     */
    variant?: Variant_16;
    /**
     * Style customization
     */
    views?: ChatInputStyles;
}

/**
 * Style customization interface for ChatInput
 */
declare interface ChatInputStyles {
    textarea?: ViewProps;
    container?: ViewProps;
    content?: ViewProps;
    editableInput?: ViewProps;
    header?: ViewProps;
    title?: ViewProps;
    guideTip?: ViewProps;
    guideTipVideo?: ViewProps;
    guideTipClose?: ViewProps;
    promptExamples?: ViewProps;
    promptExampleItem?: ViewProps;
    attachments?: ViewProps;
    attachmentItem?: ViewProps;
    attachmentName?: ViewProps;
    attachmentSize?: ViewProps;
    attachmentRemove?: ViewProps;
    submitButton?: ViewProps;
    fileButton?: ViewProps;
    recordButton?: ViewProps;
    modelSelector?: ViewProps;
    loadingIndicator?: ViewProps;
    bottomTip?: ViewProps;
}

/**
 * Props for the ChatInput view component
 */
export declare interface ChatInputViewProps extends ChatInputProps {
    /**
     * Current value of the input
     */
    value?: string;
    /**
     * Callback function when the input value changes
     */
    handleChange: (value: string) => void;
    /**
     * Callback function when the form is submitted
     */
    handleSubmit: (e: React.FormEvent) => void;
    /**
     * Reference to the editable div element
     */
    editableRef: React.RefObject<HTMLDivElement | null>;
    /**
     * Reference to the file input element
     */
    fileInputRef: React.RefObject<HTMLInputElement | null>;
    /**
     * Whether files are being uploaded
     */
    isUploading: boolean;
    /**
     * Current upload progress (0-100)
     */
    uploadProgress?: number;
    leftButtons?: React.ReactNode;
    rightButtons?: React.ReactNode;
    /**
     * Whether the user is dragging files over the input
     */
    isDraggingOver: boolean;
    /**
     * List of uploaded files
     */
    uploadedFiles: File[];
    /**
     * Callback function to remove an uploaded file
     */
    removeUploadedFile: (index: number) => void;
    /**
     * Callback function to set pending files
     */
    setPendingFiles: React.Dispatch<React.SetStateAction<File[]>>;
    /**
     * Callback function to set uploaded files
     */
    setUploadedFiles: React.Dispatch<React.SetStateAction<File[]>>;
    /**
     * Callback function to set whether files are being uploaded
     */
    setIsUploading: React.Dispatch<React.SetStateAction<boolean>>;
    /**
     * Start uploading newly added files
     */
    startUpload: (files: File[]) => void;
    /**
     * Currently selected model
     */
    selectedModel: string;
    /**
     * Callback function when the model changes
     */
    handleModelChange: (model: string) => void;
    /**
     * List of available models
     */
    modelOptions: ModelOption[];
    /**
     * Subscription status
     */
    subscriptionStatus?: string;
    /**
     * Whether the user can access the selected model
     */
    canAccessModel: (model: string) => boolean;
    /**
     * Whether the guide tip is shown
     */
    isGuideTipShown: boolean;
    /**
     * Callback function to hide the guide tip
     */
    hideGuideTip: () => void;
    /**
     * Callback function to handle prompt example selection
     */
    handlePromptExampleSelect: (example: PromptExample) => void;
    /**
     * Callback function to handle drag over events
     */
    handleDragOver: (e: React.DragEvent<HTMLDivElement>) => void;
    /**
     * Callback function to handle drag leave events
     */
    handleDragLeave: (e: React.DragEvent<HTMLDivElement>) => void;
    /**
     * List of suggestions for auto-completion
     */
    suggestions?: Suggestion[];
    /**
     * Optional text label displayed while in loading state.
     */
    loadingText?: string;
    /**
     * Optional text label displayed on the attachment button / area.
     */
    attachmentText?: string;
    /**
     * Files staged for upload (pending) — surfaced by the state hook.
     */
    pendingFiles?: File[];
    /**
     * Optional error message used by some compositions (e.g. Formik wrapper).
     */
    error?: any;
}

export declare const ChatWidget: default_2.FC<ChatWidgetProps>;

export declare const ChatWidgetComponent: default_2.FC<ChatWidgetProps>;

export declare interface ChatWidgetProps extends Omit<ViewProps, 'size' | 'onSubmit'> {
    messages?: Message[];
    inputValue?: string;
    onInputChange?: (value: string) => void;
    onSubmit?: (message: string) => void;
    inputPlaceholder?: string;
    disableInput?: boolean;
    variant?: Variant_31;
    size?: Size_34;
    showTimestamps?: boolean;
    enableAttachments?: boolean;
    enableContextPicker?: boolean;
    selectedContextElements?: Array<{
        id: string;
        name: string;
    }>;
    onContextPickerClick?: () => void;
    onRemoveContextElement?: (id: string) => void;
    isLoading?: boolean;
    loadingText?: string;
    styles?: ChatWidgetStyles;
    maxHeight?: string | number;
}

declare interface ChatWidgetStyles {
    container?: any;
    messagesContainer?: any;
    inputContainer?: any;
    bubble?: any;
    userBubble?: any;
    assistantBubble?: any;
    timestamp?: any;
    input?: any;
    sendButton?: any;
    attachmentButton?: any;
    loadingIndicator?: any;
    contextChipsContainer?: any;
    contextPickerButton?: any;
    reasoningContainer?: any;
    reasoningContent?: any;
    errorMessage?: any;
    systemMessage?: any;
    toolMessage?: any;
}

export declare interface ChatWidgetViewProps extends ChatWidgetProps {
    internalInputValue: string;
    handleInputChange: (value: string) => void;
    handleSubmit: (e?: React.FormEvent) => void;
    inputRef: React.RefObject<HTMLTextAreaElement | null>;
    messagesRef: React.RefObject<HTMLDivElement | null>;
}

/**
 * ChatWidget Widget Component
 * A floating chat widget with DOM element selection capabilities.
 */
export declare const ChatWidgetWidget: default_2.FC<ChatWidgetWidgetProps>;

declare interface ChatWidgetWidgetProps {
    initialMessages?: Message[];
    onSendMessage?: (message: string, contextElements: ContextElement_2[]) => void;
    bubbleSize?: 'sm' | 'md' | 'lg';
}

/**
 * Checkbox allows users to select one or more options from a list of choices.
 */
export declare const Checkbox: default_2.FC<CheckboxProps>;

export declare interface CheckboxProps extends Omit<InputProps, 'size' | 'onChange' | 'shadow'> {
    id?: string;
    icon?: default_2.ReactNode;
    error?: any;
    name?: string;
    label?: string;
    isChecked?: boolean;
    defaultIsSelected?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isIndeterminate?: boolean;
    labelPosition?: 'left' | 'right';
    onChange?: Function;
    onValueChange?: Function;
    views?: CheckboxStyles;
    size?: Size_12;
    shadow?: Shadow | Elevation_2 | ViewProps;
    infoText?: string;
}

export declare interface CheckboxViewProps extends CheckboxProps {
    isHovered?: boolean;
    setIsHovered?: (hovered: boolean) => void;
    isChecked?: boolean;
    setIsChecked?: (selected: boolean) => void;
    isSelected?: boolean;
    setIsSelected?: (selected: boolean) => void;
}

export declare const CheckIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ChevronIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ClockIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CloseEyeIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CloseIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CloudIcon: default_2.FC<Omit<IconProps, "name">>;

declare type ColorFormat = 'hex' | 'rgb' | 'hsl';

declare type ColorFormat_2 = 'hex' | 'rgb' | 'hsl';

export declare const ColorInput: default_2.FC<ColorInputProps>;

export declare interface ColorInputProps extends Omit<InputProps, 'size' | 'onChange' | 'shadow'> {
    id?: string;
    error?: any;
    helperText?: string;
    name?: string;
    label?: string;
    placeholder?: string;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isAutoFocus?: boolean;
    onChange?: (value: string) => void;
    onBlur?: (value: any) => void;
    onClick?: () => void;
    onFocus?: () => void;
    size?: Size_13;
    shadow?: Shadow | Elevation_2 | ViewProps;
    shape?: Shape_9;
    views?: ColorInputStyles;
    value?: string;
    defaultValue?: string;
    variant?: Variant_11;
    predefinedColors?: PredefinedColor[];
    showCustomInput?: boolean;
    showRecentColors?: boolean;
    colorFormat?: ColorFormat;
    maxRecentColors?: number;
    closeOnSelect?: boolean;
    onChangeComplete?: (color: string) => void;
    onOpen?: () => void;
    onClose?: () => void;
}

declare type ColorInputStyles = {
    text?: ViewProps;
    label?: ViewProps;
    error?: ViewProps;
    helperText?: ViewProps;
    container?: ViewProps;
    trigger?: ViewProps;
    dropdown?: ViewProps;
    colorGrid?: ViewProps;
    colorSwatch?: ViewProps;
    customInput?: ViewProps;
    recentColors?: ViewProps;
};

export declare interface ColorInputViewProps extends ColorInputProps {
    isFocused?: boolean;
    setIsFocused?: Function;
    isHovered?: boolean;
    setIsHovered?: Function;
    value?: string;
    setValue?: Function;
    isOpen?: boolean;
    selectedColor?: string;
    recentColors?: string[];
    customColor?: string;
    handleToggle?: () => void;
    handleColorSelect?: (color: string) => void;
    handleCustomColorChange?: (color: string) => void;
    handleCustomColorSubmit?: () => void;
    handleClose?: () => void;
    triggerRef?: default_2.RefObject<HTMLDivElement | null>;
    dropdownRef?: default_2.RefObject<HTMLDivElement | null>;
}

export declare const ColorPicker: default_2.FC<ColorPickerProps>;

export declare interface ColorPickerProps extends Omit<ViewProps, 'onChange'> {
    id?: string;
    name?: string;
    label?: string;
    placeholder?: string;
    helperText?: string;
    value?: string;
    defaultValue?: string;
    onChange?: (color: string) => void;
    onChangeComplete?: (color: string) => void;
    views?: ColorPickerStyles;
    size?: Size_28;
    shape?: Shape_21;
    variant?: Variant_24;
    error?: boolean;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    predefinedColors?: PredefinedColor_2[];
    showCustomInput?: boolean;
    showRecentColors?: boolean;
    colorFormat?: ColorFormat_2;
    maxRecentColors?: number;
    isOpen?: boolean;
    onOpen?: () => void;
    onClose?: () => void;
    closeOnSelect?: boolean;
    'aria-label'?: string;
    'aria-describedby'?: string;
}

declare type ColorPickerStyles = {
    container?: ViewProps;
    trigger?: ViewProps;
    dropdown?: ViewProps;
    colorGrid?: ViewProps;
    colorSwatch?: ViewProps;
    customInput?: ViewProps;
    recentColors?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
};

export declare interface ColorPickerViewProps extends ColorPickerProps {
    isOpen: boolean;
    selectedColor: string;
    recentColors: string[];
    customColor: string;
    handleToggle: () => void;
    handleColorSelect: (color: string) => void;
    handleCustomColorChange: (color: string) => void;
    handleCustomColorSubmit: () => void;
    handleClose: () => void;
    triggerRef: React.RefObject<HTMLDivElement | null>;
    dropdownRef: React.RefObject<HTMLDivElement | null>;
}

declare interface ColorStop {
    color: string;
    position?: string | number;
}

declare interface Column {
    title: string;
    field: string;
}

export declare const ComboBox: default_2.FC<ComboBoxProps>;

export declare interface ComboBoxItem {
    label: string;
    value: string;
    icon?: ReactNode;
}

export declare interface ComboBoxProps extends Omit<InputProps, 'size' | 'onSelect' | 'left' | 'right'> {
    id: string;
    name?: string;
    items: ComboBoxItem[];
    onSelect?: (item: ComboBoxItem | ComboBoxItem[]) => void;
    searchEnabled?: boolean;
    left?: ReactNode;
    right?: ReactNode;
    label?: string;
    showTick?: boolean;
    placeholder?: string;
    views?: ComboBoxStyles;
    searchPlaceholder?: string;
    isMulti?: boolean;
}

export declare interface ComboBoxStateActions {
    filteredItems: ComboBoxItem[];
    setFilteredItems: Dispatch<SetStateAction<ComboBoxItem[]>>;
    selectedItem: ComboBoxItem;
    setSelectedItem: Dispatch<SetStateAction<ComboBoxItem>>;
    selectedItems: ComboBoxItem[];
    setSelectedItems: Dispatch<SetStateAction<ComboBoxItem[]>>;
    highlightedIndex: number;
    setHighlightedIndex: Dispatch<SetStateAction<number>>;
    searchQuery: string;
    setSearchQuery: Dispatch<SetStateAction<string>>;
    isDropdownVisible: boolean;
    setIsDropdownVisible: Dispatch<SetStateAction<boolean>>;
}

declare type ComboBoxStyles = {
    container?: React.CSSProperties;
    label?: any;
    dropdown?: React.CSSProperties;
    item?: React.CSSProperties;
    labelContainer?: React.CSSProperties;
    text?: any;
};

export declare interface ComboBoxViewProps extends ComboBoxProps, ComboBoxStateActions {
}

export declare const Command: CommandType;

export declare interface CommandEmptyProps {
    children?: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
}

declare interface CommandGroup {
    id: string;
    name: string;
    commands: CommandItem[];
}

export declare interface CommandGroupProps {
    heading: string;
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
        heading?: ViewProps;
    };
}

export declare interface CommandInputProps {
    value: string;
    onValueChange: (value: string) => void;
    placeholder?: string;
    views?: {
        container?: ViewProps;
        input?: ViewProps;
    };
}

declare interface CommandItem {
    id: string;
    name: string;
    description?: string;
    icon?: default_2.ReactNode;
    shortcut?: string;
    onSelect: () => void;
    keywords?: string[];
    disabled?: boolean;
}

export declare interface CommandItemProps {
    item: CommandItem;
    selected?: boolean;
    onSelect?: () => void;
    views?: {
        container?: ViewProps;
        icon?: ViewProps;
        content?: ViewProps;
        name?: ViewProps;
        description?: ViewProps;
        shortcut?: ViewProps;
    };
}

export declare interface CommandListProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
}

export declare interface CommandProps {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    groups?: CommandGroup[];
    commands?: CommandItem[];
    placeholder?: string;
    size?: CommandSize;
    variant?: CommandVariant;
    filter?: (value: string, item: CommandItem) => boolean;
    emptyState?: default_2.ReactNode;
    footer?: default_2.ReactNode;
    views?: CommandStyles;
    [key: string]: any;
}

declare type CommandSize = 'sm' | 'md' | 'lg';

declare interface CommandStyles {
    container?: ViewProps;
    searchInput?: {
        container?: ViewProps;
        input?: ViewProps;
    };
    list?: ViewProps;
    groupHeading?: {
        container?: ViewProps;
        heading?: ViewProps;
    };
    item?: ViewProps;
    selectedItem?: ViewProps;
    icon?: ViewProps;
    content?: ViewProps;
    name?: ViewProps;
    description?: ViewProps;
    shortcut?: ViewProps;
    empty?: {
        container?: ViewProps;
    };
    footer?: ViewProps;
}

export declare interface CommandType extends default_2.FC<CommandProps> {
    Input: default_2.FC<CommandInputProps>;
    List: default_2.FC<CommandListProps>;
    Group: default_2.FC<CommandGroupProps>;
    Item: default_2.FC<CommandItemProps>;
    Empty: default_2.FC<CommandEmptyProps>;
}

declare type CommandVariant = 'default' | 'filled' | 'outline';

export declare interface ContainerProps extends Omit<ViewProps, 'size' | 'position' | 'shadow'> {
    views?: {
        container?: ViewProps;
    };
    children: default_2.ReactNode;
    shape?: Shape_20;
    isFullScreen?: boolean;
    isOpen?: boolean;
    onClose?: () => void;
    isClosePrevented?: boolean;
    blur?: number;
    variant?: string;
    buttonSize?: any;
    buttonColor?: any;
    buttonPosition?: CloseButtonPosition;
    position?: Position_4;
    shadow?: Shadow | Elevation | ViewProps;
}

declare interface ContextElement {
    id: string;
    name: string;
    tagName: string;
    rect?: DOMRect;
}

declare interface ContextElement_2 {
    id: string;
    name: string;
    tagName: string;
    rect: DOMRect;
}

export declare const ContextMenu: ContextMenuType;

export declare interface ContextMenuContentProps extends Omit<ViewProps, 'position'> {
    items?: ContextMenuItem[];
    children?: default_2.ReactNode;
    position?: {
        x: number;
        y: number;
    };
    side?: Position_2;
    align?: Alignment;
    views?: {
        menu?: ViewProps;
        content?: ViewProps;
        item?: ViewProps;
        divider?: ViewProps;
        separator?: ViewProps;
        icon?: ViewProps;
        submenuIndicator?: ViewProps;
    };
}

export declare interface ContextMenuDividerProps {
    views?: {
        divider?: ViewProps;
    };
}

declare interface ContextMenuItem {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    onClick?: () => void;
    disabled?: boolean;
    items?: ContextMenuItem[];
    divider?: boolean;
}

export declare interface ContextMenuItemProps extends Omit<ButtonProps, 'onPress' | 'onClick'> {
    item?: ContextMenuItem;
    children?: default_2.ReactNode;
    onSelect?: (event: default_2.MouseEvent<HTMLButtonElement>) => void;
    isDisabled?: boolean;
    isExternal?: boolean;
    views?: {
        item?: ViewProps;
        icon?: ViewProps;
        submenuIndicator?: ViewProps;
    };
}

export declare interface ContextMenuProps {
    children: default_2.ReactNode;
    items?: ContextMenuItem[];
    size?: Size_6;
    variant?: Variant_6;
    disableNativeContextMenu?: boolean;
    onOpenChange?: (isOpen: boolean) => void;
    views?: ContextMenuStyles;
    [key: string]: any;
}

export declare interface ContextMenuSeparatorProps extends ViewProps {
    views?: {
        separator?: ViewProps;
    };
}

declare interface ContextMenuStyles {
    container?: ViewProps;
    menu?: ViewProps;
    content?: ViewProps;
    item?: ButtonProps & {
        _disabled?: ButtonProps;
    };
    activeItem?: ViewProps;
    divider?: ViewProps;
    separator?: ViewProps;
    icon?: ViewProps;
    submenuIndicator?: ViewProps;
    submenu?: ViewProps;
}

export declare interface ContextMenuTriggerProps {
    children: default_2.ReactNode;
    disableNativeContextMenu?: boolean;
    asChild?: boolean;
    isDisabled?: boolean;
    views?: {
        container?: ViewProps;
    };
}

export declare interface ContextMenuType extends default_2.FC<ContextMenuProps> {
    Trigger: default_2.FC<ContextMenuTriggerProps>;
    Content: default_2.FC<ContextMenuContentProps>;
    Item: default_2.FC<ContextMenuItemProps>;
    Divider: default_2.FC<ContextMenuDividerProps>;
    Separator: default_2.FC<ContextMenuSeparatorProps>;
}

export declare const CookieConsent: default_2.FC<CookieConsentProps>;

declare type CookieConsentPosition = 'bottom' | 'top';

export declare interface CookieConsentProps extends Omit<ViewProps, 'position'> {
    title?: string;
    description?: string | React.ReactNode;
    acceptButtonText?: string;
    customizeButtonText?: string;
    position?: CookieConsentPosition;
    variant?: CookieConsentVariant;
    onAccept?: () => void;
    onCustomize?: () => void;
    views?: CookieConsentStyles;
    showCustomizeButton?: boolean;
    cookieExpiration?: number;
}

declare type CookieConsentStyles = {
    container?: any;
    title?: any;
    description?: any;
    buttonGroup?: any;
    acceptButton?: any;
    customizeButton?: any;
};

declare type CookieConsentVariant = 'default' | 'info' | 'primary';

export declare const CopyIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CountryPicker: default_2.FC<CountryPickerProps>;

export declare interface CountryPickerDropDownProps extends Omit<InputProps, 'size'> {
    size?: Size_14;
    callback?: Function;
    options?: Array<Country>;
    views?: CountryPickerStyles;
}

export declare interface CountryPickerProps extends Omit<InputProps, 'size' | 'shadow' | 'value'> {
    id?: string;
    error?: boolean;
    name?: string;
    label?: string;
    helperText?: string;
    placeholder?: string;
    shape?: Shape_10;
    isAutoFocus?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    onBlur?: (value: any) => void;
    onChange?: (value: any) => void;
    views?: CountryPickerStyles;
    size?: Size_14;
    value?: string;
    variant?: Variant_12;
    shadow?: Shadow | Elevation_2 | ViewProps;
}

export declare interface CountryPickerViewProps extends CountryPickerProps {
    isHovered?: boolean;
    setIsHovered?: (hovered: boolean) => void;
    isFocused?: boolean;
    setIsFocused?: (focused: boolean) => void;
    selected?: string;
    setSelected?: (selected: string) => void;
    hide?: boolean;
    setHide?: (hide: boolean) => void;
    newOptions?: Array<Country>;
    setNewOptions?: (newOptions: Array<Country>) => void;
    value?: string;
    setValue?: Function;
}

export declare const CreditCardIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const CropIcon: default_2.FC<Omit<IconProps, "name">>;

declare interface CustomFormProps<T> extends FormikConfig<T> {
    autoFocus?: boolean;
    initFocus?: string;
}

declare interface CustomFormProps<T> extends FormikConfig<T> {
    autoFocus?: boolean;
    initFocus?: string;
}

/**
 * Date picker allows users to select a date from a calendar view.
 */
export declare const DatePicker: default_2.FC<DatePickerProps>;

export declare interface DatePickerProps extends Omit<ViewProps, 'size' | 'shadow'> {
    id?: string;
    /**
     * Custom icon to display when the DatePicker is checked.
     */
    icon?: default_2.ReactNode;
    /**
     * Indicates whether the DatePicker has an error.
     */
    error?: boolean;
    /**
     * Additional helper text that provides information about the field.
     */
    helperText?: string;
    /**
     * The name of the toggle.
     */
    name?: string;
    /**
     * The color scheme that changes the background color of the DatePicker.
     */
    /**
     * If true, the DatePicker cannot be selected.
     */
    isReadOnly?: boolean;
    /**
     * If true, the DatePicker will be unusable.
     */
    isDisabled?: boolean;
    /**
     * The label text for the  field.
     */
    label?: string;
    /**
     * Callback function triggered when the DatePicker value changes.
     */
    onChange?: (value: any) => void;
    /**
     * Callback function triggered when the DatePicker value changes for IOS and Android.
     */
    onChangeText?: (text: string) => void;
    /**
     * CSS styles for the DatePicker container and label.
     */
    views?: DatePickerStyles;
    /**
     * The shape that changes the outlines of the field.
     */
    shape?: Shape_11;
    /**
     * Changes the style of the  field.
     */
    variant?: Variant_13;
    /**
     * The size that sets the height and width of the DatePicker.
     */
    size?: Size_15;
    /**
     * Adds a shadow effect to the DatePicker.
     */
    shadow?: Shadow | Elevation_2 | ViewProps;
}

export declare interface DatePickerViewProps extends DatePickerProps {
    /**
     * The selected date value as a string.
     */
    date: string;
    /**
     * A function to set the selected date value.
     * @param {string} newDate - The new date value to set.
     */
    setDate: (newDate: string) => void;
    /**
     * Flag indicating if the date picker is currently being hovered.
     */
    isHovered: boolean;
    /**
     * A function to set the hovered state of the date picker.
     * @param {boolean} hovered - The hovered state to set.
     */
    setIsHovered: (hovered: boolean) => void;
    /**
     * Flag indicating if the date picker is currently focused.
     */
    isFocused: boolean;
    /**
     * A function to set the focus state of the date picker.
     * @param {boolean} focused - The focus state to set.
     */
    setIsFocused: (focused: boolean) => void;
}

export declare const deepMerge: <T extends Record<string, any> = Record<string, any>>(...objects: Array<Record<string, any> | undefined>) => T;

export declare const DEFAULT_CHART_COLORS: string[];

export declare const defaultDesignSystemConfig: DesignSystemConfig;

export declare interface DefaultSpinnerProps extends Omit<ViewProps, 'size'> {
    size?: number | Size_3;
    speed?: Speed;
    color?: string;
}

export declare const DeleteIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const DesignSystem: ({ config }: {
    config: DesignSystemConfig;
}) => default_2.JSX.Element;

export declare type DesignSystemAppearance = 'light' | 'dark';

export declare interface DesignSystemColorToken {
    name: string;
    value: string;
    role: string;
}

export declare interface DesignSystemComponentConfig extends Record<string, any> {
    views?: Record<string, DesignSystemViewProps>;
    config?: Record<string, any>;
}

export declare type DesignSystemComponentName = 'accordion' | 'alert' | 'avatar' | 'badge' | 'button' | 'card' | 'checkbox' | 'hero' | 'input' | 'loader' | 'navigation' | 'page' | 'progress' | 'radio' | 'select' | 'separator' | 'slider' | 'status' | 'switch' | 'table' | 'tabs' | 'textarea';

export declare interface DesignSystemConfig {
    metadata: DesignSystemMetadata;
    theme: DesignSystemTheme;
    tokens: DesignSystemTokens;
    components: Partial<Record<DesignSystemComponentName, DesignSystemComponentConfig>>;
    personality?: BrandPersonality;
}

export declare type DesignSystemConfigId = keyof typeof designSystemConfigs;

export declare const designSystemConfigList: DesignSystemConfig[];

export declare const designSystemConfigs: {
    airbnb: DesignSystemConfig;
    apple: DesignSystemConfig;
    coinbase: DesignSystemConfig;
    figma: DesignSystemConfig;
    linear: DesignSystemConfig;
    nike: DesignSystemConfig;
    notion: DesignSystemConfig;
    revolut: DesignSystemConfig;
    shopify: DesignSystemConfig;
    spacex: DesignSystemConfig;
    spotify: DesignSystemConfig;
    stripe: DesignSystemConfig;
    tesla: DesignSystemConfig;
    uber: DesignSystemConfig;
    vercel: DesignSystemConfig;
};

export declare interface DesignSystemContextValue {
    config?: DesignSystemConfig;
    configId?: string;
    isEnabled: boolean;
}

export declare interface DesignSystemMetadata {
    id: string;
    label: string;
    sourcePath: string;
    sourceTitle: string;
    defaultAppearance: DesignSystemAppearance;
    googleFontLinks?: string[];
}

export declare const DesignSystemProvider: default_2.FC<DesignSystemProviderProps>;

export declare interface DesignSystemProviderProps {
    children: ReactNode;
    config?: DesignSystemConfig;
    configId?: DesignSystemConfigId | string;
}

export declare interface DesignSystemTheme {
    primary: string;
    secondary: string;
    success: string;
    warning: string;
    error: string;
    canvas: string;
    surface: string;
    text: string;
    muted: string;
    border: string;
    onPrimary: string;
}

export declare interface DesignSystemTokens {
    rawCssVars: Record<string, string>;
    colors: DesignSystemColorToken[];
    typography: DesignSystemTypographyTokens;
    spacing: string[];
    radii: string[];
    shadows: string[];
}

export declare interface DesignSystemTypographyTokens {
    fontFamily: string;
    monoFamily: string;
    fontSizes: string[];
    fontWeights: string[];
    lineHeights: string[];
}

export declare type DesignSystemViewProps = Record<string, any>;

export declare const Divider: default_2.FC<SeparatorProps>;

export declare const DocumentIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface DottedProps extends Omit<ViewProps, 'size'> {
    size?: number | Size_3;
    speed?: Speed;
    color?: string;
}

export declare const DownloadIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const DragAndDrop: default_2.FC<DragAndDropProps>;

export declare const DragAndDropComponent: default_2.FC<DragAndDropProps>;

declare interface DragAndDropProps {
    items: any[];
    onChange?: (items: any[]) => void;
    renderItem?: (item: any, index: number) => React.ReactNode;
    containerProps?: ViewProps;
    itemProps?: ViewProps;
}

export declare const DragHandleIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const DragHandleLinesIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Drawer: DrawerType;

export declare interface DrawerBodyProps extends ViewProps {
    children?: default_2.ReactNode;
}

export declare interface DrawerContainerProps extends ViewProps {
    placement?: Placement;
    size?: Size_25;
    isOpen?: boolean;
    children?: default_2.ReactNode;
}

export declare interface DrawerFooterProps extends ViewProps {
    children?: default_2.ReactNode;
}

export declare interface DrawerHeaderProps extends ViewProps {
    onClose?: () => void;
    buttonPosition?: CloseButtonPosition_2;
    children?: default_2.ReactNode;
}

export declare interface DrawerItem {
    name: string;
    props: any & {
        isOpen: boolean;
    };
    overlayProps: any;
}

export declare interface DrawerLayoutProps extends ViewProps {
    drawers: {
        [key: string]: default_2.ComponentType<any>;
    };
    onShow?: (name: string, props?: any) => void;
    onHide?: (name?: string) => void;
}

export declare interface DrawerOverlayProps extends ViewProps {
    isOpen: boolean;
    onClose: () => void;
    isClosePrevented?: boolean;
    blur?: number;
    children?: default_2.ReactNode;
}

export declare interface DrawerProps extends ViewProps {
    placement?: Placement;
    side?: string;
    size?: Size_25;
    isOpen: boolean;
    onClose: () => void;
    isClosePrevented?: boolean;
    children?: default_2.ReactNode;
}

export declare interface DrawerState {
    drawers: DrawerItem[];
    show: (name: string, drawerProps?: any, overlayProps?: any) => void;
    hide: (name?: string) => void;
    onShow: (name: string, props?: any) => void;
    onHide: (name?: string) => void;
    setOnShow: (onShow: (name: string, props?: any) => void) => void;
    setOnHide: (onHide: (name?: string) => void) => void;
}

export declare interface DrawerType extends default_2.FC<DrawerProps> {
    Overlay: default_2.FC<DrawerOverlayProps>;
    Container: default_2.FC<DrawerContainerProps>;
    Header: default_2.FC<DrawerHeaderProps>;
    Body: default_2.FC<DrawerBodyProps>;
    Footer: default_2.FC<DrawerFooterProps>;
    Layout: default_2.FC<DrawerLayoutProps>;
}

export declare interface DropDownItemProps extends Omit<InputProps, 'size'> {
    callback?: Function;
    option?: string;
    size?: Size_14;
    views?: CountryPickerStyles;
}

export declare const DropdownMenu: DropdownMenuType;

export declare interface DropdownMenuContentProps {
    items: DropdownMenuItem[];
    side?: Position_5;
    align?: Alignment_2;
    views?: {
        menu?: ViewProps;
        item?: ViewProps;
        divider?: ViewProps;
        icon?: ViewProps;
        submenuIndicator?: ViewProps;
    };
}

export declare interface DropdownMenuDividerProps {
    views?: {
        divider?: ViewProps;
    };
}

declare interface DropdownMenuItem {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    onClick?: () => void;
    disabled?: boolean;
    items?: DropdownMenuItem[];
    divider?: boolean;
}

export declare interface DropdownMenuItemProps {
    item: DropdownMenuItem;
    views?: {
        item?: ViewProps;
        icon?: ViewProps;
        submenuIndicator?: ViewProps;
    };
}

export declare interface DropdownMenuProps {
    trigger: default_2.ReactNode;
    items: DropdownMenuItem[];
    size?: Size_27;
    variant?: Variant_23;
    side?: Position_5;
    align?: Alignment_2;
    defaultOpen?: boolean;
    views?: DropdownMenuStyles;
    [key: string]: any;
}

declare interface DropdownMenuStyles {
    container?: ViewProps;
    trigger?: ViewProps;
    menu?: ViewProps;
    item?: ViewProps;
    activeItem?: ViewProps;
    divider?: ViewProps;
    icon?: ViewProps;
    submenuIndicator?: ViewProps;
    submenu?: ViewProps;
}

export declare interface DropdownMenuTriggerProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
}

export declare interface DropdownMenuType extends default_2.FC<DropdownMenuProps> {
    Trigger: default_2.FC<DropdownMenuTriggerProps>;
    Content: default_2.FC<DropdownMenuContentProps>;
    Item: default_2.FC<DropdownMenuItemProps>;
    Divider: default_2.FC<DropdownMenuDividerProps>;
}

export declare interface DropDownProps extends Omit<InputProps, 'size'> {
    size?: Size_7;
    callback?: Function;
    options: Option_2[];
    views?: SelectStyles;
    highlightedIndex?: number;
    setHighlightedIndex?: Function;
}

export declare const DropZone: default_2.FC<DropZoneProps>;

export declare interface DropZoneProps extends UseUploadProps {
    children?: React.ReactNode;
    containerProps?: ViewProps;
    text?: string;
    textProps?: TextProps;
    className?: string;
    disabled?: boolean;
    imageProps?: ImageProps;
    previewUrl?: string | null;
    selectedFiles?: File[];
    onRemove?: (index: number) => void;
}

export declare interface DropZoneStateProps {
    isDragActive: boolean;
    handleDragEnter: (e: React.DragEvent<HTMLDivElement>) => void;
    handleDragLeave: (e: React.DragEvent<HTMLDivElement>) => void;
    handleDragOver: (e: React.DragEvent<HTMLDivElement>) => void;
    handleDrop: (e: React.DragEvent<HTMLDivElement>) => void;
    handleClick: () => void;
    handleFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
    inputRef: React.RefObject<HTMLInputElement | null>;
    preview: string | null;
}

export declare const DustBinIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const EditIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Elevation_3 = 'none' | 'low' | 'medium' | 'high';

declare type Emoji = {
    emoji: string;
    name: string;
    category: EmojiCategory;
    keywords: string[];
    skinTones?: string[];
};

declare type EmojiCategory = 'recent' | 'smileys' | 'people' | 'animals' | 'food' | 'activities' | 'travel' | 'objects' | 'symbols' | 'flags';

export declare const EmojiPicker: default_2.FC<EmojiPickerProps>;

export declare interface EmojiPickerProps extends Omit<ViewProps, 'onChange'> {
    id?: string;
    name?: string;
    label?: string;
    placeholder?: string;
    helperText?: string;
    value?: string;
    defaultValue?: string;
    onChange?: (emoji: string) => void;
    onEmojiSelect?: (emoji: Emoji) => void;
    views?: EmojiPickerStyles;
    size?: Size_22;
    shape?: Shape_19;
    variant?: Variant_21;
    error?: boolean;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    showSearch?: boolean;
    showCategories?: boolean;
    showRecentEmojis?: boolean;
    maxRecentEmojis?: number;
    enabledCategories?: EmojiCategory[];
    customEmojis?: Emoji[];
    isOpen?: boolean;
    onOpen?: () => void;
    onClose?: () => void;
    closeOnSelect?: boolean;
    'aria-label'?: string;
    'aria-describedby'?: string;
}

declare type EmojiPickerStyles = {
    container?: ViewProps;
    trigger?: ViewProps;
    dropdown?: ViewProps;
    searchInput?: ViewProps;
    categoryTabs?: ViewProps;
    categoryTab?: ViewProps;
    emojiGrid?: ViewProps;
    emoji?: ViewProps;
    recentEmojis?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
};

export declare interface EmojiPickerViewProps extends EmojiPickerProps {
    isOpen: boolean;
    selectedEmoji: string;
    recentEmojis: Emoji[];
    searchQuery: string;
    activeCategory: EmojiCategory;
    filteredEmojis: Emoji[];
    handleToggle: () => void;
    handleEmojiSelect: (emoji: Emoji) => void;
    handleSearchChange: (query: string) => void;
    handleCategoryChange: (category: EmojiCategory) => void;
    handleClose: () => void;
    triggerRef: React.RefObject<HTMLDivElement | null>;
    dropdownRef: React.RefObject<HTMLDivElement | null>;
}

export declare const ErrorIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ExternalLinkIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const FacebookIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const FileIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const FileImage: ({ path, ...props }: {
    path: string;
} & ImageProps) => default_2.JSX.Element;

export declare interface FileProps extends ViewProps {
    src: string;
    color?: string;
    views?: {
        container?: ViewProps;
        image?: ImageProps;
    };
}

export declare const FileSVG: ({ src, color, views, themeMode: elementMode, ...props }: FileProps) => default_2.JSX.Element;

export declare const FilterIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const FolderIcon: default_2.FC<Omit<IconProps, "name">>;

declare interface FooterCell {
    value: string;
    props?: ViewProps;
}

export declare interface FooterProps extends ViewProps {
    views?: {
        container?: ViewProps;
    };
}

/**
 * ChatInput is a component used to create a chat input field with file upload support,
 * auto-completion, mentions, and other advanced features, integrated with Formik.
 */
export declare const FormikChatInput: default_2.FC<FormikChatInputProps>;

declare interface FormikChatInputProps extends Omit<ChatInputProps, 'value' | 'onChange' | 'onSubmit' | 'getPendingFiles' | 'clearPendingFiles'> {
    name: string;
    onSubmit?: (message: string, options?: any) => void;
}

/**
 * Checkbox allows users to select one or more options from a list of choices.
 */
export declare const FormikCheckbox: default_2.FC<CheckboxProps>;

/**
 * Color input allows users to select a color from a predefined palette or enter a custom color-
 */
export declare const FormikColorInput: default_2.FC<ColorInputProps>;

/**
 * ComboBox allows users to select one or more options from a list of choices.
 */
export declare const FormikComboBox: default_2.FC<ComboBoxProps>;

/**
 * Country picker allows users to select a country from a dropdown list or search field.
 */
export declare const FormikCountryPicker: default_2.FC<CountryPickerProps>;

/**
 * Date picker allows users to select a date from a calendar view.
 */
export declare const FormikDatePicker: default_2.FC<DatePickerProps>;

/**
 * EmojiPicker allows users to select an emoji from a list with Formik integration.
 */
export declare const FormikEmojiPicker: default_2.FC<EmojiPickerProps>;

export declare const FormikForm: <T extends {}>({ children, autoFocus, initFocus, onChange, ...props }: CustomFormProps<T> & any) => default_2.JSX.Element;

/**
 * IconPicker allows users to select an icon from a list with Formik integration.
 */
export declare const FormikIconPicker: default_2.FC<IconPickerProps>;

/**
 * OTPInput component for entering one-time passwords or verification codes with Formik integration.
 * Provides multiple input fields for entering digits with auto-focus functionality.
 * Supports step-based input and improved accessibility.
 */
export declare const FormikOTPInput: default_2.FC<OTPInputProps>;

/**
 * To allow users to securely enter sensitive information
 */
export declare const FormikPassword: default_2.FC<PasswordProps>;

/**
 * Radio allows users to select one option from a set of choices with Formik integration.
 */
export declare const FormikRadio: default_2.FC<RadioProps>;

/**
 * Select provides a dropdown list of options for the user to choose from.
 */
export declare const FormikSelect: default_2.FC<SelectProps>;

/**
 * Selector provides a dropdown list of options for the user to choose from.
 */
export declare const FormikSelector: default_2.FC<SelectorProps>;

/**
 * Slider component integrated with Formik for form state management.
 * Allows users to select a value from a range by moving a handle.
 */
export declare const FormikSlider: default_2.FC<SliderProps>;

export declare const FormikSwitch: default_2.FC<SwitchProps>;

/**
 * TagInput allows users to add and manage a list of tags.
 * Integrated with Formik for form validation and state management.
 */
export declare const FormikTagInput: default_2.FC<TagInputProps & {
    name: string;
}>;

/**
 * Text Area is an component used to create a multi-line input field.
 */
export declare const FormikTextArea: default_2.FC<TextAreaProps>;

/**
 * TextField is used to capture text data from users.
 */
export declare const FormikTextField: default_2.FC<TextFieldProps>;

/**
 * Toggle allows users to switch between two states with Formik integration.
 */
export declare const FormikToggle: default_2.FC<ToggleProps>;

/**
 * ToggleGroup allows users to select multiple options from a group with Formik integration.
 */
export declare const FormikToggleGroup: default_2.FC<ToggleGroupProps>;

export declare const FormikUploader: default_2.FC<FormikUploaderProps>;

declare interface FormikUploaderProps extends Omit<UploadProps, 'onFileSelect' | 'onMultipleFileSelect' | 'isLoading' | 'progress'> {
    /**
     * Name of the field that will receive the uploaded file responses
     */
    name: string;
    /**
     * Custom upload handler. Defaults to the platform UploadService
     */
    uploadFile: UploadFileHandler;
    /**
     * Callback fired when a single file upload succeeds
     */
    onUploadSuccess?: (file: File, response: any) => void;
    /**
     * Callback fired when a single file upload fails
     */
    onUploadError?: (file: File, error: unknown) => void;
    /**
     * Transform the raw upload response before storing it in the form state
     */
    transformResponse?: (response: any, file: File) => any;
    /**
     * Optional external handler mirroring the Uploader prop
     */
    onMultipleFileSelect?: (files: File[]) => void;
    /**
     * Optional external handler mirroring the Uploader prop for single upload mode
     */
    onFileSelect?: (file: File) => void;
    /**
     * Enable/disable multiple uploads. Defaults to true
     */
    multiple?: boolean;
}

export declare const getDesignSystemComponentProps: (componentName: DesignSystemComponentName, config?: DesignSystemConfig) => DesignSystemComponentConfig;

export declare const GiftIcon: default_2.FC<Omit<IconProps, "name">>;

declare interface GradientProps extends Omit<ViewProps, 'colors' | 'animate' | 'animationDuration' | 'direction' | 'position'> {
    type?: GradientType;
    direction?: LinearDirection;
    shape?: RadialShape;
    position?: RadialPosition;
    from?: string;
    to?: string;
    colors?: ColorStop[];
    animate?: boolean;
    animationDuration?: number;
    children?: React.ReactNode;
    views?: GradientStyles;
}

declare interface GradientStyles {
    container?: ViewProps;
    content?: ViewProps;
}

declare type GradientType = 'linear' | 'radial' | 'conic';

export declare interface GridProps extends ViewProps {
    gridSize?: number;
    lineColor?: string;
    pulseColor?: string;
    animationSpeed?: 'slow' | 'medium' | 'fast';
}

declare type HandlePosition = 'start' | 'end' | 'both';

export declare interface HeaderProps extends Omit<ViewProps, 'size'> {
    views?: {
        container?: ViewProps;
        header?: ViewProps;
    };
    buttonColor?: string;
    iconSize?: Size_24;
    children?: default_2.ReactNode;
    buttonPosition?: CloseButtonPosition;
    buttonSize?: any;
    variant?: string;
    onClose?: () => void;
}

export declare const HeartIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const HelpIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface HiddenSelectProps extends Omit<InputProps, 'size' | 'value'> {
    id?: string;
    name?: string;
    value: string | Array<string>;
    isMulti?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    onChange?: (value: any) => void;
    options: Option_2[];
}

export declare const hideDrawer: (name?: string) => void;

export declare const hideMessage: () => void;

export declare const hideModal: (name?: string) => void;

declare type HighlightStyle = 'underline' | 'background' | 'gradient' | 'outline' | 'glow' | 'solid' | 'default';

export declare const HomeIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const HoverCard: HoverCardType;

export declare interface HoverCardContentProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
    side?: 'top' | 'right' | 'bottom' | 'left';
    align?: 'start' | 'center' | 'end';
    sideOffset?: number;
    [key: string]: any;
}

export declare interface HoverCardProps {
    children?: default_2.ReactNode;
    views?: {
        container?: ViewProps;
        content?: ViewProps;
    };
    openDelay?: number;
    closeDelay?: number;
}

export declare interface HoverCardTriggerProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
    asChild?: boolean;
    [key: string]: any;
}

export declare interface HoverCardType extends default_2.FC<HoverCardProps> {
    Trigger: default_2.FC<HoverCardTriggerProps>;
    Content: default_2.FC<HoverCardContentProps>;
}

export declare const Icon: default_2.FC<IconProps>;

export declare type IconName = keyof typeof default_3;

export declare const IconPicker: default_2.FC<IconPickerProps>;

export declare interface IconPickerProps extends Omit<ViewProps, 'onChange'> {
    id?: string;
    name?: string;
    label?: string;
    placeholder?: string;
    helperText?: string;
    value?: IconName;
    defaultValue?: IconName;
    onChange?: (iconName: IconName) => void;
    views?: IconPickerStyles;
    size?: Size_21;
    shape?: Shape_18;
    variant?: Variant_20;
    error?: boolean;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    showSearch?: boolean;
    isOpen?: boolean;
    onOpen?: () => void;
    onClose?: () => void;
    closeOnSelect?: boolean;
}

declare type IconPickerStyles = {
    container?: ViewProps;
    trigger?: ViewProps;
    dropdown?: ViewProps;
    searchInput?: ViewProps;
    iconGrid?: ViewProps;
    iconItem?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
};

export declare interface IconPickerViewProps extends IconPickerProps {
    isOpen: boolean;
    selectedIcon?: IconName;
    searchQuery: string;
    filteredIcons: IconName[];
    handleToggle: () => void;
    handleIconSelect: (iconName: IconName) => void;
    handleSearchChange: (query: string) => void;
    handleClose: () => void;
    triggerRef: React.RefObject<HTMLDivElement | null>;
    dropdownRef: React.RefObject<HTMLDivElement | null>;
}

export declare interface IconProps extends Omit<ViewProps, 'orientation' | 'name' | 'size'> {
    color?: string;
    filled?: boolean;
    orientation?: 'left' | 'right' | 'up' | 'down';
    name?: IconName;
    strokeWidth?: number | string;
    size?: number | string;
    fallback?: default_2.ReactNode;
}

export declare const ImageIcon: default_2.FC<Omit<IconProps, "name">>;

declare type IndicatorPosition = 'top' | 'bottom';

declare type IndicatorVariant = 'dot' | 'line' | 'number';

export declare const InfoIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const InstagramIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface ItemProps extends Omit<InputProps, 'size'> {
    callback?: Function;
    option: Option_2;
    size?: Size_7;
    style?: SelectStyles;
    isHovered?: boolean;
    setIsHovered?: Function;
}

export declare const LayoutIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const LikeIcon: default_2.FC<Omit<IconProps, "name">>;

declare type LinearDirection = 'to-right' | 'to-left' | 'to-bottom' | 'to-top' | 'to-top-right' | 'to-top-left' | 'to-bottom-right' | 'to-bottom-left' | string;

export declare const Link: default_2.ForwardRefExoticComponent<LinkProps & default_2.RefAttributes<HTMLAnchorElement>>;

export declare const LinkedinIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const LinkIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface LinkProps extends Omit<ViewProps, 'size'> {
    children: default_2.ReactNode;
    underline?: TextDecorationStyle;
    isExternal?: boolean;
    iconSize?: Size_23;
    to: string;
    views?: Styles;
}

export declare interface LinkViewProps extends LinkProps {
    isHovered: boolean;
    setIsHovered: Function;
}

export declare const Loader: default_2.FC<LoaderProps>;

export declare interface LoaderProps extends Omit<ViewProps, 'size'> {
    children?: default_2.ReactNode;
    loaderColor?: string;
    type?: LoaderType;
    textColor?: string;
    textPosition?: TextPosition;
    size?: number | Size_3;
    speed?: Speed;
}

export declare const LoadingSpinnerIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const LockIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const LogoutIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const MagicWandIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const MapPinIcon: default_2.FC<Omit<IconProps, "name">>;

/**
 * MediaPreview renders a square thumbnail for image, video or audio files.
 * It falls back to a file icon for unsupported types. Clicking the preview
 * opens the original file unless the user interacts with playback controls.
 */
export declare const MediaPreview: default_2.FC<MediaPreviewProps>;

export declare interface MediaPreviewProps {
    url: string;
    type: string;
    name?: string;
    onOpen?: () => void;
}

export declare const Menubar: MenubarType;

export declare interface MenubarContentProps {
    children: default_2.ReactNode;
    menuId: string;
    views?: {
        content?: ViewProps;
    };
}

declare interface MenubarItem {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    items?: MenubarItem[];
    disabled?: boolean;
    onClick?: () => void;
    separator?: boolean;
}

export declare interface MenubarItemProps {
    children: default_2.ReactNode;
    id: string;
    icon?: default_2.ReactNode;
    disabled?: boolean;
    onClick?: () => void;
    views?: {
        item?: ViewProps;
        icon?: ViewProps;
    };
}

export declare interface MenubarMenuProps {
    children: default_2.ReactNode;
    id: string;
    disabled?: boolean;
    views?: {
        menu?: ViewProps;
    };
}

export declare interface MenubarProps {
    items: MenubarItem[];
    orientation?: Orientation_3;
    size?: Size_29;
    variant?: Variant_25;
    defaultActiveMenuId?: string | null;
    defaultOpenMenuId?: string | null;
    views?: MenubarStyles;
    [key: string]: any;
}

export declare interface MenubarRootProps {
    children: default_2.ReactNode;
    orientation?: Orientation_3;
    size?: Size_29;
    variant?: Variant_25;
    views?: {
        container?: ViewProps;
    };
    [key: string]: any;
}

export declare interface MenubarSeparatorProps {
    views?: {
        separator?: ViewProps;
    };
}

declare interface MenubarStyles {
    container?: ViewProps;
    menu?: ViewProps;
    trigger?: ViewProps;
    content?: ViewProps;
    item?: ViewProps;
    activeItem?: ViewProps;
    separator?: ViewProps;
    icon?: ViewProps;
}

export declare interface MenubarTriggerProps {
    children: default_2.ReactNode;
    menuId: string;
    disabled?: boolean;
    views?: {
        trigger?: ViewProps;
        icon?: ViewProps;
    };
}

export declare interface MenubarType extends default_2.FC<MenubarProps> {
    Root: default_2.FC<MenubarRootProps>;
    Menu: default_2.FC<MenubarMenuProps>;
    Trigger: default_2.FC<MenubarTriggerProps>;
    Content: default_2.FC<MenubarContentProps>;
    Item: default_2.FC<MenubarItemProps>;
    Separator: default_2.FC<MenubarSeparatorProps>;
}

export declare const MenuIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const mergeDesignSystemComponentProps: <T extends Record<string, any>>(componentName: DesignSystemComponentName, props: T, config?: DesignSystemConfig) => T;

declare interface Message {
    id: string;
    role: MessageRole;
    content: string;
    reasoning?: string;
    messageType?: MessageType_2;
    timestamp: Date;
    attachments?: Attachment[];
    contextElements?: ContextElement[];
}

export declare const MessageLayout: ({ container, theme, position, }: MessageLayoutProps) => default_2.JSX.Element | null;

export declare interface MessageLayoutProps {
    icons?: {
        [x: string]: string;
    };
    container?: any;
    theme?: ThemesType;
    position?: Position_3;
}

export declare interface MessageProps extends ShowMessageProps {
    subtitle?: string;
    variant: MessageType;
    show?: boolean;
    hide: Function;
    title: string;
    theme?: ThemesType;
}

declare type MessageRole = 'user' | 'assistant';

export declare interface MessageState {
    visible: boolean;
    variant: MessageType;
    title: string;
    subtitle: string;
    isClosable?: boolean;
    views?: MessageViewStyles;
    action?: Function;
    actionText?: string;
    showIcon?: boolean;
    timeout?: number;
    show: (variant: MessageType, title?: string, subtitle?: string, isClosable?: boolean, views?: MessageViewStyles, action?: Function, actionText?: string, showIcon?: boolean, timeout?: number) => void;
    hide: () => void;
}

export declare type MessageType = 'info' | 'warning' | 'error' | 'success';

declare type MessageType_2 = 'text' | 'error' | 'system' | 'tool';

export declare const MessageView: ({ variant, hide, title, subtitle, theme, action, actionText, showIcon, isClosable, timeout, views, }: MessageProps) => default_2.JSX.Element;

declare type MessageViewStyles = {
    container?: ViewProps;
    title?: ViewProps;
    subtitle?: ViewProps;
    icon?: ViewProps;
    actionText?: ViewProps;
    closingIcon?: {
        container?: ViewProps;
        icon?: ViewProps;
    };
};

export declare interface MeteorsProps extends ViewProps {
    number?: number;
    children?: ReactNode;
}

export declare const MicrophoneIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const MinusIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Modal: ModalType;

export declare interface ModalItem {
    name: string;
    props: any & {
        isVisible: boolean;
    };
    overlayProps: any;
}

export declare interface ModalLayoutProps {
    modals: {
        [x: string]: default_2.FC<any>;
    };
    onShow?: (name: string, props?: any) => void;
    onHide?: (name?: string, props?: any) => void;
}

export declare interface ModalProps extends Omit<ViewProps, 'size' | 'shadow' | 'position'> {
    buttonColor?: string;
    iconSize?: Size_24;
    shape?: Shape_20;
    isFullScreen?: boolean;
    buttonPosition?: CloseButtonPosition;
    onClose?: () => void;
    blur?: number;
    isOpen?: boolean;
    isClosePrevented?: boolean;
    position?: Position_4;
    shadow?: Shadow | Elevation | ViewProps;
    id?: string;
    title?: string;
    render?: (ctx: any) => default_2.ReactNode;
}

export declare interface ModalState {
    modals: ModalItem[];
    show: (name: string, modalProps?: any, overlayProps?: any) => void;
    hide: (name?: string) => void;
    onShow: (name: string, props?: any) => void;
    onHide: (name?: string) => void;
    setOnShow: (onShow: (name: string, props?: any) => void) => void;
    setOnHide: (onHide: (name?: string) => void) => void;
}

export declare interface ModalType extends default_2.FunctionComponent<ModalProps> {
    Overlay: default_2.FC<OverlayProps>;
    Container: default_2.FC<ContainerProps>;
    Header: default_2.FC<HeaderProps>;
    Body: default_2.FC<BodyProps>;
    Footer: default_2.FC<FooterProps>;
    Layout: default_2.FC<ModalLayoutProps>;
}

/**
 * Model option interface
 */
declare interface ModelOption {
    id: string;
    name: string;
    description?: string;
    isThinking?: boolean;
}

export declare const MoonIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const MoreIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const MousePointerIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface MultiSelectProps extends Omit<InputProps, 'size'> {
    option: string;
    removeOption: Function;
    size?: Size_7;
}

declare interface NavigationItem {
    id: string;
    label: string;
    icon?: default_2.ReactNode;
    href?: string;
    items?: NavigationItem[];
    disabled?: boolean;
}

export declare const NavigationMenu: NavigationMenuType;

export declare interface NavigationMenuContentProps {
    children: default_2.ReactNode;
    itemId: string;
    views?: {
        container?: ViewProps;
    };
}

export declare interface NavigationMenuItemProps {
    item?: NavigationItem;
    value?: string;
    isDisabled?: boolean;
    children?: default_2.ReactNode;
    views?: {
        item?: ViewProps;
        trigger?: ViewProps;
        content?: ViewProps;
        icon?: ViewProps;
        indicator?: ViewProps;
    };
}

export declare interface NavigationMenuLinkProps extends Omit<LinkProps, 'to'> {
    href?: string;
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
        icon?: ViewProps;
    };
}

export declare interface NavigationMenuListProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
}

export declare interface NavigationMenuProps {
    items?: NavigationItem[];
    children?: default_2.ReactNode;
    orientation?: Orientation_2;
    size?: Size_26;
    variant?: Variant_22;
    defaultActiveItemId?: string;
    defaultExpandedItemIds?: string[];
    onItemActivate?: (itemId: string) => void;
    views?: NavigationMenuStyles;
    [key: string]: any;
}

declare interface NavigationMenuStyles {
    container?: ViewProps;
    list?: ViewProps;
    item?: ViewProps;
    activeItem?: ViewProps;
    content?: ViewProps;
    trigger?: ViewProps;
    icon?: ViewProps;
    indicator?: ViewProps;
}

export declare interface NavigationMenuTriggerProps {
    children: default_2.ReactNode | default_2.ReactElement;
    itemId: string;
    disabled?: boolean;
    views?: {
        container?: ViewProps;
        icon?: ViewProps;
        trigger?: ViewProps;
        indicator?: ViewProps;
    };
}

export declare interface NavigationMenuType extends default_2.FC<NavigationMenuProps> {
    List: default_2.FC<NavigationMenuListProps>;
    Item: default_2.FC<NavigationMenuItemProps>;
    Trigger: default_2.FC<NavigationMenuTriggerProps>;
    Content: default_2.FC<NavigationMenuContentProps>;
    Link: default_2.FC<NavigationMenuLinkProps>;
}

declare type NavigationPosition = 'inside' | 'outside';

export declare type NavigatorShareData = Parameters<Navigator['share']>[0];

export declare const normalizeDesignSystemComponentProps: <T extends Record<string, any>>(props: T) => T;

export declare const NotificationIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const OpenEyeIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Orientation = 'horizontal' | 'vertical';

declare type Orientation_2 = 'horizontal' | 'vertical';

declare type Orientation_3 = 'horizontal' | 'vertical';

declare type Orientation_4 = 'horizontal' | 'vertical';

declare type Orientation_5 = 'horizontal' | 'vertical';

export declare const OTPInput: default_2.FC<OTPInputProps>;

export declare interface OTPInputProps extends Omit<InputProps, 'size' | 'onChange' | 'pattern' | 'shadow'> {
    id?: string;
    error?: any;
    helperText?: string;
    name?: string;
    label?: string;
    length?: number;
    placeholder?: string;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isAutoFocus?: boolean;
    type?: OTPInputType;
    onComplete?: (value: string) => void;
    onChange?: (value: string) => void;
    onChangeText?: (value: string) => void;
    onBlur?: (value: any) => void;
    onKeyPress?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
    onClick?: () => void;
    onFocus?: () => void;
    pattern?: RegExp | string;
    pasteTransformer?: (pasted: string) => string;
    stepValues?: number[];
    size?: Size_17;
    shadow?: Shadow | Elevation | ViewProps;
    shape?: Shape_13;
    variant?: Variant_15;
    gap?: number;
    views?: OTPInputStyles;
    secureTextEntry?: boolean;
}

declare type OTPInputStyles = {
    input?: ViewProps;
    container?: ViewProps;
    text?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
};

declare type OTPInputType = 'text' | 'password' | 'number';

export declare interface OTPInputViewProps extends OTPInputProps {
    value: string;
    isFocused: boolean;
    isHovered: boolean;
    setValue: (value: string) => void;
    setIsFocused: (isFocused: boolean) => void;
    setIsHovered: (isHovered: boolean) => void;
    isFirstColumn?: boolean;
}

export declare interface OverlayProps extends Omit<ViewProps, 'position' | 'isOpen'> {
    children?: default_2.ReactNode;
    blur?: number;
    isOpen: boolean;
    isClosePrevented?: boolean;
    position?: Position_4;
    isFullScreen?: boolean;
    onClose: () => void;
}

declare interface PageSizeOption {
    label: string;
    value: number;
}

export declare const Pagination: default_2.FC<PaginationProps>;

export declare interface PaginationProps extends ViewProps {
    currentPage: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    pageSize?: number;
    pageSizeOptions?: PageSizeOption[];
    onPageSizeChange?: (pageSize: number) => void;
    showPageSizeSelector?: boolean;
    showPageInfo?: boolean;
    maxPageButtons?: number;
    showFirstLastButtons?: boolean;
    size?: Size_30;
    variant?: Variant_26;
    shape?: Shape_22;
    views?: PaginationStyles;
    visiblePageNumbers?: (number | string)[];
}

declare interface PaginationStyles {
    container?: ViewProps;
    pageButton?: ViewProps;
    activePageButton?: ViewProps;
    navigationButton?: ViewProps;
    pageInfo?: ViewProps;
    pageSizeSelector?: ViewProps;
    ellipsis?: ViewProps;
}

export declare const PanelIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface ParticlesProps extends Omit<ViewProps, 'colors'> {
    count?: number;
    colors?: string[];
    speed?: 'slow' | 'medium' | 'fast';
    shapes?: ('circle' | 'square' | 'triangle')[];
}

/**
 * To allow users to securely enter sensitive information
 */
export declare const Password: default_2.FC<PasswordProps>;

/**
 * TextFieldProps already extends Omit<InputProps, ...>, so a second extend of
 * Omit<InputProps, ...> would conflict on every property TextField narrowed
 * (error, helperText, label, left, right, onBlur, onChange, onClick, onFocus,
 * shadow, value). The Password component is a TextField with a visibility
 * toggle — extend TextFieldProps alone.
 */
export declare interface PasswordProps extends TextFieldProps {
    /**
     * The name of the input field
     */
    name?: string;
    /**
     * If true, the Input will be unusable
     */
    isDisabled?: boolean;
    /**
     * Icon to Indicate that the password is visible
     */
    visibleIcon?: default_2.ReactNode;
    /**
     * Icon to Indicate that the password is hidden
     */
    hiddenIcon?: default_2.ReactNode;
}

export declare interface PasswordViewProps extends PasswordProps {
    /**
     * Optional prop to determine if the password is visible
     */
    isVisible?: boolean;
    /**
     * Optional callback to update the visibility state.
     */
    setIsVisible?: (value: boolean) => void;
}

export declare const PauseIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const PlayIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const PlusIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Position = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';

declare type Position_2 = 'top' | 'right' | 'bottom' | 'left';

declare type Position_3 = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';

declare type Position_5 = 'top' | 'right' | 'bottom' | 'left';

declare type Position_6 = 'left' | 'right';

declare type Position_7 = 'top' | 'right' | 'bottom' | 'left';

export declare const PowerOffIcon: default_2.FC<Omit<IconProps, "name">>;

declare type PredefinedColor = {
    name: string;
    value: string;
    category?: string;
};

declare type PredefinedColor_2 = {
    name: string;
    value: string;
    category?: string;
};

export declare const PrintIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ProfileIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ProgressBar: default_2.FC<ProgressBarProps>;

export declare interface ProgressBarProps extends ViewProps {
    shape?: 'linear' | 'circle';
    value?: number;
    max?: number;
    color?: string;
    backgroundColor?: string;
    height?: number | string;
    size?: number;
    radius?: number | string;
    strokeWidth?: number;
    showLabel?: boolean;
    labelColor?: string;
    animated?: boolean;
    animationDuration?: string;
    views?: ProgressBarStyles;
}

export declare interface ProgressBarStyles {
    container?: ViewProps;
    bar?: ViewProps;
    track?: React.SVGAttributes<SVGCircleElement>;
    indicator?: React.SVGAttributes<SVGCircleElement>;
    text?: ViewProps;
}

/**
 * Prompt example interface
 */
declare interface PromptExample {
    id: string | number;
    text: string;
}

export declare interface QuarterProps extends Omit<ViewProps, 'size'> {
    size?: number | Size_3;
    speed?: Speed;
    color?: string;
}

declare type RadialPosition = 'center' | 'top' | 'right' | 'bottom' | 'left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | string;

declare type RadialShape = 'circle' | 'ellipse';

declare interface RadioProps extends Omit<InputProps, 'size' | 'onChange' | 'shadow'> {
    id?: string;
    icon?: default_2.ReactNode;
    error?: any;
    name?: string;
    label?: string;
    value?: string;
    isChecked?: boolean;
    defaultIsSelected?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    labelPosition?: 'left' | 'right';
    onChange?: Function;
    onValueChange?: Function;
    views?: RadioStyles;
    size?: Size_18;
    shadow?: Shadow | Elevation_2 | ViewProps;
    infoText?: string;
}

export declare const RefreshIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Resizable: ResizableType;

export declare interface ResizableHandleProps {
    id: string;
    position?: HandlePosition;
    disabled?: boolean;
    withVisualIndicator?: boolean;
    withCollapseButton?: boolean;
    collapseTarget?: string;
    views?: {
        handle?: ViewProps;
        handleIcon?: ViewProps;
        collapseIcon?: ViewProps;
    };
    [key: string]: any;
}

export declare interface ResizablePanelProps {
    children: default_2.ReactNode;
    id: string;
    defaultSize?: number | string;
    minSize?: number;
    maxSize?: number;
    collapsible?: boolean;
    defaultCollapsed?: boolean;
    onCollapseChange?: (collapsed: boolean) => void;
    views?: {
        panel?: ViewProps;
        collapsedPanel?: ViewProps;
    };
    [key: string]: any;
}

export declare interface ResizableProps {
    children: default_2.ReactNode;
    orientation?: Orientation_5;
    size?: Size_32;
    variant?: Variant_29;
    defaultSizes?: (number | string)[];
    onSizesChange?: (sizes: number[]) => void;
    minSize?: number;
    maxSize?: number;
    collapsible?: boolean;
    autoSaveId?: string;
    storage?: ResizableStorage;
    keyboardResizeBy?: number;
    views?: ResizableStyles;
    [key: string]: any;
}

declare interface ResizableStorage {
    getItem: (id: string) => string | null;
    setItem: (id: string, value: string) => void;
}

declare interface ResizableStyles {
    container?: ViewProps;
    panel?: ViewProps;
    collapsedPanel?: ViewProps;
    handle?: ViewProps & {
        _hover?: ViewProps;
        _active?: ViewProps;
    };
    handleIcon?: ViewProps;
    collapseIcon?: ViewProps;
}

export declare interface ResizableType extends default_2.FC<ResizableProps> {
    Panel: default_2.FC<ResizablePanelProps>;
    Handle: default_2.FC<ResizableHandleProps>;
}

export declare interface RipplesProps extends Omit<ViewProps, 'colors'> {
    rippleCount?: number;
    colors?: string[];
    maxSize?: number;
    frequency?: number;
}

export declare const RotateIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const SaveIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const SearchIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Select: default_2.FC<SelectProps>;

export declare interface SelectBoxProps {
    options: Option_2[];
    value?: string | Array<string>;
    isDisabled?: boolean;
    placeholder?: string;
    removeOption?: Function;
    views?: SelectStyles;
    size?: Size_7;
}

export declare const Selector: default_2.FC<SelectorProps>;

declare interface SelectorProps extends Omit<InputProps, 'size' | 'shadow' | 'value'> {
    id?: string;
    error?: boolean;
    name?: string;
    label?: string;
    helperText?: string;
    placeholder?: string;
    options: Option_3[];
    isMulti?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    onChange?: (value: any) => void;
    shape?: Shape_6;
    variant?: Variant_8;
    views?: SelectorStyles;
    size?: Size_9;
    shadow?: Shadow | Elevation_2 | ViewProps;
    isScrollable?: boolean;
}

export declare interface SelectProps extends Omit<InputProps, 'size' | 'shadow' | 'value'> {
    id?: string;
    error?: boolean;
    name?: string;
    label?: string;
    helperText?: string;
    placeholder?: string;
    options: Option_2[];
    isMulti?: boolean;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isClearable?: boolean;
    isRequired?: boolean;
    isAutoFocus?: boolean;
    onChange?: (value: any) => void;
    shape?: Shape_5;
    variant?: Variant_7;
    views?: SelectStyles;
    size?: Size_7;
    shadow?: Shadow | Elevation_2 | ViewProps;
    isScrollable?: boolean;
    labelProps?: any;
}

export declare interface SelectViewProps extends SelectProps {
    value: string | Array<string>;
    setValue: Function;
    hide: boolean;
    setHide: Function;
    isHovered: boolean;
    setIsHovered: Function;
    isFocused: boolean;
    setIsFocused: Function;
    highlightedIndex?: number;
    setHighlightedIndex?: Function;
}

export declare const SendIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Separator: default_2.FC<SeparatorProps>;

export declare interface SeparatorProps extends ViewProps {
    orientation?: Orientation_4;
    variant?: Variant_27;
    thickness?: Thickness;
    color?: string;
    spacing?: number | string;
    label?: React.ReactNode;
    decorative?: boolean;
    views?: SeparatorStyles;
}

declare interface SeparatorStyles {
    container?: ViewProps;
    label?: ViewProps;
}

export declare const SettingsIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Shape = 'square' | 'rounded';

declare type Shape_12 = 'default' | 'square' | 'rounded' | 'pill';

declare type Shape_13 = 'default' | 'square' | 'rounded' | 'pill';

/**
 * Shape options for the ChatInput component
 */
declare type Shape_14 = 'default' | 'square' | 'rounded';

declare type Shape_15 = 'square' | 'rounded' | 'pill';

declare type Shape_16 = 'square' | 'rounded' | 'pill';

declare type Shape_17 = 'square' | 'rounded' | 'pill';

declare type Shape_18 = 'default' | 'square' | 'rounded' | 'pill';

declare type Shape_19 = 'default' | 'square' | 'rounded' | 'pill';

declare type Shape_2 = 'square' | 'rounded' | 'pill';

declare type Shape_21 = 'default' | 'square' | 'rounded' | 'pill';

declare type Shape_22 = 'rounded' | 'square' | 'circular';

declare type Shape_4 = 'square' | 'rounded' | 'pill';

declare type Shape_7 = 'default' | 'square' | 'rounded' | 'pill';

declare type Shape_9 = 'default' | 'square' | 'rounded' | 'pill';

export declare const ShapeIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ShareButton: default_2.FC<ShareButtonProps>;

export declare interface ShareButtonProps extends Omit<ButtonProps, 'onClick'> {
    shareData: NavigatorShareData;
    label?: default_2.ReactNode;
    onShareStart?: () => void;
    onShareSuccess?: () => void;
    onShareCancel?: () => void;
    onShareError?: (error: unknown) => void;
    onUnsupported?: () => void;
    disableWhenUnsupported?: boolean;
    onClick?: ButtonProps['onClick'];
}

export declare interface ShareButtonViewProps extends Omit<ShareButtonProps, 'shareData' | 'onShareStart' | 'onShareSuccess' | 'onShareCancel' | 'onShareError' | 'onUnsupported' | 'onClick'> {
    isSupported: boolean;
    isSharing: boolean;
    onShare: ButtonProps['onClick'];
}

export declare const ShareIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ShieldIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const showDrawer: (name: string, drawerProps?: any, overlayProps?: any) => void;

export declare const showMessage: (variant: MessageType, title?: string, subtitle?: string, props?: ShowMessageType) => void;

export declare interface ShowMessageProps {
    isClosable?: boolean;
    views?: MessageViewStyles;
    action?: Function;
    actionText?: string;
    showIcon?: boolean;
    timeout?: number;
}

declare type ShowMessageType = {
    isClosable?: boolean;
    views?: MessageViewStyles;
    action?: Function;
    actionText?: string;
    showIcon?: boolean;
    timeout?: number;
};

export declare const showModal: (name: string, modalProps?: any, overlayProps?: any) => void;

export declare const showToast: (variant: ToastVariant, title: string, description?: string, options?: ToastOptions) => string;

export declare const Sidebar: SidebarType;

export declare interface SidebarContentProps {
    children: default_2.ReactNode;
    views?: {
        content?: ViewProps;
    };
    [key: string]: any;
}

declare interface SidebarContextType {
    isExpanded: boolean;
    toggleExpanded: () => void;
    expand: () => void;
    collapse: () => void;
    position: Position_6;
    size: Size_31;
    variant: Variant_28;
    views?: SidebarStyles;
}

export declare interface SidebarFooterProps {
    children: default_2.ReactNode;
    views?: {
        footer?: ViewProps;
    };
    [key: string]: any;
}

export declare interface SidebarHeaderProps {
    children: default_2.ReactNode;
    showToggleButton?: boolean;
    views?: {
        header?: ViewProps;
        toggleButton?: ViewProps;
        toggleButtonIcon?: ViewProps;
    };
    [key: string]: any;
}

export declare interface SidebarProps {
    children: default_2.ReactNode;
    position?: Position_6;
    size?: Size_31;
    variant?: Variant_28;
    defaultExpanded?: boolean;
    expanded?: boolean;
    onExpandedChange?: (expanded: boolean) => void;
    fixed?: boolean;
    hasBackdrop?: boolean;
    showToggleButton?: boolean;
    expandedWidth?: string | number;
    collapsedWidth?: string | number;
    breakpoint?: number;
    breakpointBehavior?: BreakpointBehavior;
    elevation?: Elevation_3;
    transitionPreset?: TransitionPreset;
    ariaLabel?: string;
    views?: SidebarStyles;
    [key: string]: any;
}

declare interface SidebarStyles {
    container?: ViewProps;
    header?: ViewProps;
    content?: ViewProps;
    footer?: ViewProps;
    backdrop?: ViewProps;
    toggleButton?: ViewProps;
    toggleButtonIcon?: ViewProps;
    divider?: ViewProps;
    navItem?: ViewProps;
    navItemActive?: ViewProps;
    navItemIcon?: ViewProps;
    navItemText?: ViewProps;
    navItemBagde?: ViewProps;
}

export declare interface SidebarType extends default_2.FC<SidebarProps> {
    Header: default_2.FC<SidebarHeaderProps>;
    Content: default_2.FC<SidebarContentProps>;
    Footer: default_2.FC<SidebarFooterProps>;
    useContext: () => SidebarContextType;
}

declare type Size = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_10 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_13 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_16 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_17 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

/**
 * Size options for the ChatInput component
 */
declare type Size_19 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_2 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_20 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_21 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_22 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_26 = 'sm' | 'md' | 'lg';

declare type Size_27 = 'sm' | 'md' | 'lg';

declare type Size_28 = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type Size_29 = 'sm' | 'md' | 'lg';

declare type Size_30 = 'sm' | 'md' | 'lg';

declare type Size_31 = 'sm' | 'md' | 'lg' | 'xl';

declare type Size_32 = 'sm' | 'md' | 'lg';

declare type Size_33 = 'sm' | 'md' | 'lg';

declare type Size_34 = 'sm' | 'md' | 'lg';

declare type Size_5 = 'sm' | 'md' | 'lg';

declare type Size_6 = 'sm' | 'md' | 'lg';

declare type SlideDirection = 'horizontal' | 'vertical';

export declare const Slider: default_2.FC<SliderProps>;

export declare const SliderIcon: default_2.FC<Omit<IconProps, "name">>;

declare interface SliderProps extends Omit<InputProps, 'size' | 'onChange' | 'onDrag' | 'shadow' | 'value'> {
    min?: number;
    max?: number;
    value?: number;
    defaultValue?: number;
    step?: number;
    stepValues?: number[];
    shape?: Shape_15;
    size?: Size_20;
    variant?: Variant_17;
    orientation?: Orientation;
    isDisabled?: boolean;
    showValue?: boolean;
    showTooltip?: boolean;
    label?: React.ReactNode;
    helperText?: string;
    onChange?: (value: number) => void;
    onDrag?: (value: number) => void;
    views?: SliderStyles;
    shadow?: ViewProps;
    ariaLabel?: string;
}

declare interface SliderStyles {
    container?: ViewProps;
    track?: ViewProps;
    progress?: ViewProps;
    filledTrack?: ViewProps;
    thumb?: ViewProps;
    label?: ViewProps;
    valueLabel?: ViewProps;
    stepMarks?: ViewProps;
    tooltip?: ViewProps & {
        text?: TextProps;
    };
}

export declare const SpinnerIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const StarIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Status = 'default' | 'info' | 'success' | 'warning' | 'error';

export declare const StatusIndicator: (props: StatusIndicatorProps) => default_2.JSX.Element;

export declare interface StatusIndicatorProps extends ViewProps {
    label?: string;
    status?: Status;
    views?: StatusIndicatorStyles;
    icon?: default_2.ReactNode;
    color?: string;
    size?: string;
    variant?: string;
}

declare type StatusIndicatorStyles = {
    container?: ViewProps;
    indicator?: ViewProps;
    label?: ViewProps;
};

export declare const StopIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const SuccessIcon: default_2.FC<Omit<IconProps, "name">>;

declare interface Suggestion {
    id: string;
    text: string;
    description?: string;
}

export declare const Switch: default_2.FC<SwitchProps>;

export declare interface SwitchProps extends Omit<InputProps, 'size' | 'onChange' | 'on' | 'shadow' | 'value'> {
    activeChild?: React.ReactNode;
    id?: string;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isChecked?: boolean;
    onChange?: (checked: boolean) => void;
    name?: string;
    inActiveChild?: React.ReactNode;
    views?: SwitchStyles;
    shadow?: Shadow | Elevation_2 | ViewProps;
    size?: Size_8;
    labelPosition?: 'left' | 'right';
    label?: React.ReactNode;
    description?: React.ReactNode;
    variant?: string;
}

export declare interface SwitchViewProps extends SwitchProps {
    isHovered: boolean;
    setIsHovered: Function;
    value?: boolean;
    setValue?: Function;
    on?: boolean;
    setOn?: Function;
}

export declare const Table: {
    ({ children, views, onClick }: TableLayoutProps): default_2.JSX.Element;
    Head: default_2.FC<ViewProps>;
    HeadCell: default_2.FC<ViewProps>;
    Body: default_2.FC<ViewProps>;
    Row: default_2.FC<ViewProps>;
    Cell: default_2.FC<ViewProps & {
        isFirstColumn?: boolean;
    }>;
    Footer: default_2.FC<ViewProps>;
    Caption: default_2.FC<ViewProps>;
    Container: default_2.FC<ViewProps>;
    Template: default_2.FC<TableViewProps>;
};

export declare interface TableLayoutProps {
    Head?: default_2.FC<any>;
    Body?: default_2.FC<any>;
    Row?: default_2.FC<any>;
    Cell?: default_2.FC<any>;
    Footer?: default_2.FC<any>;
    Caption?: default_2.FC<any>;
    TableContainer?: default_2.FC<any>;
    children?: default_2.ReactNode;
    views?: TableViewStyles;
    onClick?: Function;
}

export declare interface TableProps {
    data: any[];
    columns: Column[];
    footer?: FooterCell[];
    caption?: default_2.ReactNode;
    views?: TableViewStyles;
}

export declare interface TableViewProps extends TableProps, Omit<ViewProps, 'size' | 'columns'> {
}

declare type TableViewStyles = {
    table?: ViewProps;
    thead?: ViewProps;
    tfoot?: ViewProps;
    tbody?: ViewProps;
    tr?: ViewProps;
    td?: ViewProps;
    th?: ViewProps;
    caption?: ViewProps;
};

export declare const Tabs: TabsType;

declare const TabsContent: default_2.FC<TabsContentProps>;

/**
 * Props for TabsContent compound component
 */
export declare interface TabsContentProps {
    /** Value that this content corresponds to */
    value: string;
    /** Children content to display when this tab is active */
    children: default_2.ReactNode;
    /** Custom styles for the content */
    views?: {
        content?: ViewProps;
    };
}

declare const TabsList: default_2.FC<TabsListProps>;

/**
 * Props for TabsList compound component
 */
export declare interface TabsListProps {
    /** Children (TabsTrigger components) */
    children: default_2.ReactNode;
    /** Custom styles for the list container */
    views?: {
        container?: ViewProps;
    };
}

/**
 * Props for the main Tabs component (External API).
 * Supports both data-driven approach (with tabs prop) and compound component pattern.
 */
export declare interface TabsProps {
    /** Array of tab objects to be displayed. Each tab needs a unique `value`. (Data-driven approach) */
    tabs?: Tab[];
    /** Optional value of the tab to be active initially. Defaults to the first tab if not provided or not found. */
    defaultValue?: string | number;
    /** Optional callback function triggered when the active tab changes. Receives the newly active tab object. */
    onTabChange?: (activeTab: Tab) => void;
    /** Optional styles object to customize the appearance of the tabs container, headers, text, and content area. */
    views?: TabsStyles;
    /** Visual presentation style for the tab list. */
    variant?: TabsVariant;
    /** Optional position of the icon relative to the text in tab headers. */
    iconPosition?: 'left' | 'right' | 'top' | 'bottom';
    /**
     * Optional custom renderer for a single tab header.
     * Receives the tab data, whether it's currently active, and an onClick handler to activate the tab.
     */
    renderTab?: (tab: Tab, isActive: boolean, onClick: () => void) => default_2.ReactNode;
    /**
     * Optional custom renderer for the content area.
     * Receives the currently active tab object.
     * If not provided, the `content` property from the active tab object will be rendered.
     */
    renderContent?: (activeTab: Tab) => default_2.ReactNode;
    /** Current value for controlled compound component pattern */
    value?: string | number;
    /** Callback when tab value changes in compound component pattern */
    onValueChange?: (value: any) => void;
    /** Children for compound component pattern */
    children?: default_2.ReactNode;
}

declare const TabsTrigger: default_2.FC<TabsTriggerProps>;

/**
 * Props for TabsTrigger compound component
 */
export declare interface TabsTriggerProps {
    /** Unique value for this tab */
    value: string;
    /** Children content for the trigger */
    children: default_2.ReactNode;
    /** Whether this trigger is disabled */
    disabled?: boolean;
    /** Custom styles for the trigger */
    views?: {
        trigger?: ViewProps;
        activeState?: ViewProps;
    };
}

declare interface TabsType extends default_2.FC<TabsProps> {
    List: typeof TabsList;
    Trigger: typeof TabsTrigger;
    Content: typeof TabsContent;
}

/**
 * Props specifically for the TabsView component (Internal).
 * These props are derived or passed down from the main Tabs component.
 */
export declare interface TabsViewProps {
    variant?: TabsVariant;
    iconPosition?: 'left' | 'right' | 'bottom' | 'top';
    /** The original array of tab objects. */
    tabs: Tab[];
    /** The currently active tab object, or undefined if none is active. */
    activeTab: Tab | undefined;
    /** Callback function to handle clicking on a tab header/button. */
    handleTabClick: (tab: Tab) => void;
    /** Optional styles object. */
    views?: TabsStyles;
    /** Optional custom renderer for a tab button/header. */
    renderTab?: (tab: Tab, isActive: boolean, onClick: () => void) => default_2.ReactNode;
    /** Optional custom renderer for the content area. */
    renderContent?: (activeTab: Tab) => default_2.ReactNode;
}

export declare const TagInput: default_2.FC<TagInputProps>;

declare interface TagInputProps extends Omit<InputProps, 'size' | 'value' | 'onChange' | 'shadow' | 'left' | 'right'> {
    id?: string;
    name?: string;
    label?: string;
    helperText?: string;
    error?: string | boolean;
    placeholder?: string;
    tags?: string[];
    defaultTags?: string[];
    onTagsChange?: (tags: string[]) => void;
    onTagAdd?: (tag: string) => void;
    onTagRemove?: (tag: string, index: number) => void;
    maxTags?: number;
    minTagLength?: number;
    maxTagLength?: number;
    allowDuplicates?: boolean;
    separators?: TagSeparator[];
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isAutoFocus?: boolean;
    isRemovable?: boolean;
    size?: Size_16;
    shape?: Shape_12;
    variant?: Variant_14;
    shadow?: Shadow | Elevation_2 | ViewProps;
    views?: TagInputStyles;
    left?: default_2.ReactNode;
    right?: default_2.ReactNode;
    onFocus?: () => void;
    onBlur?: () => void;
    onClick?: () => void;
    menuItems?: string[];
    onMenuItemSelect?: (item: string) => void;
}

declare type TagInputStyles = {
    inputContainer?: ViewProps;
    tagsContainer?: ViewProps;
    tag?: ViewProps;
    tagText?: ViewProps;
    tagRemove?: ViewProps;
    input?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
    error?: ViewProps;
    container?: ViewProps;
    placeholder?: ViewProps;
    menu?: ViewProps;
    menuItem?: ViewProps;
    menuItemActive?: ViewProps;
};

declare type TagSeparator = 'enter' | 'comma' | 'space' | 'tab';

export declare const TextArea: default_2.FC<TextAreaProps>;

export declare interface TextAreaProps extends Omit<InputProps, 'size' | 'shadow' | 'value' | 'onSubmit'> {
    defaultValue?: string;
    error?: boolean;
    isEditable?: boolean;
    helperText?: string;
    id?: string;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isAutoFocus?: boolean;
    isMultiline?: boolean;
    label?: string;
    maxRows?: number;
    maxCols?: number;
    name?: string;
    placeholder?: string;
    onChange?: (value: any) => void;
    onChangeText?: (text: string) => void;
    onBlur?: (value: any) => void;
    onFocus?: () => void;
    size?: Size_10;
    shadow?: Shadow | Elevation_2 | ViewProps;
    shape?: Shape_7;
    views?: TextAreaStyles;
    value?: string | number;
    variant?: Variant_9;
    rows?: number;
    cols?: number;
    isRequired?: boolean;
    required?: boolean;
    labelProps?: any;
    onSubmit?: (input: string) => void;
    isWorkerRunning?: boolean;
}

declare type TextAreaStyles = {
    warper?: ViewProps;
    container?: ViewProps;
    label?: ViewProps;
    helperText?: ViewProps;
    field?: ViewProps;
    content?: ViewProps;
    textarea?: ViewProps;
};

export declare interface TextAreaViewProps extends TextAreaProps {
    hint?: string;
    setHint?: Function;
    isHovered?: boolean;
    setIsHovered?: Function;
    value?: string | number;
    setValue?: Function;
    isFocused?: boolean;
    setIsFocused?: Function;
}

export declare const TextField: default_2.FC<TextFieldProps>;

export declare interface TextFieldProps extends Omit<InputProps, 'size' | 'shadow' | 'left' | 'right'> {
    id?: string;
    error?: any;
    helperText?: string;
    name?: string;
    label?: string;
    left?: default_2.ReactNode;
    right?: default_2.ReactNode;
    placeholder?: string;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isClearable?: boolean;
    isAutoFocus?: boolean;
    isRequired?: boolean;
    required?: boolean;
    rightIcon?: default_2.ReactNode;
    leftIcon?: default_2.ReactNode;
    labelProps?: any;
    onChange?: (value: any) => void;
    onChangeText?: (value: string) => void;
    onBlur?: (value: any) => void;
    onClick?: () => void;
    onFocus?: () => void;
    size?: Size_11;
    shadow?: Shadow | Elevation_2 | ViewProps;
    shape?: Shape_8;
    views?: TextFieldStyles;
    value?: string;
    variant?: Variant_10;
    isMultiline?: boolean;
    rows?: number;
}

export declare interface TextFieldViewProps extends TextFieldProps {
    hint?: string;
    setHint?: Function;
    isFocused?: boolean;
    setIsFocused?: Function;
    isHovered?: boolean;
    setIsHovered?: Function;
    value?: string;
    setValue?: Function;
}

export declare const TextIcon: default_2.FC<Omit<IconProps, "name">>;

declare type Theme = {
    container: {
        backgroundColor?: string;
        border?: string;
    };
    icon: {
        color?: string;
        name?: string;
    };
    content: {
        color?: string;
    };
    close: {
        color?: string;
        name?: string;
    };
};

declare interface Theme_2 {
    container: {
        backgroundColor: string;
        border: string;
    };
    content: {
        color: string;
    };
    icon: {
        color: string;
    };
}

declare type ThemesType = {
    info: Theme;
    success: Theme;
    error: Theme;
    warning: Theme;
};

declare type ThemesType_2 = {
    info: Theme_2;
    success: Theme_2;
    error: Theme_2;
    warning: Theme_2;
};

declare type Thickness = 'thin' | 'medium' | 'thick';

export declare const ThreadsIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const TickIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Title: default_2.FC<TitleProps>;

export declare interface TitleProps extends ViewProps {
    level?: 1 | 2 | 3 | 4 | 5 | 6;
    centered?: boolean;
    _isInView?: boolean;
    children: React.ReactNode;
    highlightText?: string | string[];
    alternateHighlightText?: string[];
    highlightAnimate?: AnimationProps | AnimationProps[];
    highlightTypewriter?: boolean;
    highlightTypewriterDuration?: number;
    highlightSlide?: boolean;
    highlightSlideDuration?: number;
    highlightSlideStagger?: number;
    highlightSlideSequential?: boolean;
    highlightStyle?: HighlightStyle;
    highlightColor?: string;
    highlightSecondaryColor?: string;
    animate?: AnimationProps | AnimationProps[];
    animationLoop?: number | 'infinite';
    highlightAnimationLoop?: number | 'infinite';
    size?: TitleSize;
    responsive?: boolean;
    views?: TitleStyles;
    alternateAnimation?: boolean;
    alternateDuration?: number;
}

declare type TitleSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

declare type TitleStyles = {
    container?: ViewProps;
    text?: ViewProps;
    highlight?: ViewProps;
};

export declare const Toast: default_2.FC<ToastProps> & {
    Container: (props: ToastContainerProps) => default_2.JSX.Element;
    show: (variant: ToastVariant, title: string, description?: string, options?: ToastOptions) => string;
    info: (title: string, description?: string, options?: ToastOptions) => string;
    success: (title: string, description?: string, options?: ToastOptions) => string;
    warning: (title: string, description?: string, options?: ToastOptions) => string;
    error: (title: string, description?: string, options?: ToastOptions) => string;
    remove: (id: string) => void;
    removeAll: () => void;
};

export declare interface ToastContainerProps {
    position?: ToastPosition;
    gap?: number;
    limit?: number;
    containerStyle?: React.CSSProperties;
}

declare interface ToastItem extends ToastOptions {
    id: string;
    variant: ToastVariant;
    title: string;
    description?: string;
    createdAt: number;
    isVisible?: boolean;
}

declare interface ToastOptions {
    id?: string;
    duration?: number;
    position?: ToastPosition;
    isClosable?: boolean;
    onClose?: () => void;
    action?: () => void;
    actionText?: string;
    showIcon?: boolean;
    views?: ToastStyles;
    render?: (props: {
        id: string;
        onClose: () => void;
    }) => React.ReactNode;
    icon?: React.ReactNode;
}

declare type ToastPosition = 'top' | 'top-right' | 'top-left' | 'bottom' | 'bottom-right' | 'bottom-left';

export declare interface ToastProps extends Omit<ViewProps, 'theme'> {
    id?: string;
    variant: ToastVariant;
    title: string;
    description?: string;
    onClose: () => void;
    isClosable?: boolean;
    action?: () => void;
    actionText?: string;
    showIcon?: boolean;
    theme?: ThemesType_2;
    views?: ToastStyles;
    duration?: number;
    render?: (props: {
        id: string;
        onClose: () => void;
    }) => React.ReactNode;
    icon?: React.ReactNode;
    isVisible?: boolean;
}

export declare interface ToastState {
    toasts: ToastItem[];
    add: (variant: ToastVariant, title: string, description?: string, options?: ToastOptions) => string;
    remove: (id: string) => void;
    removeAll: () => void;
}

declare interface ToastStyles {
    container?: ViewProps;
    title?: ViewProps;
    description?: ViewProps;
    icon?: ViewProps;
    closeButton?: ViewProps;
    actionButton?: ViewProps;
}

declare type ToastVariant = 'info' | 'success' | 'warning' | 'error';

export declare const Toggle: ({ children, shape, variant, isDisabled, isToggled, onToggle, ...props }: ToggleProps) => default_2.JSX.Element;

export declare const ToggleGroup: ({ items, shape, variant, onToggleChange, }: ToggleGroupProps) => default_2.JSX.Element;

export declare interface ToggleGroupProps {
}

export declare interface ToggleGroupProps extends Omit<InputProps, 'size'> {
    shape?: Shape_17;
    items: ToggleItem[];
    variant?: Variant_19;
    onToggleChange?: (activeIds: string[]) => void;
    views?: any;
}

export declare interface ToggleGroupViewProps extends Omit<ToggleGroupProps, ''> {
    activeToggles: string[];
    setActiveToggles: React.Dispatch<React.SetStateAction<string[]>>;
    views?: {
        container?: ViewProps;
        toggle?: ViewProps;
    };
}

declare type ToggleItem = {
    id: string;
    value: React.ReactNode;
    state?: boolean;
    isDisabled?: boolean;
    isActive?: boolean;
};

export declare interface ToggleProps extends Omit<InputProps, 'size' | 'onToggle'> {
    shape?: Shape_16;
    isToggled?: boolean;
    isDisabled?: boolean;
    children: React.ReactNode;
    variant?: Variant_18;
    onToggle?: (isToggled: boolean) => void;
    views?: any;
}

export declare interface ToggleViewProps extends Omit<ToggleProps, never> {
    isHovered: boolean;
    setIsHovered: React.Dispatch<React.SetStateAction<boolean>>;
    isToggle: boolean;
    setIsToggled: React.Dispatch<React.SetStateAction<boolean>>;
}

export declare const Tooltip: TooltipType;

export declare interface TooltipContentProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
        arrow?: ViewProps;
    };
    [key: string]: any;
}

export declare interface TooltipProps {
    content: default_2.ReactNode;
    children: default_2.ReactNode;
    position?: Position_7;
    align?: Alignment_3;
    size?: Size_33;
    variant?: Variant_30;
    openDelay?: number;
    closeDelay?: number;
    showArrow?: boolean;
    defaultOpen?: boolean;
    isDisabled?: boolean;
    views?: TooltipStyles;
    [key: string]: any;
}

declare interface TooltipStyles {
    container?: ViewProps;
    content?: ViewProps;
    arrow?: ViewProps;
    text?: TextProps;
}

export declare interface TooltipTriggerProps {
    children: default_2.ReactNode;
    views?: {
        container?: ViewProps;
    };
    asChild?: boolean;
    [key: string]: any;
}

export declare interface TooltipType extends default_2.FC<TooltipProps> {
    Trigger: default_2.FC<TooltipTriggerProps>;
    Content: default_2.FC<TooltipContentProps>;
}

declare type TransitionPreset = 'fast' | 'normal' | 'slow' | 'bounce';

export declare const TrashIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const TwitchIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const TwitterIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const UnLikeIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const UnlockIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const Uploader: default_2.FC<UploadProps>;

declare type UploadFileHandler = (file: File, onProgress: (progress: number) => void) => Promise<any>;

export declare const UploadIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface UploadProps extends UseUploadProps, UploadViewProps {
}

export declare interface UploadStateProps {
    handleFileChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
    selectedFile: File | null;
    selectedFiles: File[];
    fileInputRef: React.RefObject<HTMLInputElement | null>;
    videoRef: React.RefObject<HTMLVideoElement | null>;
}

export declare interface UploadViewProps {
    onError?: (error: string) => void;
    containerProps?: ViewProps;
    errorMessageProps?: TextProps;
    thumbnailContainerProps?: ViewProps;
    loadingProps?: ViewProps;
    progressProps?: ViewProps;
    videoProps?: ViewProps;
    imageProps?: ImageProps;
    iconProps?: IconProps;
    textProps?: TextProps;
    renderVideo?: (props: any) => React.ReactNode;
    renderText?: (props: any) => React.ReactNode;
    renderImage?: (props: any) => React.ReactNode;
    renderError?: (props: any) => React.ReactNode;
    renderFile?: (props: any) => React.ReactNode;
    renderProgress?: (props: any) => React.ReactNode;
    previewUrl?: string | null;
    thumbnailUrl?: string | null;
    errorMessage?: string | null;
    isLoading?: boolean;
    icon?: React.ReactNode;
    accept?: string;
    text?: string;
    maxSize?: number;
    progress?: number;
    fileType?: 'video' | 'image' | 'file';
    handleClick?: () => void;
    onFileSelect?: (file: File) => void;
    onMultipleFileSelect?: (files: File[]) => void;
    validateFile?: (file: File) => string | null;
    multiple?: boolean;
    views?: {
        container?: ViewProps;
        view?: ViewProps;
        image?: ImageProps;
        horizontal?: ViewProps;
        text?: ViewProps;
    };
}

export declare const useDesignSystem: () => DesignSystemContextValue;

export declare const useDesignSystemComponentProps: (componentName: DesignSystemComponentName) => DesignSystemComponentConfig;

export declare const useDrawerStore: UseBoundStore<StoreApi<DrawerState>>;

export declare const useMergedDesignSystemComponentProps: <T extends Record<string, any>>(componentName: DesignSystemComponentName, props: T) => T;

export declare const useMessageStore: UseBoundStore<StoreApi<MessageState>>;

export declare const useModalStore: UseBoundStore<StoreApi<ModalState>>;

export declare const UserIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const useToast: () => {
    toast: (variant: ToastVariant, title: string, description?: string, options?: ToastOptions) => string;
    info: (title: string, description?: string, options?: ToastOptions) => string;
    success: (title: string, description?: string, options?: ToastOptions) => string;
    warning: (title: string, description?: string, options?: ToastOptions) => string;
    error: (title: string, description?: string, options?: ToastOptions) => string;
    remove: (id: string) => void;
    removeAll: () => void;
};

export declare interface UseUploadProps {
    accept?: string;
    maxSize?: number;
    onFileSelect?: (file: File) => void;
    onMultipleFileSelect?: (files: File[]) => void;
    validateFile?: (file: File) => string | null;
    onError?: (error: string) => void;
    thumbnail?: string;
    multiple?: boolean;
}

declare type Variant = 'default' | 'outline' | 'filled';

declare type Variant_11 = 'outline' | 'default' | 'none';

declare type Variant_14 = 'outline' | 'default' | 'none';

declare type Variant_15 = 'outline' | 'default' | 'none';

/**
 * Variant options for the ChatInput component
 */
declare type Variant_16 = 'default' | 'outline' | 'none';

declare type Variant_17 = 'default' | 'outline';

declare type Variant_18 = 'outline' | 'link' | 'ghost';

declare type Variant_19 = 'outline' | 'link' | 'ghost';

declare type Variant_2 = 'default' | 'info' | 'success' | 'error' | 'warning';

declare type Variant_20 = 'outline' | 'default' | 'filled';

declare type Variant_21 = 'outline' | 'default' | 'filled';

declare type Variant_22 = 'default' | 'filled' | 'outline';

declare type Variant_23 = 'default' | 'filled' | 'outline';

declare type Variant_24 = 'outline' | 'default' | 'filled';

declare type Variant_25 = 'default' | 'filled' | 'outline';

declare type Variant_26 = 'default' | 'filled' | 'outline';

declare type Variant_27 = 'solid' | 'dashed' | 'dotted';

declare type Variant_28 = 'default' | 'filled' | 'outline' | 'subtle' | 'elevated';

declare type Variant_29 = 'default' | 'subtle' | 'prominent';

declare type Variant_3 = 'filled' | 'outline' | 'link' | 'ghost';

declare type Variant_30 = 'default' | 'light' | 'dark';

declare type Variant_31 = 'default' | 'glassy' | 'minimal';

declare type Variant_5 = 'default' | 'outlined' | 'elevated';

declare type Variant_6 = 'default' | 'filled' | 'outline';

declare type Variant_9 = 'outline' | 'default' | 'none';

export declare const VideoIcon: default_2.FC<Omit<IconProps, "name">>;

export declare interface WallProps extends ViewProps {
    rows?: number;
    cols?: number;
    squareSize?: number;
}

export declare const WarningIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const WifiIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const XIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const YoutubeIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ZapIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ZoomInIcon: default_2.FC<Omit<IconProps, "name">>;

export declare const ZoomOutIcon: default_2.FC<Omit<IconProps, "name">>;

export { }