import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { ComponentPropsWithoutRef, ReactNode, InputHTMLAttributes } from 'react';
import * as _radix_ui_themes from '@radix-ui/themes';
import { CardProps as CardProps$1, Popover as Popover$1, TabNav as TabNav$1, Tabs as Tabs$1, Text as Text$1, TooltipProps, Box as Box$1, Flex as Flex$1, Grid as Grid$1, Dialog as Dialog$1, Select as Select$1, TextField as TextField$1 } from '@radix-ui/themes';
import * as RadixCheckbox from '@radix-ui/react-checkbox';
import { Label as Label$1 } from '@radix-ui/react-label';
import * as RadixSwitch from '@radix-ui/react-switch';
import * as RadixAccordion from '@radix-ui/react-accordion';
import * as RadixRadioGroup from '@radix-ui/react-radio-group';
import * as _types_react from '@types/react';

/**
 * Shared Tailwind configuration
 * This config extends Tailwind's default theme with custom design tokens.
 */
declare const tailwindConfig: {
    theme: {
        extend: {
            fontFamily: {
                sans: string[];
            };
            fontSize: {
                '2xs': (string | {
                    lineHeight: string;
                })[];
                xs: (string | {
                    lineHeight: string;
                })[];
                sm: (string | {
                    lineHeight: string;
                })[];
                base: (string | {
                    lineHeight: string;
                })[];
                lg: (string | {
                    lineHeight: string;
                })[];
                xl: (string | {
                    lineHeight: string;
                })[];
                '2xl': (string | {
                    lineHeight: string;
                })[];
            };
            lineHeight: {
                default: string;
                sm: string;
            };
            colors: {
                primary: {
                    1: string;
                    2: string;
                    3: string;
                    4: string;
                    5: string;
                    6: string;
                    7: string;
                    8: string;
                    9: string;
                    10: string;
                    11: string;
                    12: string;
                    a1: string;
                    a2: string;
                    a3: string;
                    a4: string;
                    a5: string;
                    a6: string;
                    a7: string;
                    a8: string;
                    a9: string;
                    a10: string;
                    a11: string;
                    a12: string;
                };
                neutral: {
                    1: string;
                    2: string;
                    3: string;
                    4: string;
                    5: string;
                    6: string;
                    7: string;
                    8: string;
                    9: string;
                    10: string;
                    11: string;
                    12: string;
                    a1: string;
                    a2: string;
                    a3: string;
                    a4: string;
                    a5: string;
                    a6: string;
                    a7: string;
                    a8: string;
                    a9: string;
                    a10: string;
                    a11: string;
                    a12: string;
                };
            };
        };
    };
};

interface ThemeProviderProps {
    theme?: 'light' | 'dark';
    children: React__default.ReactNode;
}
declare const EpilotThemeProvider: ({ theme, children }: ThemeProviderProps) => react_jsx_runtime.JSX.Element;

type RadixPropsVariant = 'classic' | 'solid' | 'soft' | 'surface' | 'outline' | 'ghost';
type NewVariant = 'primary' | 'secondary' | 'tertiary' | 'neutral';
declare const Button: React__default.ForwardRefExoticComponent<React__default.ButtonHTMLAttributes<HTMLButtonElement> & {
    variant?: RadixPropsVariant | NewVariant;
    size?: 1 | 2 | 3 | "1" | "2" | "3";
    warning?: boolean;
    children: React__default.ReactNode;
} & React__default.RefAttributes<HTMLButtonElement>>;

declare const IconButton: React__default.ForwardRefExoticComponent<React__default.ButtonHTMLAttributes<HTMLButtonElement> & {
    variant?: RadixPropsVariant | NewVariant;
    size?: 1 | 2 | 3 | "1" | "2" | "3";
    warning?: boolean;
    children: React__default.ReactNode;
} & React__default.RefAttributes<HTMLButtonElement>>;

type CardVariant = 'surface' | 'classic';
type CardSize = '1' | '2';
interface CardProps extends Omit<CardProps$1, 'variant' | 'size'> {
    variant?: CardVariant;
    size?: CardSize;
}
declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;

interface CheckboxProps extends Omit<ComponentPropsWithoutRef<typeof RadixCheckbox.Root>, 'children'> {
    label: string;
    className?: string;
    warning?: boolean;
}
declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;

declare const Heading: React$1.ForwardRefExoticComponent<Omit<_radix_ui_themes.HeadingProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;

type LabelProps = ComponentPropsWithoutRef<typeof Label$1>;
declare const Label: (props: LabelProps) => react_jsx_runtime.JSX.Element;

type PopoverSize = '1' | '2' | '3' | '4';
interface PopoverContentProps extends Omit<ComponentPropsWithoutRef<typeof Popover$1.Content>, 'size'> {
    size?: PopoverSize;
}
declare const Popover: {
    Root: React$1.FC<Popover$1.RootProps>;
    Trigger: React$1.ForwardRefExoticComponent<Popover$1.TriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
    Content: React$1.ForwardRefExoticComponent<PopoverContentProps & React$1.RefAttributes<HTMLDivElement>>;
    Close: React$1.ForwardRefExoticComponent<Popover$1.CloseProps & React$1.RefAttributes<HTMLButtonElement>>;
};

interface SwitchProps extends Omit<ComponentPropsWithoutRef<typeof RadixSwitch.Root>, 'children'> {
    label: string;
    className?: string;
    warning?: boolean;
}
declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;

type TabNavSize = '1' | '2';
type TabNavJustify = 'start' | 'center' | 'end';
type TabNavWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
declare const TabNav: {
    Root: React$1.ForwardRefExoticComponent<Omit<TabNav$1.RootProps & React$1.RefAttributes<HTMLElement>, "ref"> & {
        size?: TabNavSize;
        justify?: TabNavJustify;
        wrap?: TabNavWrap;
    } & React$1.RefAttributes<HTMLDivElement>>;
    Link: React$1.ForwardRefExoticComponent<Omit<TabNav$1.LinkProps & React$1.RefAttributes<HTMLAnchorElement>, "ref"> & {
        active?: boolean;
    } & React$1.RefAttributes<HTMLAnchorElement>>;
};

type TabsSize = '1' | '2';
type TabsJustify = 'start' | 'center' | 'end';
type TabsWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
declare const Tabs: {
    Root: React$1.ForwardRefExoticComponent<Omit<Tabs$1.RootProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    List: React$1.ForwardRefExoticComponent<Omit<Tabs$1.ListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
        size?: TabsSize;
        justify?: TabsJustify;
        wrap?: TabsWrap;
    } & React$1.RefAttributes<HTMLDivElement>>;
    Trigger: React$1.ForwardRefExoticComponent<Omit<Tabs$1.TriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
    Content: React$1.ForwardRefExoticComponent<Omit<Tabs$1.ContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
};

type TextProps = ComponentPropsWithoutRef<typeof Text$1>;
declare const Text: React$1.ForwardRefExoticComponent<TextProps & React$1.RefAttributes<HTMLSpanElement>>;

declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLDivElement>>;

type BoxProps = ComponentPropsWithoutRef<typeof Box$1>;
declare const Box: React$1.ForwardRefExoticComponent<BoxProps & React$1.RefAttributes<HTMLDivElement>>;

type FlexProps = ComponentPropsWithoutRef<typeof Flex$1>;
declare const Flex: React$1.ForwardRefExoticComponent<FlexProps & React$1.RefAttributes<HTMLDivElement>>;

type GridProps = ComponentPropsWithoutRef<typeof Grid$1>;
declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;

declare const Badge: React$1.ForwardRefExoticComponent<Omit<_radix_ui_themes.BadgeProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;

interface FieldCardProps {
    label?: string;
    children: ReactNode;
    className?: string;
    labelSize?: '1' | '2' | '3';
}
declare const FieldCard: {
    ({ label, children, className, labelSize }: FieldCardProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface AccordionProps {
    type?: 'single' | 'multiple';
    defaultValue?: string | string[];
    children: ReactNode;
    className?: string;
    collapsible?: boolean;
}
declare const Accordion: {
    Root: {
        ({ type, defaultValue, children, className, collapsible }: AccordionProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Item: React$1.ForwardRefExoticComponent<Omit<RadixAccordion.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    Trigger: React$1.ForwardRefExoticComponent<Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
        variant?: RadixPropsVariant | NewVariant;
        size?: 1 | 2 | 3 | "1" | "2" | "3";
        warning?: boolean;
        children: React.ReactNode;
    } & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
    Content: React$1.ForwardRefExoticComponent<Omit<RadixAccordion.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
};

interface RadioGroupProps extends ComponentPropsWithoutRef<typeof RadixRadioGroup.Root> {
    className?: string;
}
declare const RadioGroup: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;

declare const TextArea: React$1.ForwardRefExoticComponent<Omit<_radix_ui_themes.TextAreaProps & React$1.RefAttributes<HTMLTextAreaElement>, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;

interface RootProps {
    id: string;
    children: ReactNode;
    className?: string;
    error?: boolean;
    disabled?: boolean;
    readOnly?: boolean;
}
type ValidationVariant$1 = 'error' | 'success' | 'default';
declare const InputField: {
    Root: {
        ({ id, children, className, error, disabled, readOnly }: RootProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Container: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Label: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
        visuallyHidden?: boolean;
    } & React__default.RefAttributes<HTMLLabelElement>>;
    Validation: React__default.ForwardRefExoticComponent<{
        children: ReactNode;
        className?: string;
        variant?: ValidationVariant$1;
    } & React__default.RefAttributes<HTMLSpanElement>>;
    HelperText: React__default.ForwardRefExoticComponent<{
        children: ReactNode;
        className?: string;
    } & React__default.RefAttributes<HTMLSpanElement>>;
    AffixContainer: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Prefix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
    Suffix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
};

interface SelectOption {
    value: string;
    label: string;
}
interface SelectGroup {
    label: string;
    options: SelectOption[];
}
interface SelectInputProps {
    options: (SelectOption | SelectGroup)[];
    className?: string;
    disabled?: boolean;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    placeholder?: string;
    name?: string;
    required?: boolean;
    form?: string;
    open?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    onEscapeKeyDown?: (event: React__default.KeyboardEvent) => void;
    onBlur?: (event: React__default.FocusEvent<HTMLButtonElement>) => void;
    onFocus?: (event: React__default.FocusEvent<HTMLButtonElement>) => void;
    clearable?: boolean;
    onClear?: () => void;
}
declare const SelectInput: {
    Root: {
        ({ id, children, className, error, disabled, readOnly }: RootProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Container: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Label: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
        visuallyHidden?: boolean;
    } & React__default.RefAttributes<HTMLLabelElement>>;
    Select: React__default.ForwardRefExoticComponent<SelectInputProps & React__default.RefAttributes<HTMLButtonElement>>;
    Validation: React__default.ForwardRefExoticComponent<{
        children: React__default.ReactNode;
        className?: string;
        variant?: "default" | "error" | "success";
    } & React__default.RefAttributes<HTMLSpanElement>>;
    HelperText: React__default.ForwardRefExoticComponent<{
        children: React__default.ReactNode;
        className?: string;
    } & React__default.RefAttributes<HTMLSpanElement>>;
    AffixContainer: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Prefix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
    Suffix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
};

interface TextInputProps extends InputHTMLAttributes<HTMLInputElement> {
    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
    onFocus?: (event: React__default.FocusEvent<HTMLInputElement>) => void;
    onBlur?: (event: React__default.FocusEvent<HTMLInputElement>) => void;
    onKeyDown?: (event: React__default.KeyboardEvent<HTMLInputElement>) => void;
    clearable?: boolean;
    onClear?: () => void;
}
declare const TextInput: {
    Root: {
        ({ id, children, className, error, disabled, readOnly }: RootProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Container: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Label: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
        visuallyHidden?: boolean;
    } & React__default.RefAttributes<HTMLLabelElement>>;
    Input: React__default.ForwardRefExoticComponent<TextInputProps & React__default.RefAttributes<HTMLInputElement>>;
    Validation: React__default.ForwardRefExoticComponent<{
        children: React__default.ReactNode;
        className?: string;
        variant?: "default" | "error" | "success";
    } & React__default.RefAttributes<HTMLSpanElement>>;
    HelperText: React__default.ForwardRefExoticComponent<{
        children: React__default.ReactNode;
        className?: string;
    } & React__default.RefAttributes<HTMLSpanElement>>;
    AffixContainer: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
    Prefix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
    Suffix: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
};

declare const Dialog: {
    Root: React$1.ForwardRefExoticComponent<Dialog$1.RootProps & React$1.RefAttributes<HTMLDivElement>>;
    Trigger: React$1.ForwardRefExoticComponent<Omit<Dialog$1.TriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
    Content: React$1.ForwardRefExoticComponent<Omit<Dialog$1.ContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
    Title: React$1.ForwardRefExoticComponent<Omit<Dialog$1.TitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
    Description: React$1.ForwardRefExoticComponent<Omit<Dialog$1.DescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
    Close: React$1.ForwardRefExoticComponent<Omit<Dialog$1.CloseProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
};

type ValidationVariant = 'error' | 'success' | 'default';
interface ValidationProps {
    children: React__default.ReactNode;
    className?: string;
    variant?: ValidationVariant;
    id?: string;
    'aria-live'?: 'assertive' | 'polite';
    role?: 'alert' | 'status';
}
declare const Validation: React__default.ForwardRefExoticComponent<ValidationProps & React__default.RefAttributes<HTMLSpanElement>>;

declare const Illustrations: {
    readonly 'automated-task': (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly conditions: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly 'coupon-cashback': (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly 'coupon-discount': (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly emails: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly funnel: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly kanban: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly notes: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly 'partner-performance': (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly phases: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly tasks: (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
    readonly 'user-metrics': (props: _types_react.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
};
type IllustrationName = keyof typeof Illustrations;
interface IllustrationProps {
    name: IllustrationName;
    size?: number;
    className?: string;
    alt?: string;
}
declare const Illustration: {
    ({ name, size, className, alt }: IllustrationProps): react_jsx_runtime.JSX.Element | null;
    displayName: string;
};

type SelectSize = '1' | '2' | '3';
type SelectTriggerVariant = 'classic' | 'surface' | 'soft' | 'ghost';
type SelectContentVariant = 'solid' | 'soft';
type SelectRootProps = ComponentPropsWithoutRef<typeof Select$1.Root> & {
    size?: SelectSize;
};
declare const Select: {
    Root: {
        ({ size, ...props }: SelectRootProps): react_jsx_runtime.JSX.Element;
        displayName: string;
    };
    Trigger: React$1.ForwardRefExoticComponent<Omit<Select$1.TriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
        variant?: SelectTriggerVariant;
    } & React$1.RefAttributes<HTMLButtonElement>>;
    Content: React$1.ForwardRefExoticComponent<Omit<Select$1.ContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
        variant?: SelectContentVariant;
    } & React$1.RefAttributes<HTMLDivElement>>;
    Item: React$1.ForwardRefExoticComponent<Select$1.ItemProps & React$1.RefAttributes<HTMLDivElement>>;
    Group: React$1.ForwardRefExoticComponent<Select$1.GroupProps & React$1.RefAttributes<HTMLDivElement>>;
    Label: React$1.ForwardRefExoticComponent<Select$1.LabelProps & React$1.RefAttributes<HTMLDivElement>>;
    Separator: React$1.ForwardRefExoticComponent<Select$1.SeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
};

declare const TextField: React$1.ForwardRefExoticComponent<Omit<TextField$1.RootProps & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;

export { Accordion, Badge, Box, Button, Card, Checkbox, Dialog, EpilotThemeProvider, FieldCard, Flex, Grid, Heading, IconButton, Illustration, InputField, Label, Popover, RadioGroup, Select, SelectInput, Switch, TabNav, Tabs, Text, TextArea, TextField, TextInput, Tooltip, Validation, tailwindConfig };