analytica-frontend-lib 1.0.87 → 1.0.89

package/dist/index.d.mts

@@ -0,0 +1,2205 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ElementType, ReactNode, ComponentPropsWithoutRef, ButtonHTMLAttributes, HTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, HtmlHTMLAttributes, ComponentType } from 'react';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
+
+/**
+ * Base text component props
+ */
+type BaseTextProps = {
+    /** Content to be displayed */
+    children?: ReactNode;
+    /** Text size variant */
+    size?: '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl';
+    /** Font weight variant */
+    weight?: 'hairline' | 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
+    /** Color variant - white for light backgrounds, black for dark backgrounds */
+    color?: string;
+    /** Additional CSS classes to apply */
+    className?: string;
+};
+/**
+ * Polymorphic text component props that ensures type safety based on the 'as' prop
+ */
+type TextProps<T extends ElementType = 'p'> = BaseTextProps & {
+    /** HTML tag to render */
+    as?: T;
+} & Omit<ComponentPropsWithoutRef<T>, keyof BaseTextProps>;
+/**
+ * Text component for Analytica Ensino platforms
+ *
+ * A flexible polymorphic text component with multiple sizes, weights, and colors.
+ * Automatically adapts to dark and light themes with full type safety.
+ *
+ * @param children - The content to display
+ * @param size - The text size variant (2xs, xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl, 6xl)
+ * @param weight - The font weight variant (hairline, light, normal, medium, semibold, bold, extrabold, black)
+ * @param color - The color variant - adapts to theme
+ * @param as - The HTML tag to render - determines allowed attributes via TypeScript
+ * @param className - Additional CSS classes
+ * @param props - HTML attributes valid for the chosen tag only
+ * @returns A styled text element with type-safe attributes
+ *
+ * @example
+ * ```tsx
+ * <Text size="lg" weight="bold" color="text-info-800">
+ *   This is a large, bold text
+ * </Text>
+ *
+ * <Text as="a" href="/link" target="_blank">
+ *   Link with type-safe anchor attributes
+ * </Text>
+ *
+ * <Text as="button" onClick={handleClick} disabled>
+ *   Button with type-safe button attributes
+ * </Text>
+ * ```
+ */
+declare const Text: <T extends ElementType = "p">({ children, size, weight, color, as, className, ...props }: TextProps<T>) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Button component props interface
+ */
+type ButtonProps = {
+    /** Content to be displayed inside the button */
+    children: ReactNode;
+    /** Ícone à esquerda do texto */
+    iconLeft?: ReactNode;
+    /** Ícone à direita do texto */
+    iconRight?: ReactNode;
+    /** Size of the button */
+    size?: 'extra-small' | 'small' | 'medium' | 'large' | 'extra-large';
+    /** Visual variant of the button */
+    variant?: 'solid' | 'outline' | 'link';
+    /** Action type of the button */
+    action?: 'primary' | 'positive' | 'negative';
+    /** Additional CSS classes to apply */
+    className?: string;
+} & ButtonHTMLAttributes<HTMLButtonElement>;
+/**
+ * Button component for Analytica Ensino platforms
+ *
+ * A flexible button component with multiple variants, sizes and actions.
+ *
+ * @param children - The content to display inside the button
+ * @param size - The size variant (extra-small, small, medium, large, extra-large)
+ * @param variant - The visual style variant (solid, outline, link)
+ * @param action - The action type (primary, positive, negative)
+ * @param className - Additional CSS classes
+ * @param props - All other standard button HTML attributes
+ * @returns A styled button element
+ *
+ * @example
+ * ```tsx
+ * <Button variant="solid" action="primary" size="medium" onClick={() => console.log('clicked')}>
+ *   Click me
+ * </Button>
+ * ```
+ */
+declare const Button: ({ children, iconLeft, iconRight, size, variant, action, className, disabled, type, ...props }: ButtonProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Badge component props interface
+ */
+type BadgeProps = {
+    /** Content to be displayed inside the badge */
+    children?: ReactNode;
+    /** Ícone à direita do texto */
+    iconRight?: ReactNode;
+    /** Ícone à esquerda do texto */
+    iconLeft?: ReactNode;
+    /** Size of the badge */
+    size?: 'small' | 'medium' | 'large';
+    /** Visual variant of the badge */
+    variant?: 'solid' | 'outlined' | 'exams' | 'examsOutlined' | 'resultStatus' | 'notification';
+    /** Action type of the badge  */
+    action?: 'error' | 'warning' | 'success' | 'info' | 'muted' | 'exam1' | 'exam2' | 'exam3' | 'exam4' | 'positive' | 'negative';
+    /** Additional CSS classes to apply */
+    className?: string;
+    notificationActive?: boolean;
+} & HTMLAttributes<HTMLDivElement>;
+/**
+ * Badge component for Analytica Ensino platforms
+ *
+ * A flexible button component with multiple variants, sizes and actions.
+ *
+ * @param children - The content to display inside the badge
+ * @param size - The size variant (extra-small, small, medium, large, extra-large)
+ * @param variant - The visual style variant (solid, outline, link)
+ * @param action - The action type (primary, positive, negative)
+ * @param className - Additional CSS classes
+ * @param props - All other standard div HTML attributes
+ * @returns A styled badge element
+ *
+ * @example
+ * ```tsx
+ * <Badge variant="solid" action="info" size="medium">
+ *   Information
+ * </Badge>
+ * ```
+ */
+declare const Badge: ({ children, iconLeft, iconRight, size, variant, action, className, notificationActive, ...props }: BadgeProps) => react_jsx_runtime.JSX.Element;
+
+type AlertProps = {
+    title?: string;
+    description: string;
+    variant?: 'solid' | 'outline';
+    action?: 'default' | 'info' | 'success' | 'warning' | 'error';
+    className?: string;
+} & HTMLAttributes<HTMLDivElement>;
+declare const Alert: ({ variant, title, description, action, className, ...props }: AlertProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * IconButton component for Analytica Ensino platforms
+ *
+ * Um botão compacto apenas com ícone, ideal para menus dropdown,
+ * barras de ferramentas e ações secundárias.
+ * Oferece dois tamanhos com estilo consistente.
+ * Estado ativo permanece até ser clicado novamente ou outro botão ser ativado.
+ * Suporta forwardRef para acesso programático ao elemento DOM.
+ *
+ * @param icon - O ícone a ser exibido no botão
+ * @param size - Tamanho do botão (sm, md)
+ * @param active - Estado ativo/selecionado do botão
+ * @param className - Classes CSS adicionais
+ * @param props - Todos os outros atributos HTML padrão de button
+ * @returns Um elemento button compacto estilizado apenas com ícone
+ *
+ * @example
+ * ```tsx
+ * <IconButton
+ *   icon={<MoreVerticalIcon />}
+ *   size="sm"
+ *   onClick={() => openMenu()}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Botão ativo em uma barra de ferramentas - permanece ativo até outro clique
+ * <IconButton
+ *   icon={<BoldIcon />}
+ *   active={isBold}
+ *   onClick={toggleBold}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Usando ref para controle programático
+ * const buttonRef = useRef<HTMLButtonElement>(null);
+ *
+ * <IconButton
+ *   ref={buttonRef}
+ *   icon={<EditIcon />}
+ *   size="md"
+ *   onClick={() => startEditing()}
+ * />
+ * ```
+ */
+declare const IconButton: react.ForwardRefExoticComponent<{
+    /** Ícone a ser exibido no botão */
+    icon: ReactNode;
+    /** Tamanho do botão */
+    size?: "sm" | "md";
+    /** Estado de seleção/ativo do botão - permanece ativo até ser clicado novamente ou outro botão ser ativado */
+    active?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+} & ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * IconRoundedButton component props interface
+ */
+type IconRoundedButtonProps = {
+    /** Ícone a ser exibido no botão */
+    icon: ReactNode;
+    /** Additional CSS classes to apply */
+    className?: string;
+} & ButtonHTMLAttributes<HTMLButtonElement>;
+/**
+ * IconRoundedButton component for Analytica Ensino platforms
+ *
+ * Um botão redondo simples que exibe apenas um ícone.
+ * Ideal para ações como navegação, fechar, editar, etc.
+ *
+ * @param icon - O ícone a ser exibido no botão
+ * @param className - Classes CSS adicionais
+ * @param props - Todos os outros atributos HTML padrão de button
+ * @returns Um elemento button estilizado e redondo
+ *
+ * @example
+ * ```tsx
+ * <IconRoundedButton
+ *   icon={<ChevronRightIcon />}
+ *   onClick={() => console.log('clicked')}
+ * />
+ * ```
+ */
+declare const IconRoundedButton: ({ icon, className, disabled, ...props }: IconRoundedButtonProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * NavButton component for Analytica Ensino platforms
+ *
+ * Um botão de navegação com ícone e texto para navegação principal.
+ * Ideal para menus de navegação, sidebar, tabs de navegação, etc.
+ * Suporta forwardRef para acesso programático ao elemento DOM.
+ *
+ * @param icon - O ícone a ser exibido no botão
+ * @param label - O texto/label a ser exibido
+ * @param selected - Estado de seleção do botão
+ * @param className - Classes CSS adicionais
+ * @param props - Todos os outros atributos HTML padrão de button
+ * @returns Um elemento button estilizado para navegação
+ *
+ * @example
+ * ```tsx
+ * <NavButton
+ *   icon={<HomeIcon />}
+ *   label="Início"
+ *   selected={false}
+ *   onClick={() => navigate('/')}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Usando ref para foco programático
+ * const buttonRef = useRef<HTMLButtonElement>(null);
+ *
+ * const handleFocus = () => {
+ *   buttonRef.current?.focus();
+ * };
+ *
+ * <NavButton
+ *   ref={buttonRef}
+ *   icon={<HomeIcon />}
+ *   label="Dashboard"
+ *   selected={isActive}
+ *   onClick={() => setActiveTab('dashboard')}
+ * />
+ * ```
+ */
+declare const NavButton: react.ForwardRefExoticComponent<{
+    /** Ícone a ser exibido no botão */
+    icon: ReactNode;
+    /** Texto/label a ser exibido ao lado do ícone */
+    label: string;
+    /** Estado de seleção do botão */
+    selected?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+} & ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * SelectionButton component for Analytica Ensino platforms
+ *
+ * Um botão com ícone e texto para ações e navegação com estado de seleção.
+ * Ideal para filtros, tags, categorias, seleção de tipos, etc.
+ * Suporta forwardRef para acesso programático ao elemento DOM.
+ *
+ * @param icon - O ícone a ser exibido no botão
+ * @param label - O texto/label a ser exibido
+ * @param selected - Estado de seleção do botão
+ * @param className - Classes CSS adicionais
+ * @param props - Todos os outros atributos HTML padrão de button
+ * @returns Um elemento button estilizado
+ *
+ * @example
+ * ```tsx
+ * <SelectionButton
+ *   icon={<TagIcon />}
+ *   label="Categoria"
+ *   selected={false}
+ *   onClick={() => handleSelection()}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Usando ref para foco programático
+ * const buttonRef = useRef<HTMLButtonElement>(null);
+ *
+ * const handleFocus = () => {
+ *   buttonRef.current?.focus();
+ * };
+ *
+ * <SelectionButton
+ *   ref={buttonRef}
+ *   icon={<TagIcon />}
+ *   label="Categoria"
+ *   selected={isSelected}
+ *   onClick={() => setSelected(!isSelected)}
+ * />
+ * ```
+ */
+declare const SelectionButton: react.ForwardRefExoticComponent<{
+    /** Ícone a ser exibido no botão */
+    icon: ReactNode;
+    /** Texto/label a ser exibido ao lado do ícone */
+    label: string;
+    /** Estado de seleção do botão */
+    selected?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+} & ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+declare const Table: react.ForwardRefExoticComponent<HTMLAttributes<HTMLTableElement> & react.RefAttributes<HTMLTableElement>>;
+
+/**
+ * CheckBox size variants
+ */
+type CheckBoxSize = 'small' | 'medium' | 'large';
+/**
+ * CheckBox visual state
+ */
+type CheckBoxState = 'default' | 'hovered' | 'focused' | 'invalid' | 'disabled';
+/**
+ * CheckBox component for Analytica Ensino platforms
+ *
+ * A checkbox component with essential states, sizes and themes.
+ * Uses the Analytica Ensino Design System colors from styles.css with automatic
+ * light/dark mode support. Includes Text component integration for consistent typography.
+ *
+ * @example
+ * ```tsx
+ * // Basic checkbox
+ * <CheckBox label="Option" />
+ *
+ * // Small size
+ * <CheckBox size="small" label="Small option" />
+ *
+ * // Invalid state
+ * <CheckBox state="invalid" label="Required field" />
+ *
+ * // Disabled state
+ * <CheckBox disabled label="Disabled option" />
+ * ```
+ */
+declare const CheckBox: react.ForwardRefExoticComponent<{
+    /** Label text to display next to the checkbox */
+    label?: ReactNode;
+    /** Size variant of the checkbox */
+    size?: CheckBoxSize;
+    /** Visual state of the checkbox */
+    state?: CheckBoxState;
+    /** Indeterminate state for partial selections */
+    indeterminate?: boolean;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Helper text to display */
+    helperText?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label CSS classes */
+    labelClassName?: string;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & react.RefAttributes<HTMLInputElement>>;
+
+/**
+ * CheckboxList size variants
+ */
+type CheckboxListSize = 'small' | 'medium' | 'large';
+/**
+ * CheckboxList visual state
+ */
+type CheckboxListState = 'default' | 'hovered' | 'focused' | 'invalid' | 'disabled';
+/**
+ * CheckboxList store interface
+ */
+interface CheckboxListStore {
+    values: string[];
+    setValues: (values: string[]) => void;
+    toggleValue: (value: string) => void;
+    onValuesChange?: (values: string[]) => void;
+    disabled: boolean;
+    name: string;
+}
+type CheckboxListStoreApi = StoreApi<CheckboxListStore>;
+/**
+ * CheckboxList component for flexible checkbox group composition
+ *
+ * Uses Zustand for state management with automatic store injection.
+ * Allows complete control over layout and styling by composing with CheckboxListItem.
+ *
+ * @example
+ * ```tsx
+ * <CheckboxList defaultValues={["option1"]} onValuesChange={setValues}>
+ *   <div className="flex items-center gap-3">
+ *     <CheckboxListItem value="option1" id="c1" />
+ *     <label htmlFor="c1">Option 1</label>
+ *   </div>
+ *   <div className="flex items-center gap-3">
+ *     <CheckboxListItem value="option2" id="c2" />
+ *     <label htmlFor="c2">Option 2</label>
+ *   </div>
+ * </CheckboxList>
+ * ```
+ */
+declare const CheckboxList: react.ForwardRefExoticComponent<{
+    /** Current selected values */
+    values?: string[];
+    /** Default selected values for uncontrolled usage */
+    defaultValues?: string[];
+    /** Callback when selection changes */
+    onValuesChange?: (values: string[]) => void;
+    /** Group name for all checkboxes */
+    name?: string;
+    /** Disabled state for the entire group */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Children components */
+    children: ReactNode;
+} & Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValues"> & react.RefAttributes<HTMLDivElement>>;
+/**
+ * CheckboxListItem component for use within CheckboxList
+ *
+ * A checkbox without label that works within CheckboxList context.
+ * Provides just the checkbox input for maximum flexibility in composition.
+ *
+ * @example
+ * ```tsx
+ * <CheckboxList defaultValues={["option1"]}>
+ *   <div className="flex items-center gap-3">
+ *     <CheckboxListItem value="option1" id="c1" />
+ *     <label htmlFor="c1">Option 1</label>
+ *   </div>
+ * </CheckboxList>
+ * ```
+ */
+declare const CheckboxListItem: react.ForwardRefExoticComponent<{
+    /** Value for this checkbox item */
+    value: string;
+    /** Store reference (automatically injected by CheckboxList) */
+    store?: CheckboxListStoreApi;
+    /** Disabled state for this specific item */
+    disabled?: boolean;
+    /** Size variant */
+    size?: CheckboxListSize;
+    /** Visual state */
+    state?: CheckboxListState;
+    /** Additional CSS classes */
+    className?: string;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "checked" | "type" | "name" | "onChange"> & react.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Radio size variants
+ */
+type RadioSize = 'small' | 'medium' | 'large' | 'extraLarge';
+/**
+ * Radio visual state
+ */
+type RadioState = 'default' | 'hovered' | 'focused' | 'invalid' | 'disabled';
+/**
+ * Radio component for Analytica Ensino platforms
+ *
+ * A radio button component with essential states, sizes and themes.
+ * Uses the Analytica Ensino Design System colors from styles.css with automatic
+ * light/dark mode support. Includes Text component integration for consistent typography.
+ *
+ * @example
+ * ```tsx
+ * // Basic radio
+ * <Radio name="option" value="1" label="Option 1" />
+ *
+ * // Small size
+ * <Radio size="small" name="option" value="2" label="Small option" />
+ *
+ * // Invalid state
+ * <Radio state="invalid" name="option" value="3" label="Required field" />
+ *
+ * // Disabled state
+ * <Radio disabled name="option" value="4" label="Disabled option" />
+ *
+ * // Default checked (uncontrolled)
+ * <Radio defaultChecked name="option" value="5" label="Initially checked" />
+ * ```
+ */
+declare const Radio: react.ForwardRefExoticComponent<{
+    /** Label text to display next to the radio */
+    label?: ReactNode;
+    /** Size variant of the radio */
+    size?: RadioSize;
+    /** Visual state of the radio */
+    state?: RadioState;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Helper text to display */
+    helperText?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label CSS classes */
+    labelClassName?: string;
+    /** Radio group name */
+    name?: string;
+    /** Radio value */
+    value?: string;
+    /** Default checked state for uncontrolled radios */
+    defaultChecked?: boolean;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "defaultChecked" | "type"> & react.RefAttributes<HTMLInputElement>>;
+/**
+ * RadioGroup store interface
+ */
+interface RadioGroupStore {
+    value: string;
+    setValue: (value: string) => void;
+    onValueChange?: (value: string) => void;
+    disabled: boolean;
+    name: string;
+}
+type RadioGroupStoreApi = StoreApi<RadioGroupStore>;
+/**
+ * RadioGroup component for flexible radio group composition
+ *
+ * Uses Zustand for state management with automatic store injection.
+ * Allows complete control over layout and styling by composing with RadioGroupItem.
+ *
+ * @example
+ * ```tsx
+ * <RadioGroup defaultValue="option1" onValueChange={setValue}>
+ *   <div className="flex items-center gap-3">
+ *     <RadioGroupItem value="option1" id="r1" />
+ *     <label htmlFor="r1">Option 1</label>
+ *   </div>
+ *   <div className="flex items-center gap-3">
+ *     <RadioGroupItem value="option2" id="r2" />
+ *     <label htmlFor="r2">Option 2</label>
+ *   </div>
+ * </RadioGroup>
+ * ```
+ */
+declare const RadioGroup: react.ForwardRefExoticComponent<{
+    /** Current selected value */
+    value?: string;
+    /** Default selected value for uncontrolled usage */
+    defaultValue?: string;
+    /** Callback when selection changes */
+    onValueChange?: (value: string) => void;
+    /** Group name for all radios */
+    name?: string;
+    /** Disabled state for the entire group */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Children components */
+    children: ReactNode;
+} & Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> & react.RefAttributes<HTMLDivElement>>;
+/**
+ * RadioGroupItem component for use within RadioGroup
+ *
+ * A radio button without label that works within RadioGroup context.
+ * Provides just the radio input for maximum flexibility in composition.
+ *
+ * @example
+ * ```tsx
+ * <RadioGroup defaultValue="option1">
+ *   <div className="flex items-center gap-3">
+ *     <RadioGroupItem value="option1" id="r1" />
+ *     <label htmlFor="r1">Option 1</label>
+ *   </div>
+ * </RadioGroup>
+ * ```
+ */
+declare const RadioGroupItem: react.ForwardRefExoticComponent<{
+    /** Value for this radio item */
+    value: string;
+    /** Store reference (automatically injected by RadioGroup) */
+    store?: RadioGroupStoreApi;
+    /** Disabled state for this specific item */
+    disabled?: boolean;
+    /** Size variant */
+    size?: RadioSize;
+    /** Visual state */
+    state?: RadioState;
+    /** Additional CSS classes */
+    className?: string;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "checked" | "type" | "name" | "onChange"> & react.RefAttributes<HTMLInputElement>>;
+
+/**
+ * TextArea size variants
+ */
+type TextAreaSize = 'small' | 'medium' | 'large' | 'extraLarge';
+/**
+ * TextArea visual state
+ */
+type TextAreaState = 'default' | 'hovered' | 'focused' | 'invalid' | 'disabled';
+/**
+ * TextArea component for Analytica Ensino platforms
+ *
+ * A textarea component with essential states, sizes and themes.
+ * Uses exact design specifications with 288px width, 96px height, and specific
+ * color values. Includes Text component integration for consistent typography.
+ *
+ * @example
+ * ```tsx
+ * // Basic textarea
+ * <TextArea label="Description" placeholder="Enter description..." />
+ *
+ * // Small size
+ * <TextArea size="small" label="Comment" />
+ *
+ * // Invalid state
+ * <TextArea state="invalid" label="Required field" errorMessage="This field is required" />
+ *
+ * // Disabled state
+ * <TextArea disabled label="Read-only field" />
+ * ```
+ */
+declare const TextArea: react.ForwardRefExoticComponent<{
+    /** Label text to display above the textarea */
+    label?: ReactNode;
+    /** Size variant of the textarea */
+    size?: TextAreaSize;
+    /** Visual state of the textarea */
+    state?: TextAreaState;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Helper text to display */
+    helperMessage?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label CSS classes */
+    labelClassName?: string;
+} & Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & react.RefAttributes<HTMLTextAreaElement>>;
+
+type ToastPosition$1 = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'default';
+type ToastProps = {
+    title: string;
+    description?: string;
+    onClose: () => void;
+    /** Visual variant of the badge */
+    variant?: 'solid' | 'outlined';
+    /** Action type of the badge  */
+    action?: 'warning' | 'success' | 'info';
+    position?: ToastPosition$1;
+} & HTMLAttributes<HTMLDivElement>;
+declare const Toast: ({ variant, action, className, onClose, title, description, position, ...props }: ToastProps) => react_jsx_runtime.JSX.Element;
+
+declare const Toaster: () => react_jsx_runtime.JSX.Element;
+
+/**
+ * Divider component props interface
+ */
+type DividerProps = {
+    /** Orientation of the divider */
+    orientation?: 'horizontal' | 'vertical';
+    /** Additional CSS classes to apply */
+    className?: string;
+} & HTMLAttributes<HTMLHRElement>;
+/**
+ * Divider component for Analytica Ensino platforms
+ *
+ * A simple divider component that creates a visual separation between content sections.
+ * Can be used both horizontally and vertically.
+ *
+ * @param orientation - The orientation of the divider (horizontal or vertical)
+ * @param className - Additional CSS classes
+ * @param props - All other standard hr HTML attributes
+ * @returns A styled divider element
+ *
+ * @example
+ * ```tsx
+ * <Divider orientation="horizontal" />
+ * <Divider orientation="vertical" className="h-8" />
+ * ```
+ */
+declare const Divider: ({ orientation, className, ...props }: DividerProps) => react_jsx_runtime.JSX.Element;
+
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'default';
+type ToastData = {
+    id: string;
+    title: string;
+    description?: string;
+    variant?: 'solid' | 'outlined';
+    action?: 'warning' | 'success' | 'info';
+    position?: ToastPosition;
+};
+type ToastStore = {
+    toasts: ToastData[];
+    addToast: (toast: Omit<ToastData, 'id'>) => void;
+    removeToast: (id: string) => void;
+};
+declare const useToastStore: zustand.UseBoundStore<zustand.StoreApi<ToastStore>>;
+
+declare const Input: react.ForwardRefExoticComponent<{
+    /** Label text displayed above the input */
+    label?: string;
+    /** Helper text displayed below the input */
+    helperText?: string;
+    /** Error message displayed below the input */
+    errorMessage?: string;
+    /** Size of the input */
+    size?: "small" | "medium" | "large" | "extra-large";
+    /** Visual variant of the input */
+    variant?: "outlined" | "underlined" | "rounded";
+    /** Current state of the input */
+    state?: "default" | "error" | "disabled" | "read-only";
+    /** Icon to display on the left side of the input */
+    iconLeft?: ReactNode;
+    /** Icon to display on the right side of the input */
+    iconRight?: ReactNode;
+    /** Additional CSS classes to apply to the input */
+    className?: string;
+    /** Additional CSS classes to apply to the container */
+    containerClassName?: string;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, "size"> & react.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Chips component props interface
+ */
+type ChipsProps = {
+    /** Content to be displayed inside the chip */
+    children: ReactNode;
+    /** Se o chip está selecionado (mostra check automaticamente) */
+    selected?: boolean;
+    /** Additional CSS classes to apply */
+    className?: string;
+} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
+/**
+ * Chips component for Analytica Ensino platforms
+ *
+ * Um componente de chip seguindo exatamente o design do Figma.
+ * Suporte a dois estados principais: default (sem ícone) e selected (com ícone de check).
+ * Quando selecionado, automaticamente mostra o ícone de check.
+ *
+ * @param children - O conteúdo a ser exibido dentro do chip
+ * @param selected - Se o chip está selecionado (mostra check automaticamente)
+ * @param className - Classes CSS adicionais
+ * @param props - Todos os outros atributos padrão de button HTML
+ * @returns Um elemento de chip estilizado
+ *
+ * @example
+ * ```tsx
+ * <Chips onClick={() => console.log('clicked')}>
+ *   Label
+ * </Chips>
+ *
+ * <Chips selected onClick={() => console.log('selected')}>
+ *   Selected Label
+ * </Chips>
+ * ```
+ */
+declare const Chips: ({ children, selected, className, disabled, type, ...props }: ChipsProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Progress bar size variants
+ */
+type ProgressBarSize = 'small' | 'medium';
+/**
+ * Progress bar color variants
+ */
+type ProgressBarVariant = 'blue' | 'green';
+/**
+ * Progress bar layout variants
+ */
+type ProgressBarLayout = 'default' | 'stacked' | 'compact';
+/**
+ * ProgressBar component props interface
+ */
+type ProgressBarProps = {
+    /** Progress value between 0 and 100 */
+    value: number;
+    /** Maximum value (defaults to 100) */
+    max?: number;
+    /** Size variant of the progress bar */
+    size?: ProgressBarSize;
+    /** Color variant of the progress bar */
+    variant?: ProgressBarVariant;
+    /** Layout variant of the progress bar */
+    layout?: ProgressBarLayout;
+    /** Optional label to display */
+    label?: ReactNode;
+    /** Show percentage text */
+    showPercentage?: boolean;
+    /**
+     * Show hit count (e.g., "28 de 30") instead of percentage
+     *
+     * PRIORITY: When both showHitCount and showPercentage are true,
+     * showHitCount takes precedence (stacked and compact layouts only).
+     * Default layout does not support showHitCount.
+     */
+    showHitCount?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label CSS classes */
+    labelClassName?: string;
+    /** Percentage text CSS classes */
+    percentageClassName?: string;
+    /** Custom width for stacked layout (defaults to w-[380px]) */
+    stackedWidth?: string;
+    /** Custom height for stacked layout (defaults to h-[35px]) */
+    stackedHeight?: string;
+    /** Custom width for compact layout (defaults to w-[131px]) */
+    compactWidth?: string;
+    /** Custom height for compact layout (defaults to h-[24px]) */
+    compactHeight?: string;
+};
+/**
+ * ProgressBar component for Analytica Ensino platforms
+ *
+ * A progress bar component with size and color variants designed for tracking
+ * activity progress (blue) and performance metrics (green).
+ * Uses the Analytica Ensino Design System colors from styles.css with automatic
+ * light/dark mode support. Includes Text component integration for consistent typography.
+ *
+ * CONTENT DISPLAY PRIORITY (Consistent across all layouts):
+ * 1. showHitCount (highest) - "X de Y" format (stacked/compact only)
+ * 2. showPercentage - "X%" format
+ * 3. label (lowest) - Custom label text
+ *
+ * When multiple display options are enabled, higher priority options take precedence.
+ *
+ * @example
+ * ```tsx
+ * // Basic progress bar
+ * <ProgressBar value={65} />
+ *
+ * // Activity progress (blue)
+ * <ProgressBar variant="blue" value={45} label="Progress" showPercentage />
+ *
+ * // Performance metrics (green)
+ * <ProgressBar variant="green" size="medium" value={85} label="Performance" />
+ *
+ * // Small size with custom max value
+ * <ProgressBar size="small" value={3} max={5} showPercentage />
+ *
+ * // Stacked layout with fixed width and hit count
+ * <ProgressBar layout="stacked" variant="green" value={28} max={30} label="Fáceis" showHitCount />
+ *
+ * // Compact layout for small cards
+ * <ProgressBar layout="compact" variant="blue" value={70} label="Questão 08" />
+ * ```
+ */
+declare const ProgressBar: ({ value, max, size, variant, layout, label, showPercentage, showHitCount, className, labelClassName, percentageClassName, stackedWidth, stackedHeight, compactWidth, compactHeight, }: ProgressBarProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Progress circle size variants
+ */
+type ProgressCircleSize = 'small' | 'medium';
+/**
+ * Progress circle color variants
+ */
+type ProgressCircleVariant = 'blue' | 'green';
+/**
+ * ProgressCircle component props interface
+ */
+type ProgressCircleProps = {
+    /** Progress value between 0 and 100 */
+    value: number;
+    /** Maximum value (defaults to 100) */
+    max?: number;
+    /** Size variant of the progress circle */
+    size?: ProgressCircleSize;
+    /** Color variant of the progress circle */
+    variant?: ProgressCircleVariant;
+    /** Optional label to display below percentage */
+    label?: ReactNode;
+    /** Show percentage text */
+    showPercentage?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label CSS classes */
+    labelClassName?: string;
+    /** Percentage text CSS classes */
+    percentageClassName?: string;
+};
+/**
+ * ProgressCircle component for Analytica Ensino platforms
+ *
+ * A circular progress indicator with size and color variants designed for tracking
+ * activity progress (blue) and performance metrics (green).
+ * Uses the Analytica Ensino Design System colors from styles.css with automatic
+ * light/dark mode support. Includes Text component integration for consistent typography.
+ *
+ * @example
+ * ```tsx
+ * // Basic progress circle
+ * <ProgressCircle value={65} />
+ *
+ * // Activity progress (blue)
+ * <ProgressCircle variant="blue" value={45} label="CONCLUÍDO" showPercentage />
+ *
+ * // Performance metrics (green)
+ * <ProgressCircle variant="green" size="medium" value={85} label="MÉDIA" />
+ *
+ * // Small size with custom max value
+ * <ProgressCircle size="small" value={3} max={5} showPercentage />
+ * ```
+ */
+declare const ProgressCircle: ({ value, max, size, variant, label, showPercentage, className, labelClassName, percentageClassName, }: ProgressCircleProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Stepper size variants
+ */
+type StepperSize = 'small' | 'medium' | 'large' | 'extraLarge';
+/**
+ * Step state variants
+ */
+type StepState = 'pending' | 'current' | 'completed';
+/**
+ * Individual step data interface
+ */
+interface StepData {
+    /** Unique identifier for the step */
+    id: string;
+    /** Label text for the step */
+    label: string;
+    /** Current state of the step */
+    state: StepState;
+}
+/**
+ * Stepper component props interface
+ */
+type StepperProps = {
+    /** Array of step data */
+    steps: StepData[];
+    /** Size variant of the stepper */
+    size?: StepperSize;
+    /** Current active step index */
+    currentStep?: number;
+    /** Additional CSS classes */
+    className?: string;
+    /** Step container CSS classes */
+    stepClassName?: string;
+    /** Progress indicator (e.g., "Etapa 2 de 4") */
+    showProgress?: boolean;
+    /** Custom progress text */
+    progressText?: string;
+    /** Make stepper responsive (vertical on mobile) */
+    responsive?: boolean;
+};
+/**
+ * Stepper component for Analytica Ensino platforms
+ *
+ * A progress stepper component that displays a sequence of steps with different states.
+ * Follows the exact design specifications with proper spacing, colors, and layout.
+ * Fully responsive for mobile, tablets, and laptops.
+ *
+ * Design specifications:
+ * - Based on exact CSS specifications from Figma design
+ * - Fully responsive: mobile (320px+) -> tablets (640px+) -> laptops (1024px+)
+ * - Progressive sizing with responsive breakpoints that adapt to device type
+ * - Consistent gaps that scale with screen size and device capabilities
+ * - Consistent color scheme: pending (gray), current (dark blue), completed (light blue)
+ * - Responsive design with overflow scroll on smaller devices
+ * - Optimized text sizing and layout for each device category
+ *
+ * @example
+ * ```tsx
+ * // Basic stepper - automatically responsive for all devices
+ * <Stepper steps={steps} currentStep={1} />
+ *
+ * // Custom styling with full responsive behavior
+ * <Stepper steps={steps} size="medium" showProgress responsive />
+ * ```
+ */
+declare const Stepper: ({ steps: initialSteps, size, currentStep, className, stepClassName, showProgress, progressText, responsive, }: StepperProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Activity status types for calendar days
+ */
+type ActivityStatus = 'near-deadline' | 'overdue' | 'in-deadline';
+/**
+ * Activity data for a specific day
+ */
+interface CalendarActivity {
+    id: string;
+    status: ActivityStatus;
+    title?: string;
+}
+/**
+ * Calendar variant types
+ */
+type CalendarVariant = 'navigation' | 'selection';
+/**
+ * Calendar component props
+ */
+interface CalendarProps {
+    /** Calendar variant - navigation (compact) or selection (full) */
+    variant?: CalendarVariant;
+    /** Currently selected date */
+    selectedDate?: Date;
+    /** Function called when a date is selected */
+    onDateSelect?: (date: Date) => void;
+    /** Function called when month changes */
+    onMonthChange?: (date: Date) => void;
+    /** Activities data for calendar days */
+    activities?: Record<string, CalendarActivity[]>;
+    /** Show activities indicators */
+    showActivities?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Calendar component for Analytica Ensino platforms
+ *
+ * A comprehensive calendar component with activity indicators,
+ * date selection, and navigation capabilities.
+ */
+declare const Calendar: ({ variant, selectedDate, onDateSelect, onMonthChange, activities, showActivities, className, }: CalendarProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Modal component props interface
+ */
+type ModalProps = {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Function to close the modal */
+    onClose: () => void;
+    /** Modal title */
+    title: string;
+    /** Modal description/content */
+    children: ReactNode;
+    /** Size of the modal */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Additional CSS classes for the modal content */
+    className?: string;
+    /** Whether clicking the backdrop should close the modal */
+    closeOnBackdropClick?: boolean;
+    /** Whether pressing Escape should close the modal */
+    closeOnEscape?: boolean;
+    /** Footer content (typically buttons) */
+    footer?: ReactNode;
+    /** Hide the close button */
+    hideCloseButton?: boolean;
+};
+/**
+ * Modal component for Analytica Ensino platforms
+ *
+ * A flexible modal component with multiple size variants and customizable behavior.
+ *
+ * @param isOpen - Whether the modal is currently open
+ * @param onClose - Callback function called when the modal should be closed
+ * @param title - The title displayed at the top of the modal
+ * @param children - The main content of the modal
+ * @param size - The size variant (xs, sm, md, lg, xl)
+ * @param className - Additional CSS classes for the modal content
+ * @param closeOnBackdropClick - Whether clicking the backdrop closes the modal (default: true)
+ * @param closeOnEscape - Whether pressing Escape closes the modal (default: true)
+ * @param footer - Footer content, typically action buttons
+ * @param hideCloseButton - Whether to hide the X close button (default: false)
+ * @returns A modal overlay with content
+ *
+ * @example
+ * ```tsx
+ * <Modal
+ *   isOpen={isModalOpen}
+ *   onClose={() => setIsModalOpen(false)}
+ *   title="Invite your team"
+ *   size="md"
+ *   footer={
+ *     <div className="flex gap-3">
+ *       <Button variant="outline" onClick={() => setIsModalOpen(false)}>Cancel</Button>
+ *       <Button variant="solid" onClick={handleExplore}>Explore</Button>
+ *     </div>
+ *   }
+ * >
+ *   Elevate user interactions with our versatile modals.
+ * </Modal>
+ * ```
+ */
+declare const Modal: ({ isOpen, onClose, title, children, size, className, closeOnBackdropClick, closeOnEscape, footer, hideCloseButton, }: ModalProps) => react_jsx_runtime.JSX.Element | null;
+
+interface CardAccordationProps extends HTMLAttributes<HTMLDivElement> {
+    trigger: ReactNode;
+    children: ReactNode;
+    defaultExpanded?: boolean;
+    onToggleExpanded?: (isExpanded: boolean) => void;
+}
+declare const CardAccordation: react.ForwardRefExoticComponent<CardAccordationProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Interface para definir uma alternativa
+ */
+interface Alternative {
+    value: string;
+    label: string;
+    status?: 'correct' | 'incorrect' | 'neutral';
+    disabled?: boolean;
+    description?: string;
+}
+/**
+ * Props do componente AlternativesList
+ */
+interface AlternativesListProps {
+    /** Lista de alternativas */
+    alternatives: Alternative[];
+    /** Nome do grupo de radio */
+    name?: string;
+    /** Valor selecionado por padrão */
+    defaultValue?: string;
+    /** Valor controlado */
+    value?: string;
+    /** Callback quando uma alternativa é selecionada */
+    onValueChange?: (value: string) => void;
+    /** Se o componente está desabilitado */
+    disabled?: boolean;
+    /** Layout das alternativas */
+    layout?: 'default' | 'compact' | 'detailed';
+    /** Classes CSS adicionais */
+    className?: string;
+    /** Modo de exibição: interativo (com radios funcionais) ou readonly (apenas visual) */
+    mode?: 'interactive' | 'readonly';
+    /** Valor selecionado pelo usuário (apenas para modo readonly) */
+    selectedValue?: string;
+}
+/**
+ * Componente reutilizável para exibir lista de alternativas com RadioGroup
+ *
+ * Suporta dois modos:
+ * - `interactive`: Permite interação com radios (padrão)
+ * - `readonly`: Apenas exibição visual dos estados
+ *
+ * @example
+ * ```tsx
+ * // Modo interativo (padrão)
+ * <AlternativesList
+ *   mode="interactive"
+ *   alternatives={[
+ *     { value: "a", label: "Alternativa A", status: "correct" },
+ *     { value: "b", label: "Alternativa B", status: "incorrect" },
+ *     { value: "c", label: "Alternativa C" }
+ *   ]}
+ *   defaultValue="a"
+ *   onValueChange={(value) => console.log(value)}
+ * />
+ *
+ * // Modo readonly - mostra seleção do usuário
+ * <AlternativesList
+ *   mode="readonly"
+ *   selectedValue="b"  // O que o usuário selecionou
+ *   alternatives={[
+ *     { value: "a", label: "Resposta A", status: "correct" },  // Mostra como correta
+ *     { value: "b", label: "Resposta B" },  // Mostra radio selecionado + badge incorreto
+ *     { value: "c", label: "Resposta C" }
+ *   ]}
+ * />
+ * ```
+ */
+declare const AlternativesList: ({ alternatives, name, defaultValue, value, onValueChange, disabled, layout, className, mode, selectedValue, }: AlternativesListProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertDialogProps extends HTMLAttributes<HTMLDivElement> {
+    /** Title of the alert dialog */
+    title: string;
+    /** Whether the alert dialog is open (controlled mode) */
+    isOpen: boolean;
+    /** Function called when the alert dialog is opened or closed (controlled mode) */
+    onChangeOpen: (open: boolean) => void;
+    /** Whether clicking the backdrop should close the alert dialog */
+    closeOnBackdropClick?: boolean;
+    /** Whether pressing Escape should close the alert dialog */
+    closeOnEscape?: boolean;
+    /** Additional CSS classes for the alert dialog content */
+    className?: string;
+    /** Function called when submit button is clicked */
+    onSubmit?: (value?: unknown) => void;
+    /** Value to pass to onSubmit function */
+    submitValue?: unknown;
+    /** Function called when cancel button is clicked */
+    onCancel?: (value?: unknown) => void;
+    /** Value to pass to onCancel function */
+    cancelValue?: unknown;
+    /** Description of the alert dialog */
+    description: string;
+    /** Label of the cancel button */
+    cancelButtonLabel?: string;
+    /** Label of the submit button */
+    submitButtonLabel?: string;
+    /** Size of the alert dialog */
+    size?: 'extra-small' | 'small' | 'medium' | 'large' | 'extra-large';
+}
+declare const AlertDialog: react.ForwardRefExoticComponent<AlertDialogProps & react.RefAttributes<HTMLDivElement>>;
+
+interface Choice {
+    value: string;
+    label: string;
+    status?: 'correct' | 'incorrect' | 'neutral';
+    disabled?: boolean;
+}
+interface MultipleChoiceListProps extends HtmlHTMLAttributes<HTMLDivElement> {
+    choices: Choice[];
+    disabled?: boolean;
+    name?: string;
+    selectedValues?: string[];
+    onHandleSelectedValues?: (values: string[]) => void;
+    mode?: 'interactive' | 'readonly';
+}
+declare const MultipleChoiceList: ({ disabled, className, choices, name, selectedValues, onHandleSelectedValues, mode, }: MultipleChoiceListProps) => react_jsx_runtime.JSX.Element;
+
+interface DropdownStore {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}
+type DropdownStoreApi = StoreApi<DropdownStore>;
+interface DropdownMenuProps {
+    children: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const DropdownMenu: ({ children, open: propOpen, onOpenChange, }: DropdownMenuProps) => react_jsx_runtime.JSX.Element;
+declare const DropdownMenuTrigger: {
+    ({ className, children, onClick, store: externalStore, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+        disabled?: boolean;
+        store?: DropdownStoreApi;
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const MenuLabel: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    inset?: boolean;
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    align?: "start" | "center" | "end";
+    side?: "top" | "right" | "bottom" | "left";
+    variant?: "menu" | "profile";
+    sideOffset?: number;
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    inset?: boolean;
+    size?: "small" | "medium";
+    iconLeft?: ReactNode;
+    iconRight?: ReactNode;
+    disabled?: boolean;
+    variant?: "profile" | "menu";
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ProfileMenuTrigger: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & {
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLButtonElement>>;
+declare const ProfileMenuHeader: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    name: string;
+    email: string;
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ProfileMenuSection: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    store?: DropdownStoreApi;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const ProfileMenuFooter: {
+    ({ className, disabled, onClick, store: externalStore, ...props }: HTMLAttributes<HTMLButtonElement> & {
+        disabled?: boolean;
+        store?: DropdownStoreApi;
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface SelectStore {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    value: string;
+    setValue: (value: string) => void;
+    selectedLabel: ReactNode;
+    setSelectedLabel: (label: ReactNode) => void;
+    onValueChange?: (value: string) => void;
+}
+type SelectStoreApi = StoreApi<SelectStore>;
+interface SelectProps {
+    children: ReactNode;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    size?: 'small' | 'medium' | 'large' | 'extra-large';
+    label?: string;
+    helperText?: string;
+    errorMessage?: string;
+    id?: string;
+}
+declare const Select: ({ children, defaultValue, value: propValue, onValueChange, size, label, helperText, errorMessage, id, }: SelectProps) => react_jsx_runtime.JSX.Element;
+declare const SelectValue: ({ placeholder, store: externalStore, }: {
+    placeholder?: string;
+    store?: SelectStoreApi;
+}) => react_jsx_runtime.JSX.Element;
+interface SelectTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    invalid?: boolean;
+    variant?: 'outlined' | 'underlined' | 'rounded';
+    store?: SelectStoreApi;
+    size?: 'small' | 'medium' | 'large' | 'extra-large';
+    selectId?: string;
+}
+declare const SelectTrigger: react.ForwardRefExoticComponent<SelectTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface SelectContentProps extends HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    store?: SelectStoreApi;
+}
+declare const SelectContent: react.ForwardRefExoticComponent<SelectContentProps & react.RefAttributes<HTMLDivElement>>;
+interface SelectItemProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+    disabled?: boolean;
+    store?: SelectStoreApi;
+}
+declare const SelectItem: react.ForwardRefExoticComponent<SelectItemProps & react.RefAttributes<HTMLDivElement>>;
+
+type MenuVariant = 'menu' | 'menu2' | 'breadcrumb';
+interface MenuStore {
+    value: string;
+    setValue: (value: string) => void;
+    onValueChange?: (value: string) => void;
+}
+type MenuStoreApi = StoreApi<MenuStore>;
+interface MenuProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    defaultValue: string;
+    value?: string;
+    variant?: MenuVariant;
+    onValueChange?: (value: string) => void;
+}
+declare const Menu: react.ForwardRefExoticComponent<MenuProps & react.RefAttributes<HTMLDivElement>>;
+interface MenuContentProps extends HTMLAttributes<HTMLUListElement> {
+    children: ReactNode;
+    variant?: MenuVariant;
+}
+declare const MenuContent: react.ForwardRefExoticComponent<MenuContentProps & react.RefAttributes<HTMLUListElement>>;
+interface MenuItemProps extends HTMLAttributes<HTMLLIElement> {
+    value: string;
+    disabled?: boolean;
+    store?: MenuStoreApi;
+    variant?: MenuVariant;
+    separator?: boolean;
+}
+declare const MenuItem: react.ForwardRefExoticComponent<MenuItemProps & react.RefAttributes<HTMLLIElement>>;
+interface MenuOverflowProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    defaultValue: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const MenuOverflow: ({ children, className, defaultValue, value, onValueChange, ...props }: MenuOverflowProps) => react_jsx_runtime.JSX.Element;
+
+interface CardActivitiesResultsProps extends HTMLAttributes<HTMLDivElement> {
+    icon: ReactNode;
+    title: string;
+    subTitle: string;
+    header: string;
+    description?: string;
+    extended?: boolean;
+    action?: 'warning' | 'success' | 'error' | 'info';
+}
+declare const CardActivitiesResults: react.ForwardRefExoticComponent<CardActivitiesResultsProps & react.RefAttributes<HTMLDivElement>>;
+interface CardQuestionProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    state?: 'done' | 'undone';
+    onClickButton?: (valueButton?: unknown) => void;
+    valueButton?: unknown;
+}
+declare const CardQuestions: react.ForwardRefExoticComponent<CardQuestionProps & react.RefAttributes<HTMLDivElement>>;
+interface CardProgressProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    subhead?: string;
+    initialDate?: string;
+    endDate?: string;
+    progress?: number;
+    direction?: 'horizontal' | 'vertical';
+    icon: ReactNode;
+    color?: string;
+    progressVariant?: 'blue' | 'green';
+    showDates?: boolean;
+}
+declare const CardProgress: react.ForwardRefExoticComponent<CardProgressProps & react.RefAttributes<HTMLDivElement>>;
+interface CardTopicProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    subHead?: string[];
+    progress: number;
+    showPercentage?: boolean;
+    progressVariant?: 'blue' | 'green';
+}
+declare const CardTopic: react.ForwardRefExoticComponent<CardTopicProps & react.RefAttributes<HTMLDivElement>>;
+interface CardPerformanceProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    description?: string;
+    progress?: number;
+    labelProgress?: string;
+    actionVariant?: 'button' | 'caret';
+    progressVariant?: 'blue' | 'green';
+    onClickButton?: (valueButton?: unknown) => void;
+    valueButton?: unknown;
+}
+declare const CardPerformance: react.ForwardRefExoticComponent<CardPerformanceProps & react.RefAttributes<HTMLDivElement>>;
+interface CardResultsProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    icon: ReactNode;
+    correct_answers: number;
+    incorrect_answers: number;
+    direction?: 'row' | 'col';
+    color?: string;
+}
+declare const CardResults: react.ForwardRefExoticComponent<CardResultsProps & react.RefAttributes<HTMLDivElement>>;
+interface CardStatusProps extends HTMLAttributes<HTMLDivElement> {
+    header: string;
+    status?: 'correct' | 'incorrect';
+    label?: string;
+}
+declare const CardStatus: react.ForwardRefExoticComponent<CardStatusProps & react.RefAttributes<HTMLDivElement>>;
+interface CardSimuladoProps extends HTMLAttributes<HTMLDivElement> {
+    title: string;
+    duration?: string;
+    info: string;
+    backgroundColor: 'enem' | 'prova' | 'simuladao' | 'vestibular';
+}
+declare const CardSimulado: react.ForwardRefExoticComponent<CardSimuladoProps & react.RefAttributes<HTMLDivElement>>;
+interface CardTestProps extends Omit<HTMLAttributes<HTMLElement>, 'onSelect'> {
+    title: string;
+    duration?: string;
+    questionsCount?: number;
+    additionalInfo?: string;
+    selected?: boolean;
+    onSelect?: (selected: boolean) => void;
+}
+declare const CardTest: react.ForwardRefExoticComponent<CardTestProps & react.RefAttributes<HTMLElement>>;
+interface SimulationItem {
+    id: string;
+    title: string;
+    type: 'enem' | 'prova' | 'simulado' | 'vestibular';
+    info: string;
+}
+interface SimulationHistoryData {
+    date: string;
+    simulations: SimulationItem[];
+}
+interface CardSimulationHistoryProps extends HTMLAttributes<HTMLDivElement> {
+    data: SimulationHistoryData[];
+    onSimulationClick?: (simulation: SimulationItem) => void;
+}
+declare const CardSimulationHistory: react.ForwardRefExoticComponent<CardSimulationHistoryProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'text' | 'circular' | 'rectangular' | 'rounded';
+    width?: string | number;
+    height?: string | number;
+    animation?: 'pulse' | 'none';
+    lines?: number;
+    spacing?: 'none' | 'small' | 'medium' | 'large';
+}
+declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLDivElement>>;
+declare const SkeletonText: react.ForwardRefExoticComponent<Omit<SkeletonProps, "variant"> & react.RefAttributes<HTMLDivElement>>;
+declare const SkeletonCircle: react.ForwardRefExoticComponent<Omit<SkeletonProps, "variant"> & react.RefAttributes<HTMLDivElement>>;
+declare const SkeletonRectangle: react.ForwardRefExoticComponent<Omit<SkeletonProps, "variant"> & react.RefAttributes<HTMLDivElement>>;
+declare const SkeletonRounded: react.ForwardRefExoticComponent<Omit<SkeletonProps, "variant"> & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonCardProps extends HTMLAttributes<HTMLDivElement> {
+    showAvatar?: boolean;
+    showTitle?: boolean;
+    showDescription?: boolean;
+    showActions?: boolean;
+    lines?: number;
+}
+declare const SkeletonCard: react.ForwardRefExoticComponent<SkeletonCardProps & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonListProps extends HTMLAttributes<HTMLDivElement> {
+    items?: number;
+    showAvatar?: boolean;
+    showTitle?: boolean;
+    showDescription?: boolean;
+    lines?: number;
+}
+declare const SkeletonList: react.ForwardRefExoticComponent<SkeletonListProps & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonTableProps extends HTMLAttributes<HTMLDivElement> {
+    rows?: number;
+    columns?: number;
+    showHeader?: boolean;
+}
+declare const SkeletonTable: react.ForwardRefExoticComponent<SkeletonTableProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Props interface for the NotFound component
+ *
+ * @interface NotFoundProps
+ * @property {string} [title] - Custom title text (default: "Página não encontrada")
+ * @property {string} [description] - Custom description text
+ * @property {string} [buttonText] - Custom button text (default: "Voltar")
+ * @property {() => void} [onButtonClick] - Callback function for button click
+ * @property {string} [className] - Additional CSS classes for the container
+ * @property {'404' | '500' | 'custom'} [errorType] - Type of error to display (default: '404')
+ * @property {string} [customErrorCode] - Custom error code when errorType is 'custom'
+ */
+interface NotFoundProps {
+    title?: string;
+    description?: string;
+    buttonText?: string;
+    onButtonClick?: () => void;
+    className?: string;
+    errorType?: '404' | '500' | 'custom';
+    customErrorCode?: string;
+}
+/**
+ * NotFound component for displaying error pages
+ *
+ * A reusable component for displaying 404, 500, or custom error pages
+ * with configurable content and navigation button.
+ *
+ * @param {NotFoundProps} props - The component props
+ * @returns {JSX.Element} The NotFound component
+ *
+ * @example
+ * ```typescript
+ * // Basic 404 page
+ * <NotFound onButtonClick={() => navigate('/dashboard')} />
+ *
+ * // Custom error page
+ * <NotFound
+ *   errorType="500"
+ *   title="Erro interno do servidor"
+ *   description="Algo deu errado. Tente novamente mais tarde."
+ *   buttonText="Tentar novamente"
+ *   onButtonClick={() => window.location.reload()}
+ * />
+ *
+ * // Custom error code
+ * <NotFound
+ *   errorType="custom"
+ *   customErrorCode="403"
+ *   title="Acesso negado"
+ *   description="Você não tem permissão para acessar esta página."
+ * />
+ * ```
+ */
+declare const NotFound: ({ title, description, buttonText, onButtonClick, className, errorType, customErrorCode, }: NotFoundProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Interface for basic authentication tokens
+ *
+ * @interface AuthTokens
+ * @property {string} token - Main authentication token
+ * @property {string} refreshToken - Token used to refresh the main token
+ * @property {unknown} [key] - Additional properties that can be included
+ */
+interface AuthTokens {
+    token: string;
+    refreshToken: string;
+    [key: string]: unknown;
+}
+/**
+ * Interface for basic user information
+ *
+ * @interface AuthUser
+ * @property {string} id - Unique user identifier
+ * @property {string} [name] - Optional user name
+ * @property {string} [email] - Optional user email
+ * @property {unknown} [key] - Additional user properties
+ */
+interface AuthUser {
+    id: string;
+    name?: string;
+    email?: string;
+    [key: string]: unknown;
+}
+/**
+ * Interface for basic session information
+ *
+ * @interface SessionInfo
+ * @property {string} [institutionId] - Optional institution identifier
+ * @property {string} [profileId] - Optional profile identifier
+ * @property {string} [schoolId] - Optional school identifier
+ * @property {string} [schoolYearId] - Optional school year identifier
+ * @property {string} [classId] - Optional class identifier
+ * @property {unknown} [key] - Additional session properties
+ */
+interface SessionInfo {
+    institutionId?: string;
+    profileId?: string;
+    schoolId?: string;
+    schoolYearId?: string;
+    classId?: string;
+    [key: string]: unknown;
+}
+/**
+ * Interface for authentication state
+ *
+ * @interface AuthState
+ * @property {boolean} isAuthenticated - Whether the user is authenticated
+ * @property {boolean} isLoading - Whether authentication is being checked
+ * @property {AuthUser | null} [user] - Current user information
+ * @property {SessionInfo | null} [sessionInfo] - Current session information
+ * @property {AuthTokens | null} [tokens] - Current authentication tokens
+ */
+interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user?: AuthUser | null;
+    sessionInfo?: SessionInfo | null;
+    tokens?: AuthTokens | null;
+}
+/**
+ * Interface for authentication context functions and state
+ *
+ * @interface AuthContextType
+ * @extends {AuthState}
+ * @property {() => Promise<boolean>} checkAuth - Function to check authentication status
+ * @property {() => void} signOut - Function to sign out the user
+ */
+interface AuthContextType extends AuthState {
+    checkAuth: () => Promise<boolean>;
+    signOut: () => void;
+}
+/**
+ * Props for the AuthProvider component
+ *
+ * @interface AuthProviderProps
+ * @property {ReactNode} children - Child components
+ * @property {() => Promise<boolean> | boolean} [checkAuthFn] - Function to check if user is authenticated
+ * @property {() => void} [signOutFn] - Function to handle logout
+ * @property {Partial<AuthState>} [initialAuthState] - Initial authentication state
+ * @property {() => AuthUser | null | undefined} [getUserFn] - Function to get user data
+ * @property {() => SessionInfo | null | undefined} [getSessionFn] - Function to get session info
+ * @property {() => AuthTokens | null | undefined} [getTokensFn] - Function to get tokens
+ */
+interface AuthProviderProps {
+    children: ReactNode;
+    /**
+     * Função para verificar se o usuário está autenticado
+     * Deve retornar uma Promise<boolean>
+     */
+    checkAuthFn?: () => Promise<boolean> | boolean;
+    /**
+     * Função para fazer logout
+     */
+    signOutFn?: () => void;
+    /**
+     * Estado de autenticação inicial
+     */
+    initialAuthState?: Partial<AuthState>;
+    /**
+     * Função para obter dados do usuário (opcional)
+     */
+    getUserFn?: () => AuthUser | null | undefined;
+    /**
+     * Função para obter informações da sessão (opcional)
+     */
+    getSessionFn?: () => SessionInfo | null | undefined;
+    /**
+     * Função para obter tokens (opcional)
+     */
+    getTokensFn?: () => AuthTokens | null | undefined;
+}
+/**
+ * Authentication provider that manages global auth state
+ * Compatible with any store (Zustand, Redux, Context, etc.)
+ *
+ * @param {AuthProviderProps} props - The provider props
+ * @returns {JSX.Element} The provider component
+ *
+ * @example
+ * ```tsx
+ * <AuthProvider
+ *   checkAuthFn={checkAuthFunction}
+ *   signOutFn={signOutFunction}
+ *   getUserFn={getUserFunction}
+ * >
+ *   <App />
+ * </AuthProvider>
+ * ```
+ */
+declare const AuthProvider: ({ children, checkAuthFn, signOutFn, initialAuthState, getUserFn, getSessionFn, getTokensFn, }: AuthProviderProps) => react_jsx_runtime.JSX.Element;
+/**
+ * Hook to use the authentication context
+ *
+ * @throws {Error} When used outside of AuthProvider
+ * @returns {AuthContextType} The authentication context
+ *
+ * @example
+ * ```tsx
+ * const { isAuthenticated, user, signOut } = useAuth();
+ * ```
+ */
+declare const useAuth: () => AuthContextType;
+/**
+ * Props for the ProtectedRoute component
+ *
+ * @interface ProtectedRouteProps
+ * @property {ReactNode} children - Components to render when authenticated
+ * @property {string} [redirectTo] - Path to redirect when not authenticated (default: '/')
+ * @property {ReactNode} [loadingComponent] - Custom loading component
+ * @property {(authState: AuthState) => boolean} [additionalCheck] - Additional authentication check
+ */
+interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Path para redirecionamento quando não autenticado
+     */
+    redirectTo?: string;
+    /**
+     * Componente de loading personalizado
+     */
+    loadingComponent?: ReactNode;
+    /**
+     * Função adicional de verificação (ex: verificar permissões específicas)
+     */
+    additionalCheck?: (authState: AuthState) => boolean;
+}
+/**
+ * Componente para proteger rotas que requerem autenticação
+ *
+ * @example
+ * ```tsx
+ * <ProtectedRoute redirectTo="/login">
+ *   <PainelPage />
+ * </ProtectedRoute>
+ * ```
+ */
+declare const ProtectedRoute: ({ children, redirectTo, loadingComponent, additionalCheck, }: ProtectedRouteProps) => react_jsx_runtime.JSX.Element | null;
+/**
+ * Props for the PublicRoute component
+ *
+ * @interface PublicRouteProps
+ * @property {ReactNode} children - Components to render
+ * @property {string} [redirectTo] - Path to redirect to (default: '/painel')
+ * @property {boolean} [redirectIfAuthenticated] - Whether to redirect if authenticated
+ * @property {boolean} [checkAuthBeforeRender] - Whether to check auth before rendering
+ */
+interface PublicRouteProps {
+    children: ReactNode;
+    /**
+     * Path para redirecionamento
+     */
+    redirectTo?: string;
+    /**
+     * Se deve redirecionar quando usuário estiver autenticado
+     */
+    redirectIfAuthenticated?: boolean;
+    /**
+     * Se deve verificar autenticação antes de renderizar
+     */
+    checkAuthBeforeRender?: boolean;
+}
+/**
+ * Componente para rotas públicas (login, recuperação de senha, etc.)
+ * Opcionalmente redireciona se o usuário já estiver autenticado
+ *
+ * @example
+ * ```tsx
+ * <PublicRoute redirectTo="/painel" redirectIfAuthenticated={true}>
+ *   <LoginPage />
+ * </PublicRoute>
+ * ```
+ */
+declare const PublicRoute: ({ children, redirectTo, redirectIfAuthenticated, checkAuthBeforeRender, }: PublicRouteProps) => react_jsx_runtime.JSX.Element;
+/**
+ * Higher-Order Component to protect components with authentication
+ *
+ * @template P - Component props type
+ * @param {ComponentType<P>} Component - Component to wrap with authentication
+ * @param {Omit<ProtectedRouteProps, 'children'>} [options] - Protection options
+ * @returns {(props: P) => JSX.Element} Wrapped component
+ *
+ * @example
+ * ```tsx
+ * const ProtectedComponent = withAuth(MyComponent, {
+ *   redirectTo: "/login",
+ *   loadingComponent: <CustomSpinner />
+ * });
+ * ```
+ */
+declare const withAuth: <P extends object>(Component: ComponentType<P>, options?: Omit<ProtectedRouteProps, "children">) => (props: P) => react_jsx_runtime.JSX.Element;
+/**
+ * Hook for authentication guard with custom checks
+ *
+ * @param {object} [options] - Guard options
+ * @param {boolean} [options.requireAuth=true] - Whether authentication is required
+ * @param {(authState: AuthState) => boolean} [options.customCheck] - Custom check function
+ * @returns {object} Guard result with canAccess, isLoading, and authState
+ *
+ * @example
+ * ```tsx
+ * const { canAccess, isLoading } = useAuthGuard({
+ *   requireAuth: true,
+ *   customCheck: (authState) => authState.user?.role === 'admin'
+ * });
+ * ```
+ */
+declare const useAuthGuard: (options?: {
+    requireAuth?: boolean;
+    customCheck?: (authState: AuthState) => boolean;
+}) => {
+    canAccess: boolean;
+    isLoading: boolean;
+    authState: AuthContextType;
+};
+/**
+ * Hook to check authentication on specific routes
+ * Useful for conditional checks within components
+ *
+ * @param {string} [fallbackPath='/'] - Path to redirect when not authenticated
+ * @returns {object} Object with isAuthenticated, isLoading, and redirectToLogin function
+ *
+ * @example
+ * ```tsx
+ * const { isAuthenticated, redirectToLogin } = useRouteAuth();
+ *
+ * if (!isAuthenticated) {
+ *   return redirectToLogin();
+ * }
+ * ```
+ */
+declare const useRouteAuth: (fallbackPath?: string) => {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    redirectToLogin: () => react_jsx_runtime.JSX.Element;
+};
+/**
+ * Get the root domain from the current window location
+ * Handles localhost and subdomain cases
+ *
+ * @returns {string} The root domain URL
+ */
+declare const getRootDomain: () => string;
+
+/**
+ * Generic adapter for integrating AuthProvider with Zustand stores
+ * Users should import this file and pass their store instance
+ *
+ * @template S - Zustand store type that contains auth-related state
+ * @param {object} useAuthStore - Zustand store hook with getState method
+ * @param {() => S} useAuthStore.getState - Function to get current store state
+ * @returns {object} Adapter object with auth functions
+ *
+ * @example
+ * ```typescript
+ * // Define your Zustand store type
+ * interface AuthStore {
+ *   sessionInfo?: SessionInfo;
+ *   tokens?: AuthTokens;
+ *   user?: AuthUser;
+ *   signOut: () => void;
+ * }
+ *
+ * // Create the adapter
+ * const authAdapter = createZustandAuthAdapter(useAuthStore);
+ *
+ * // Use with AuthProvider
+ * <AuthProvider
+ *   checkAuthFn={authAdapter.checkAuth}
+ *   signOutFn={authAdapter.signOut}
+ *   getUserFn={authAdapter.getUser}
+ *   getSessionFn={authAdapter.getSessionInfo}
+ *   getTokensFn={authAdapter.getTokens}
+ * >
+ *   <App />
+ * </AuthProvider>
+ * ```
+ */
+declare function createZustandAuthAdapter<S extends {
+    sessionInfo?: unknown;
+    tokens?: unknown;
+    user?: unknown;
+    signOut?: () => void;
+}>(useAuthStore: {
+    getState: () => S;
+}): {
+    /**
+     * Check if the user is authenticated based on sessionInfo and tokens
+     *
+     * @returns {Promise<boolean>} Promise that resolves to authentication status
+     */
+    checkAuth: () => Promise<boolean>;
+    /**
+     * Get the current user from the store
+     *
+     * @returns {unknown} Current user data from the store
+     */
+    getUser: () => unknown;
+    /**
+     * Get the current session information from the store
+     *
+     * @returns {unknown} Current session info from the store
+     */
+    getSessionInfo: () => unknown;
+    /**
+     * Get the current authentication tokens from the store
+     *
+     * @returns {unknown} Current tokens from the store
+     */
+    getTokens: () => unknown;
+    /**
+     * Sign out the user by calling the store's signOut function if available
+     *
+     * @returns {void}
+     */
+    signOut: () => void;
+};
+
+/**
+ * Options interface for the useUrlAuthentication hook
+ *
+ * @template Tokens - Type for authentication tokens
+ * @template Session - Type for session information
+ * @template Profile - Type for profile information
+ *
+ * @interface UseUrlAuthOptions
+ * @property {(tokens: Tokens) => void} setTokens - Function to set authentication tokens
+ * @property {(session: Session) => void} setSessionInfo - Function to set session information
+ * @property {(profile: Profile) => void} [setSelectedProfile] - Optional function to set selected profile
+ * @property {object} api - API instance with get method
+ * @property {(endpoint: string, config: unknown) => Promise<unknown>} api.get - API get method
+ * @property {string} endpoint - API endpoint to fetch session data
+ * @property {(searchParams: URLSearchParams) => object} [extractParams] - Custom parameter extraction function
+ * @property {() => void} [clearParamsFromURL] - Function to clear URL parameters after processing
+ */
+interface UseUrlAuthOptions<Tokens = unknown, Session = unknown, Profile = unknown> {
+    setTokens: (tokens: Tokens) => void;
+    setSessionInfo: (session: Session) => void;
+    setSelectedProfile?: (profile: Profile) => void;
+    api: {
+        get: (endpoint: string, config: unknown) => Promise<unknown>;
+    };
+    endpoint: string;
+    extractParams?: (searchParams: URLSearchParams) => {
+        sessionId: string;
+        token: string;
+        refreshToken: string;
+    };
+    clearParamsFromURL?: () => void;
+}
+/**
+ * Hook for handling URL-based authentication
+ * Extracts authentication parameters from URL and processes them
+ *
+ * @template Tokens - Type for authentication tokens
+ * @template Session - Type for session information
+ * @template Profile - Type for profile information
+ *
+ * @param {UseUrlAuthOptions<Tokens, Session, Profile>} options - Configuration options
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * useUrlAuthentication({
+ *   setTokens: (tokens) => authStore.setTokens(tokens),
+ *   setSessionInfo: (session) => authStore.setSessionInfo(session),
+ *   setSelectedProfile: (profile) => authStore.setProfile(profile),
+ *   api: apiInstance,
+ *   endpoint: '/auth/session',
+ *   clearParamsFromURL: () => navigate('/', { replace: true })
+ * });
+ * ```
+ */
+declare function useUrlAuthentication<Tokens = unknown, Session = unknown, Profile = unknown>(options: UseUrlAuthOptions<Tokens, Session, Profile>): void;
+
+/**
+ * Type definition for API client with get method
+ *
+ * @template T - Type extending object with get method
+ */
+type ApiClient<T = unknown> = {
+    get: (endpoint: string, config?: T) => Promise<unknown>;
+};
+/**
+ * Creates a memoized API configuration object compatible with useUrlAuthentication
+ *
+ * This hook wraps an API client instance to create a consistent interface
+ * for the useUrlAuthentication hook, ensuring proper memoization to prevent
+ * unnecessary re-renders.
+ *
+ * @template T - Generic type for API client configuration
+ * @param {ApiClient<T>} api - Axios instance or any API client with a get method
+ * @returns {object} Memoized API configuration object with get method
+ *
+ * @example
+ * ```typescript
+ * import { useApiConfig } from 'analytica-frontend-lib';
+ * import { useApi } from './services/apiService';
+ *
+ * function App() {
+ *   const api = useApi();
+ *   const apiConfig = useApiConfig(api);
+ *
+ *   useUrlAuthentication({
+ *     setTokens,
+ *     setSessionInfo,
+ *     setSelectedProfile,
+ *     api: apiConfig,
+ *     endpoint: '/auth/session-info',
+ *   });
+ * }
+ * ```
+ */
+declare function useApiConfig<T = unknown>(api: ApiClient<T>): {
+    get: (endpoint: string, config: unknown) => Promise<unknown>;
+};
+
+declare enum QUESTION_DIFFICULTY {
+    FACIL = "FACIL",
+    MEDIO = "MEDIO",
+    DIFICIL = "DIFICIL"
+}
+declare enum QUESTION_TYPE {
+    ALTERNATIVA = "ALTERNATIVA",
+    DISSERTATIVA = "DISSERTATIVA",
+    MULTIPLA_CHOICE = "MULTIPLA_CHOICE"
+}
+declare enum QUESTION_STATUS {
+    APROVADO = "APROVADO",
+    REPROVADO = "REPROVADO"
+}
+interface Question {
+    id: string;
+    questionText: string;
+    description: string;
+    type: QUESTION_TYPE;
+    status: QUESTION_STATUS;
+    difficulty: QUESTION_DIFFICULTY;
+    examBoard: string;
+    examYear: string;
+    answerKey: null | string;
+    institutionIds: string[];
+    knowledgeMatrix: {
+        areaKnowledgeId: string;
+        subjectId: string;
+        topicId: string;
+        subtopicId: string;
+        contentId: string;
+    }[];
+    options: {
+        id: string;
+        option: string;
+        isCorrect: boolean;
+    }[];
+}
+interface Simulado {
+    id: string;
+    title: string;
+    category: string;
+    questions: Question[];
+}
+interface Atividade {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface Aula {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface UserAnswerItem {
+    questionId: string;
+    activityId: string;
+    userId: string;
+    answer: string | null;
+    optionId: string | null;
+}
+interface QuizState {
+    bySimulated?: Simulado;
+    byActivity?: Atividade;
+    byQuestionary?: Aula;
+    currentQuestionIndex: number;
+    selectedAnswers: Record<string, string>;
+    userAnswers: UserAnswerItem[];
+    timeElapsed: number;
+    isStarted: boolean;
+    isFinished: boolean;
+    userId: string;
+    setBySimulated: (simulado: Simulado) => void;
+    setByActivity: (atividade: Atividade) => void;
+    setByQuestionary: (aula: Aula) => void;
+    setUserId: (userId: string) => void;
+    setUserAnswers: (userAnswers: UserAnswerItem[]) => void;
+    goToNextQuestion: () => void;
+    goToPreviousQuestion: () => void;
+    goToQuestion: (index: number) => void;
+    getActiveQuiz: () => {
+        quiz: Simulado | Atividade | Aula;
+        type: 'bySimulated' | 'byActivity' | 'byQuestionary';
+    } | null;
+    selectAnswer: (questionId: string, answerId: string) => void;
+    selectMultipleAnswer: (questionId: string, answerIds: string[]) => void;
+    skipQuestion: () => void;
+    addUserAnswer: (questionId: string, answerId?: string) => void;
+    startQuiz: () => void;
+    finishQuiz: () => void;
+    resetQuiz: () => void;
+    updateTime: (time: number) => void;
+    startTimer: () => void;
+    stopTimer: () => void;
+    getCurrentQuestion: () => Question | null;
+    getTotalQuestions: () => number;
+    getAnsweredQuestions: () => number;
+    getUnansweredQuestions: () => number[];
+    getSkippedQuestions: () => number;
+    getProgress: () => number;
+    isQuestionAnswered: (questionId: string) => boolean;
+    isQuestionSkipped: (questionId: string) => boolean;
+    getCurrentAnswer: () => string | undefined;
+    getAllCurrentAnswer: () => UserAnswerItem[] | undefined;
+    getQuizTitle: () => string;
+    formatTime: (seconds: number) => string;
+    getUserAnswers: () => UserAnswerItem[];
+    getUnansweredQuestionsFromUserAnswers: () => number[];
+    getQuestionsGroupedBySubject: () => {
+        [key: string]: Question[];
+    };
+    getUserId: () => string;
+    setCurrentQuestion: (question: Question) => void;
+    getUserAnswerByQuestionId: (questionId: string) => UserAnswerItem | null;
+    isQuestionAnsweredByUserAnswers: (questionId: string) => boolean;
+    getQuestionStatusFromUserAnswers: (questionId: string) => 'answered' | 'unanswered' | 'skipped';
+    getUserAnswersForActivity: () => UserAnswerItem[];
+}
+declare const useQuizStore: zustand.UseBoundStore<Omit<zustand.StoreApi<QuizState>, "setState" | "devtools"> & {
+    setState(partial: QuizState | Partial<QuizState> | ((state: QuizState) => QuizState | Partial<QuizState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: QuizState | ((state: QuizState) => QuizState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+
+declare const Quiz: react.ForwardRefExoticComponent<{
+    children: ReactNode;
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizHeaderResult: react.ForwardRefExoticComponent<{
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizTitle: react.ForwardRefExoticComponent<{
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizHeader: () => react_jsx_runtime.JSX.Element;
+declare const QuizContent: react.ForwardRefExoticComponent<{
+    type?: "Alternativas" | "Dissertativa";
+    variant?: "result" | "default";
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+interface QuizAlternativeInterface {
+    variant?: 'result' | 'default';
+}
+declare const QuizAlternative: ({ variant }: QuizAlternativeInterface) => react_jsx_runtime.JSX.Element;
+declare const QuizQuestionList: ({ filterType, onQuestionClick, }?: {
+    filterType?: string;
+    onQuestionClick?: () => void;
+}) => react_jsx_runtime.JSX.Element;
+declare const QuizFooter: react.ForwardRefExoticComponent<{
+    className?: string;
+    variant?: "result" | "default";
+    onGoToSimulated?: () => void;
+    onDetailResult?: () => void;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizResultHeaderTitle: react.ForwardRefExoticComponent<{
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizResultTitle: react.ForwardRefExoticComponent<{
+    className?: string;
+} & react.RefAttributes<HTMLParagraphElement>>;
+declare const QuizResultPerformance: react.ForwardRefExoticComponent<react.RefAttributes<HTMLDivElement>>;
+declare const QuizListResult: react.ForwardRefExoticComponent<{
+    className?: string;
+    onSubjectClick?: (subject: string) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+declare const QuizListResultByMateria: ({ subject, onQuestionClick, }: {
+    subject: string;
+    onQuestionClick: (question: Question) => void;
+}) => react_jsx_runtime.JSX.Element;
+
+export { Alert, AlertDialog, AlternativesList, AuthProvider, Badge, Button, Calendar, CardAccordation, CardActivitiesResults, CardPerformance, CardProgress, CardQuestions, CardResults, CardSimulado, CardSimulationHistory, CardStatus, CardTest, CardTopic, CheckBox, CheckboxList, CheckboxListItem, Chips, Divider, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger, IconButton, IconRoundedButton, Input, Menu, MenuContent, MenuItem, MenuLabel, MenuOverflow, Modal, MultipleChoiceList, NavButton, NotFound, ProfileMenuFooter, ProfileMenuHeader, ProfileMenuSection, ProfileMenuTrigger, ProgressBar, ProgressCircle, ProtectedRoute, PublicRoute, Quiz, QuizAlternative, QuizContent, QuizFooter, QuizHeader, QuizHeaderResult, QuizListResult, QuizListResultByMateria, QuizQuestionList, QuizResultHeaderTitle, QuizResultPerformance, QuizResultTitle, QuizTitle, Radio, RadioGroup, RadioGroupItem, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, SelectionButton, Skeleton, SkeletonCard, SkeletonCircle, SkeletonList, SkeletonRectangle, SkeletonRounded, SkeletonTable, SkeletonText, Stepper, Table, Text, TextArea, Toast, Toaster, createZustandAuthAdapter, getRootDomain, useApiConfig, useAuth, useAuthGuard, useQuizStore, useRouteAuth, useToastStore, useUrlAuthentication, withAuth };