@epilot/volt-ui 0.1.2 → 1.0.0-alpha.1

package/dist/types/components/Button/Button.d.ts

@@ -1,23 +1,104 @@
-import React from "react";
-export type RadixPropsVariant = "classic" | "solid" | "soft" | "surface" | "outline" | "ghost";
-export type NewVariant = "primary" | "secondary" | "tertiary";
-export declare const VARIANT_MAP: Record<RadixPropsVariant | NewVariant, NewVariant>;
-export declare const getSizeClass: (size: ButtonSize | ButtonSizeLegacy | string | number) => ButtonSize;
-export declare const getBaseButtonClasses: () => string[];
-export declare const getVariantClasses: (variant: NewVariant, warning: boolean) => string[];
-export declare const getSizeClasses: (size: ButtonSize) => string[];
-export declare const getIconButtonSizeClasses: (size: ButtonSize) => string[];
+import type { ComponentPropsWithoutRef } from "react";
+export type ButtonVariant = "primary" | "secondary" | "tertiary";
 export type ButtonSize = "sm" | "base" | "lg";
-export type ButtonSizeLegacy = 1 | 2 | 3 | "1" | "2" | "3";
-export type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
-    variant?: RadixPropsVariant | NewVariant;
-    size?: ButtonSize | ButtonSizeLegacy;
+export type ButtonProps = ComponentPropsWithoutRef<"button"> & {
+    /**
+     * Visual style variant of the button.
+     * - primary: Solid accent background (most prominent)
+     * - secondary: Accent surface with border (moderate emphasis)
+     * - tertiary: Transparent background (least emphasis)
+     * @default "primary"
+     */
+    variant?: ButtonVariant;
+    /**
+     * Size of the button.
+     * - sm: Small (24px height)
+     * - base: Default (32px height)
+     * - lg: Large (40px height)
+     * @default "base"
+     */
+    size?: ButtonSize;
+    /**
+     * Applies error/warning styling to the button.
+     * Useful for destructive actions like delete or cancel.
+     * @default false
+     */
     warning?: boolean;
-    children: React.ReactNode;
+    /**
+     * If true, button takes full width of its container.
+     * @default false
+     */
+    fullWidth?: boolean;
+    /**
+     * Renders the button as a child element while preserving button behavior.
+     * Useful for rendering as a Link component or custom element.
+     * @default false
+     */
+    asChild?: boolean;
 };
-export declare const Button: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
-    variant?: RadixPropsVariant | NewVariant;
-    size?: ButtonSize | ButtonSizeLegacy;
+/**
+ * Button component for user actions.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <Button variant="primary" onClick={handleClick}>
+ *   Click me
+ * </Button>
+ * ```
+ *
+ * @example Warning/destructive action
+ * ```tsx
+ * <Button variant="primary" warning onClick={handleDelete}>
+ *   Delete Account
+ * </Button>
+ * ```
+ *
+ * @example As a Link (with asChild)
+ * ```tsx
+ * <Button asChild>
+ *   <Link href="/dashboard">Go to Dashboard</Link>
+ * </Button>
+ * ```
+ *
+ * @example Full width
+ * ```tsx
+ * <Button variant="secondary" fullWidth>
+ *   Submit Form
+ * </Button>
+ * ```
+ */
+export declare const Button: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    /**
+     * Visual style variant of the button.
+     * - primary: Solid accent background (most prominent)
+     * - secondary: Accent surface with border (moderate emphasis)
+     * - tertiary: Transparent background (least emphasis)
+     * @default "primary"
+     */
+    variant?: ButtonVariant;
+    /**
+     * Size of the button.
+     * - sm: Small (24px height)
+     * - base: Default (32px height)
+     * - lg: Large (40px height)
+     * @default "base"
+     */
+    size?: ButtonSize;
+    /**
+     * Applies error/warning styling to the button.
+     * Useful for destructive actions like delete or cancel.
+     * @default false
+     */
     warning?: boolean;
-    children: React.ReactNode;
-} & React.RefAttributes<HTMLButtonElement>>;
+    /**
+     * If true, button takes full width of its container.
+     * @default false
+     */
+    fullWidth?: boolean;
+    /**
+     * Renders the button as a child element while preserving button behavior.
+     * Useful for rendering as a Link component or custom element.
+     * @default false
+     */
+    asChild?: boolean;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/Button/IconButton.d.ts

@@ -1,7 +1,89 @@
-import React from 'react';
-export declare const IconButton: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
-    variant?: import("./Button").RadixPropsVariant | import("./Button").NewVariant;
-    size?: import("./Button").ButtonSize | import("./Button").ButtonSizeLegacy;
+import type { ComponentPropsWithoutRef } from "react";
+import type { ButtonSize, ButtonVariant } from "./Button";
+export type IconButtonProps = ComponentPropsWithoutRef<"button"> & {
+    /**
+     * Visual style variant of the button.
+     * - primary: Solid accent background (most prominent)
+     * - secondary: Accent surface with border (moderate emphasis)
+     * - tertiary: Transparent background (least emphasis)
+     * @default "primary"
+     */
+    variant?: ButtonVariant;
+    /**
+     * Size of the icon button (square).
+     * - sm: Small (24x24px)
+     * - base: Default (32x32px)
+     * - lg: Large (40x40px)
+     * @default "base"
+     */
+    size?: ButtonSize;
+    /**
+     * Applies error/warning styling to the button.
+     * Useful for destructive actions like delete or cancel.
+     * @default false
+     */
     warning?: boolean;
-    children: React.ReactNode;
-} & React.RefAttributes<HTMLButtonElement>>;
+    /**
+     * Renders the button as a child element while preserving button behavior.
+     * Useful for rendering as a Link component or custom element.
+     * @default false
+     */
+    asChild?: boolean;
+};
+/**
+ * IconButton component for icon-only actions.
+ * Square button designed specifically for icons.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <IconButton variant="primary" aria-label="Edit">
+ *   <EditIcon />
+ * </IconButton>
+ * ```
+ *
+ * @example Warning/destructive action
+ * ```tsx
+ * <IconButton variant="tertiary" warning aria-label="Delete">
+ *   <TrashIcon />
+ * </IconButton>
+ * ```
+ *
+ * @example As a Link (with asChild)
+ * ```tsx
+ * <IconButton asChild aria-label="Settings">
+ *   <Link href="/settings">
+ *     <SettingsIcon />
+ *   </Link>
+ * </IconButton>
+ * ```
+ */
+export declare const IconButton: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    /**
+     * Visual style variant of the button.
+     * - primary: Solid accent background (most prominent)
+     * - secondary: Accent surface with border (moderate emphasis)
+     * - tertiary: Transparent background (least emphasis)
+     * @default "primary"
+     */
+    variant?: ButtonVariant;
+    /**
+     * Size of the icon button (square).
+     * - sm: Small (24x24px)
+     * - base: Default (32x32px)
+     * - lg: Large (40x40px)
+     * @default "base"
+     */
+    size?: ButtonSize;
+    /**
+     * Applies error/warning styling to the button.
+     * Useful for destructive actions like delete or cancel.
+     * @default false
+     */
+    warning?: boolean;
+    /**
+     * Renders the button as a child element while preserving button behavior.
+     * Useful for rendering as a Link component or custom element.
+     * @default false
+     */
+    asChild?: boolean;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/components/Checkbox/Checkbox.d.ts

@@ -1,8 +1,33 @@
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
-import type { ComponentPropsWithoutRef } from "react";
+import type { ComponentPropsWithoutRef, ReactNode } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
 export type CheckboxTone = "accent" | "error";
-export interface CheckboxProps extends Omit<ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, "children"> {
+export type CheckboxProps = Omit<ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, "children"> & {
     tone?: CheckboxTone;
     indicatorClassName?: string;
-}
-export declare const Checkbox: import("react").ForwardRefExoticComponent<CheckboxProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<Omit<CheckboxPrimitive.CheckboxProps & import("react").RefAttributes<HTMLButtonElement>, "ref">, "children"> & {
+    tone?: CheckboxTone;
+    indicatorClassName?: string;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export type CheckboxFieldState = "default" | "error";
+export type CheckboxFieldRootProps = {
+    id: string;
+    children: ReactNode;
+    className?: string;
+    state?: CheckboxFieldState;
+    disabled?: boolean;
+    tone?: CheckboxTone;
+};
+export declare const CheckboxField: {
+    Root: import("react").ForwardRefExoticComponent<CheckboxFieldRootProps & import("react").RefAttributes<HTMLLabelElement>>;
+    Checkbox: import("react").ForwardRefExoticComponent<Omit<Omit<CheckboxPrimitive.CheckboxProps & import("react").RefAttributes<HTMLButtonElement>, "ref">, "children"> & {
+        tone?: CheckboxTone;
+        indicatorClassName?: string;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/Form/Form.d.ts

@@ -0,0 +1,34 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import React from "react";
+import type { ControllerProps, ControllerRenderProps, FieldPath, FieldValues, SubmitHandler, UseFormReturn, FieldError } from "react-hook-form";
+import { useFormContext, useFormState } from "react-hook-form";
+import type { ZodSchema } from "zod";
+export type FormRootProps<TFieldValues extends FieldValues = FieldValues> = {
+    form: UseFormReturn<TFieldValues>;
+    onSubmit: SubmitHandler<TFieldValues>;
+    children: React.ReactNode;
+    className?: string;
+};
+export type FormFieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<ControllerProps<TFieldValues, TName>, "render"> & {
+    children: (props: {
+        field: ControllerRenderProps<TFieldValues, TName>;
+        fieldState: {
+            invalid: boolean;
+            isTouched: boolean;
+            isDirty: boolean;
+            error?: FieldError;
+        };
+    }) => React.ReactElement;
+};
+export declare const Form: {
+    Root: {
+        <TFieldValues extends FieldValues = FieldValues>({ form, onSubmit, children, className, }: FormRootProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Field: {
+        <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ children, ...props }: FormFieldProps<TFieldValues, TName>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export { zodResolver, useFormContext, useFormState };
+export type { UseFormReturn, FieldValues, SubmitHandler, ZodSchema, FieldError };

package/dist/types/components/Radio/Radio.d.ts

@@ -1,8 +1,33 @@
 import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
-import type { ComponentPropsWithoutRef } from "react";
+import type { ComponentPropsWithoutRef, ReactNode } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
 export type RadioTone = "accent" | "error";
-export interface RadioProps extends Omit<ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>, "children"> {
+export type RadioProps = Omit<ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>, "children"> & {
     tone?: RadioTone;
     indicatorClassName?: string;
-}
-export declare const Radio: import("react").ForwardRefExoticComponent<RadioProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export declare const Radio: import("react").ForwardRefExoticComponent<Omit<Omit<RadioGroupPrimitive.RadioGroupItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref">, "children"> & {
+    tone?: RadioTone;
+    indicatorClassName?: string;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export type RadioFieldState = "default" | "error";
+export type RadioFieldRootProps = {
+    id: string;
+    children: ReactNode;
+    className?: string;
+    state?: RadioFieldState;
+    disabled?: boolean;
+    tone?: RadioTone;
+};
+export declare const RadioField: {
+    Root: import("react").ForwardRefExoticComponent<RadioFieldRootProps & import("react").RefAttributes<HTMLLabelElement>>;
+    Radio: import("react").ForwardRefExoticComponent<Omit<Omit<RadioGroupPrimitive.RadioGroupItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref">, "children"> & {
+        tone?: RadioTone;
+        indicatorClassName?: string;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/Radio/RadioGroup.d.ts

@@ -1,6 +1,8 @@
 import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
 import type { ComponentPropsWithoutRef } from "react";
-export interface RadioGroupProps extends ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> {
+export type RadioGroupProps = ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
     orientation?: "vertical" | "horizontal";
-}
-export declare const RadioGroup: import("react").ForwardRefExoticComponent<RadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export declare const RadioGroup: import("react").ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    orientation?: "vertical" | "horizontal";
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/Select/Select.d.ts

@@ -0,0 +1,56 @@
+import * as RadixSelect from "@radix-ui/react-select";
+import type { ComponentPropsWithoutRef, HTMLAttributes, ReactNode } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
+export type SelectState = "default" | "highlighted" | "error";
+export type SelectRootProps = {
+    id: string;
+    children: ReactNode;
+    className?: string;
+    state?: SelectState;
+    disabled?: boolean;
+    readOnly?: boolean;
+};
+export type SelectTriggerProps = Omit<ComponentPropsWithoutRef<typeof RadixSelect.Trigger>, "id" | "disabled"> & {
+    className?: string;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    actions?: ReactNode;
+};
+export type SelectContentProps = Omit<ComponentPropsWithoutRef<typeof RadixSelect.Content>, "position" | "align" | "sideOffset"> & {
+    position?: "item-aligned" | "popper";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+};
+export type SelectItemProps = ComponentPropsWithoutRef<typeof RadixSelect.Item>;
+export type SelectHelperTextProps = HTMLAttributes<HTMLDivElement> & {
+    tone?: ValidationVariant;
+};
+export declare const Select: {
+    Root: {
+        ({ id, children, className, state, disabled, readOnly, }: SelectRootProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Container: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        visuallyHidden?: boolean;
+    } & import("react").RefAttributes<HTMLLabelElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<Omit<RadixSelect.SelectTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref">, "disabled" | "id"> & {
+        className?: string;
+        prefix?: ReactNode;
+        suffix?: ReactNode;
+        actions?: ReactNode;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+    Value: import("react").ForwardRefExoticComponent<Omit<RadixSelect.SelectValueProps & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<Omit<RadixSelect.SelectContentProps & import("react").RefAttributes<HTMLDivElement>, "ref">, "sideOffset" | "align" | "position"> & {
+        position?: "item-aligned" | "popper";
+        align?: "start" | "center" | "end";
+        sideOffset?: number;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<RadixSelect.SelectItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Group: import("react").ForwardRefExoticComponent<Omit<RadixSelect.SelectGroupProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupLabel: import("react").ForwardRefExoticComponent<Omit<RadixSelect.SelectLabelProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/Switch/Switch.d.ts

@@ -1,7 +1,26 @@
 import * as SwitchPrimitive from "@radix-ui/react-switch";
-import type { ComponentPropsWithoutRef } from "react";
+import type { ComponentPropsWithoutRef, ReactNode } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
 export type SwitchTone = "accent" | "error";
 export interface SwitchProps extends Omit<ComponentPropsWithoutRef<typeof SwitchPrimitive.Root>, "children"> {
     tone?: SwitchTone;
 }
 export declare const Switch: import("react").ForwardRefExoticComponent<SwitchProps & import("react").RefAttributes<HTMLButtonElement>>;
+export type SwitchFieldState = "default" | "error";
+export type SwitchFieldRootProps = {
+    id: string;
+    children: ReactNode;
+    className?: string;
+    state?: SwitchFieldState;
+    disabled?: boolean;
+    tone?: SwitchTone;
+};
+export declare const SwitchField: {
+    Root: import("react").ForwardRefExoticComponent<SwitchFieldRootProps & import("react").RefAttributes<HTMLLabelElement>>;
+    Switch: import("react").ForwardRefExoticComponent<SwitchProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/TextArea/TextArea.d.ts

@@ -1,18 +1,43 @@
-import type { ReactNode, TextareaHTMLAttributes } from "react";
-import { type InputFieldState } from "../InputField/InputField";
-import type { ValidationVariant } from "../Validation/Validation";
-export interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "prefix"> {
+import type { HTMLAttributes, ReactNode, TextareaHTMLAttributes } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
+export type TextAreaState = "default" | "highlighted" | "error";
+export type TextAreaRootProps = {
     id: string;
-    label?: ReactNode;
-    labelHidden?: boolean;
-    description?: ReactNode;
-    helperText?: ReactNode;
-    helperTextTone?: ValidationVariant;
-    state?: InputFieldState;
-    prefix?: ReactNode;
-    suffix?: ReactNode;
-    actions?: ReactNode;
-    fieldClassName?: string;
-    controlClassName?: string;
-}
-export declare const TextArea: import("react").ForwardRefExoticComponent<TextAreaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+    children: ReactNode;
+    className?: string;
+    state?: TextAreaState;
+    disabled?: boolean;
+    readOnly?: boolean;
+    value?: TextareaHTMLAttributes<HTMLTextAreaElement>["value"];
+    defaultValue?: TextareaHTMLAttributes<HTMLTextAreaElement>["defaultValue"];
+};
+export type TextAreaControlProps = {
+    children: ReactNode;
+    className?: string;
+};
+export type TextAreaTextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "id" | "disabled" | "readOnly">;
+export type TextAreaHelperTextProps = HTMLAttributes<HTMLDivElement> & {
+    tone?: ValidationVariant;
+};
+export declare const TextArea: {
+    Root: {
+        ({ id, children, className, state, disabled, readOnly, value: valueProp, defaultValue, }: TextAreaRootProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Container: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        visuallyHidden?: boolean;
+    } & import("react").RefAttributes<HTMLLabelElement>>;
+    Control: {
+        ({ children, className }: TextAreaControlProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Textarea: import("react").ForwardRefExoticComponent<TextAreaTextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+    Prefix: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Suffix: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Actions: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/TextInput/TextInput.d.ts

@@ -1,20 +1,52 @@
-import type { InputHTMLAttributes, ReactNode } from "react";
-import { type InputFieldState } from "../InputField/InputField";
-import type { ValidationVariant } from "../Validation/Validation";
-export interface TextInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "prefix"> {
+import type { HTMLAttributes, InputHTMLAttributes, ReactNode } from "react";
+import { type ValidationVariant } from "../Validation/Validation";
+export type TextInputState = "default" | "highlighted" | "error";
+export type TextInputRootProps = {
     id: string;
-    label?: ReactNode;
-    labelHidden?: boolean;
-    description?: ReactNode;
-    helperText?: ReactNode;
-    helperTextTone?: ValidationVariant;
-    state?: InputFieldState;
-    prefix?: ReactNode;
-    suffix?: ReactNode;
-    actions?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    state?: TextInputState;
+    disabled?: boolean;
+    readOnly?: boolean;
     clearable?: boolean;
     onClear?: () => void;
-    fieldClassName?: string;
-    controlClassName?: string;
-}
-export declare const TextInput: import("react").ForwardRefExoticComponent<TextInputProps & import("react").RefAttributes<HTMLInputElement>>;
+    value?: InputHTMLAttributes<HTMLInputElement>["value"];
+    defaultValue?: InputHTMLAttributes<HTMLInputElement>["defaultValue"];
+};
+export type TextInputControlProps = {
+    children: ReactNode;
+    className?: string;
+};
+export type TextInputInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "disabled" | "readOnly">;
+export type TextInputActionsProps = {
+    children?: ReactNode;
+    showClearButton?: boolean;
+};
+export type TextInputHelperTextProps = HTMLAttributes<HTMLDivElement> & {
+    tone?: ValidationVariant;
+};
+export declare const TextInput: {
+    Root: {
+        ({ id, children, className, state, disabled, readOnly, clearable, onClear, value: valueProp, defaultValue, }: TextInputRootProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Container: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        visuallyHidden?: boolean;
+    } & import("react").RefAttributes<HTMLLabelElement>>;
+    Control: {
+        ({ children, className }: TextInputControlProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Input: import("react").ForwardRefExoticComponent<TextInputInputProps & import("react").RefAttributes<HTMLInputElement>>;
+    Prefix: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Suffix: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Actions: {
+        ({ children, showClearButton }: TextInputActionsProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+    Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+    HelperText: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+        tone?: ValidationVariant;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+};

package/dist/types/components/Tooltip/Tooltip.d.ts

@@ -1,19 +1,11 @@
-import type { ReactNode } from "react";
-export interface TooltipProps {
-    children: ReactNode;
-    content: ReactNode;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    delayDuration?: number;
-    side?: "top" | "right" | "bottom" | "left";
-    align?: "start" | "center" | "end";
-    className?: string;
-}
-type TooltipProviderProps = {
-    children: ReactNode;
-    delayDuration?: number;
+import * as RadixTooltip from "@radix-ui/react-tooltip";
+import type { FC } from "react";
+export declare const Tooltip: {
+    Provider: FC<RadixTooltip.TooltipProviderProps>;
+    Root: FC<RadixTooltip.TooltipProps>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<RadixTooltip.TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & {
+        asChild?: boolean;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<RadixTooltip.TooltipContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Arrow: import("react").ForwardRefExoticComponent<Omit<RadixTooltip.TooltipArrowProps & import("react").RefAttributes<SVGSVGElement>, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
 };
-export declare const TooltipProvider: ({ children, delayDuration, }: TooltipProviderProps) => import("react/jsx-runtime").JSX.Element;
-export declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLDivElement>>;
-export {};

package/dist/types/components/Validation/Validation.d.ts

@@ -2,9 +2,10 @@ import { type VariantProps } from 'class-variance-authority';
 import type { HTMLAttributes } from 'react';
 export type ValidationVariant = 'error' | 'success' | 'default';
 declare const validationStyles: (props?: ({
-    variant?: "error" | "default" | "success" | null | undefined;
+    variant?: "error" | "success" | "default" | null | undefined;
 } & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
-export interface ValidationProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof validationStyles> {
-}
-export declare const Validation: import("react").ForwardRefExoticComponent<ValidationProps & import("react").RefAttributes<HTMLDivElement>>;
+export type ValidationProps = HTMLAttributes<HTMLDivElement> & VariantProps<typeof validationStyles>;
+export declare const Validation: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "error" | "success" | "default" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & import("react").RefAttributes<HTMLDivElement>>;
 export {};