@szum-tech/design-system 1.18.3 → 2.0.1

package/dist/index.d.ts

@@ -1,59 +1,37 @@
-import * as React from 'react';
-import React__default from 'react';
-import * as ReactAvatar from '@radix-ui/react-avatar';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import { Avatar as Avatar$1, Tooltip as Tooltip$1, Select as Select$1, Dialog as Dialog$1, Separator as Separator$1, Label as Label$1, AlertDialog as AlertDialog$1 } from 'radix-ui';
 import { VariantProps } from 'class-variance-authority';
 import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as ReactTooltip from '@radix-ui/react-tooltip';
-import * as ReactSelect from '@radix-ui/react-select';
-import * as ReactSheet from '@radix-ui/react-dialog';
-import * as ReactSeparator from '@radix-ui/react-separator';
 import * as react_hook_form from 'react-hook-form';
 import { FormProviderProps, FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
-import * as ReactLabel from '@radix-ui/react-label';
 import * as _radix_ui_react_slot from '@radix-ui/react-slot';
 import { Slot } from '@radix-ui/react-slot';
-import * as ReactAlertDialog from '@radix-ui/react-alert-dialog';
-
-declare const avatarCva: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
-
-type AvatarCvaProps = VariantProps<typeof avatarCva>;
-type AvatarSizeType = NonNullable<AvatarCvaProps["size"]>;
+export { cn } from './utils.js';
+import 'clsx';
 
-type AvatarProps = ReactAvatar.AvatarProps & {
+type AvatarProps = Avatar$1.AvatarProps & React$1.RefAttributes<HTMLSpanElement> & {
     /**
      * Defines avatar size
      */
     size?: AvatarSizeType;
 };
-declare const Avatar: (props: ReactAvatar.AvatarProps & {
-    /**
-     * Defines avatar size
-     */
-    size?: AvatarSizeType | undefined;
-} & React.RefAttributes<HTMLSpanElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type AvatarImageProps = React.ComponentPropsWithoutRef<typeof ReactAvatar.Image>;
-declare const AvatarImage: (props: Omit<ReactAvatar.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type AvatarFallbackProps = React.ComponentPropsWithoutRef<typeof ReactAvatar.Fallback>;
-declare const AvatarFallback: (props: Omit<ReactAvatar.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare function Avatar({ className, size, ref, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
 
-declare const buttonCva: (props?: ({
-    fullWidth?: boolean | null | undefined;
-    color?: "neutral" | "primary" | "success" | "warning" | "error" | null | undefined;
+declare const avatarCva: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
-    variant?: "text" | "outlined" | "contained" | null | undefined;
 } & class_variance_authority_dist_types.ClassProp) | undefined) => string;
 
-type ButtonCvaProps = VariantProps<typeof buttonCva>;
-type ButtonSizeType = NonNullable<ButtonCvaProps["size"]>;
-type ButtonVariantType = NonNullable<ButtonCvaProps["variant"]>;
-type ButtonColorType = NonNullable<ButtonCvaProps["color"]>;
+type AvatarCvaProps = VariantProps<typeof avatarCva>;
+type AvatarSizeType = NonNullable<AvatarCvaProps["size"]>;
+
+type AvatarImageProps = React$1.ComponentProps<typeof Avatar$1.Image>;
+declare function AvatarImage({ className, ref, ...props }: AvatarImageProps): react_jsx_runtime.JSX.Element;
+
+type AvatarFallbackProps = React$1.ComponentProps<typeof Avatar$1.Fallback>;
+declare function AvatarFallback({ className, ref, ...props }: AvatarFallbackProps): react_jsx_runtime.JSX.Element;
 
-type Props$1 = {
+type Props = {
     /**
      * Defines button full width
      */
@@ -73,7 +51,7 @@ type Props$1 = {
     /**
      * Defines button content
      */
-    children?: React.ReactNode;
+    children?: React$1.ReactNode;
     /**
      * Disabled button
      */
@@ -81,11 +59,11 @@ type Props$1 = {
     /**
      * Defines left icon
      */
-    startIcon?: React.ReactElement;
+    startIcon?: React$1.ReactElement;
     /**
      * Defines right icon
      */
-    endIcon?: React.ReactElement;
+    endIcon?: React$1.ReactElement;
     /**
      * Defines is button is in loading state
      */
@@ -96,81 +74,89 @@ type Props$1 = {
     loadingPosition?: "start" | "end";
     asChild?: boolean;
 };
-type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & Props$1;
-declare const Button: (props: React.ButtonHTMLAttributes<HTMLButtonElement> & Props$1 & React.RefAttributes<HTMLButtonElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type ButtonProps = React$1.ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement> & Props;
+declare function Button({ asChild, variant, color, disabled, fullWidth, ref, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
 
-type InputProps = React.InputHTMLAttributes<HTMLInputElement> & {
+declare const buttonCva: (props?: ({
+    fullWidth?: boolean | null | undefined;
+    color?: "neutral" | "primary" | "success" | "warning" | "error" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    variant?: "text" | "outlined" | "contained" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+
+type ButtonCvaProps = VariantProps<typeof buttonCva>;
+type ButtonSizeType = NonNullable<ButtonCvaProps["size"]>;
+type ButtonVariantType = NonNullable<ButtonCvaProps["variant"]>;
+type ButtonColorType = NonNullable<ButtonCvaProps["color"]>;
+
+type InputProps = React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
     invalid?: boolean;
-    startIcon?: React.ReactElement | string;
-    endIcon?: React.ReactElement | string;
+    startIcon?: React$1.ReactElement | string;
+    endIcon?: React$1.ReactElement | string;
 };
-declare const Input: (props: React.InputHTMLAttributes<HTMLInputElement> & {
-    invalid?: boolean | undefined;
-    startIcon?: string | React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
-    endIcon?: string | React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
-} & React.RefAttributes<HTMLInputElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type TooltipProps = ReactTooltip.TooltipContentProps & {
-    children?: React.ReactNode;
+declare function Input({ invalid, startIcon, endIcon, disabled, className, ...props }: InputProps): react_jsx_runtime.JSX.Element;
+
+type TooltipProps = Tooltip$1.TooltipContentProps & {
+    children?: React$1.ReactNode;
     defaultOpen?: boolean;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
-    content?: React.ReactNode;
+    content?: React$1.ReactNode;
     collisionPadding?: number;
 };
 declare function Tooltip({ defaultOpen, content, open, onOpenChange, children, side, align, collisionPadding, sideOffset, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
 
 type TooltipProviderProps = {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
 };
 declare function TooltipProvider({ children }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
 
-type OmitStylesProps<T> = Omit<T, "className" | "style">;
-
-type Props = {
+type TextareaProps = React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> & {
     invalid?: boolean;
 };
-type TextareaProps = OmitStylesProps<React.ComponentPropsWithoutRef<"textarea">> & Props;
-declare const Textarea: (props: OmitStylesProps<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref">> & Props & React.RefAttributes<HTMLTextAreaElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare function Textarea({ invalid, ...props }: TextareaProps): react_jsx_runtime.JSX.Element;
 
-type SelectProps = OmitStylesProps<ReactSelect.SelectProps> & {
-    placeholder?: React.ReactNode;
+type SelectProps = Select$1.SelectProps & {
+    ref?: React$1.ComponentProps<typeof Select$1.Trigger>["ref"];
+    placeholder?: React$1.ReactNode;
     invalid?: boolean;
 };
-declare const Select: (props: OmitStylesProps<ReactSelect.SelectProps> & {
-    placeholder?: React.ReactNode;
-    invalid?: boolean | undefined;
-} & React.RefAttributes<HTMLButtonElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare function Select({ children, placeholder, invalid, ref, ...props }: SelectProps): react_jsx_runtime.JSX.Element;
 
-type SelectItemProps = OmitStylesProps<ReactSelect.SelectItemProps>;
-declare const SelectItem: (props: SelectItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type SelectItemProps = React$1.ComponentProps<typeof Select$1.Item>;
+declare function SelectItem({ children, ...props }: SelectItemProps): react_jsx_runtime.JSX.Element;
 
-type CardProps = React.HTMLAttributes<HTMLDivElement>;
-declare const Card: (props: CardProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type CardProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+declare function Card({ className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
 
-type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
-declare const CardHeader: (props: CardHeaderProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type CardHeaderProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+declare function CardHeader({ className, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
 
-type CardTitleProps = React__default.HTMLAttributes<HTMLHeadingElement>;
-declare const CardTitle: (props: CardTitleProps & React__default.RefAttributes<HTMLParagraphElement>) => React__default.ReactElement<any, string | React__default.JSXElementConstructor<any>> | null;
+type CardTitleProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+declare function CardTitle({ className, ...props }: CardTitleProps): react_jsx_runtime.JSX.Element;
 
-type CardDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare const CardDescription: (props: CardDescriptionProps & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type CardDescriptionProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+declare function CardDescription({ className, ...props }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
 
-type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
-declare const CardContent: (props: CardContentProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type CardContentProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+declare function CardContent({ className, ...props }: CardContentProps): react_jsx_runtime.JSX.Element;
 
-type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
-declare const CardFooter: (props: CardFooterProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type CardFooterProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+declare function CardFooter({ className, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
 
-type SheetProps = ReactSheet.DialogProps;
-declare const Sheet: React.FC<ReactSheet.DialogProps>;
+type SheetProps = Dialog$1.DialogProps;
+declare const Sheet: React$1.FC<Dialog$1.DialogProps>;
 
-type SheetTriggerProps = ReactSheet.DialogTriggerProps;
-declare const SheetTrigger: React.ForwardRefExoticComponent<ReactSheet.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type SheetTriggerProps = Dialog$1.DialogTriggerProps;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<Dialog$1.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-type SheetCloseProps = ReactSheet.DialogCloseProps;
-declare const SheetClose: React.ForwardRefExoticComponent<ReactSheet.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+type SheetCloseProps = Dialog$1.DialogCloseProps;
+declare const SheetClose: React$1.ForwardRefExoticComponent<Dialog$1.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+type SheetContentProps = React$1.ComponentProps<typeof Dialog$1.Content> & {
+    side?: SheetContentSide;
+};
+declare function SheetContent({ side, className, children, ...props }: SheetContentProps): react_jsx_runtime.JSX.Element;
 
 declare const sheetContentStyles: (props?: ({
     side?: "left" | "right" | "top" | "bottom" | null | undefined;
@@ -179,38 +165,36 @@ declare const sheetContentStyles: (props?: ({
 type SheetContentCvaProps = VariantProps<typeof sheetContentStyles>;
 type SheetContentSide = NonNullable<SheetContentCvaProps["side"]>;
 
-type SheetContentProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Content> & {
-    side?: SheetContentSide;
-};
-declare const SheetContent: (props: Omit<ReactSheet.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    side?: SheetContentSide | undefined;
-} & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type SheetHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type SheetHeaderProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function SheetHeader({ className, ...props }: SheetHeaderProps): react_jsx_runtime.JSX.Element;
 
-type SheetFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type SheetFooterProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function SheetFooter({ className, ...props }: SheetFooterProps): react_jsx_runtime.JSX.Element;
 
-type SheetTitleProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Title>;
-declare const SheetTitle: (props: Omit<ReactSheet.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type SheetTitleProps = React$1.ComponentProps<typeof Dialog$1.Title>;
+declare function SheetTitle({ className, ...props }: SheetTitleProps): react_jsx_runtime.JSX.Element;
 
-type SheetDescriptionProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Description>;
-declare const SheetDescription: (props: Omit<ReactSheet.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type SheetDescriptionProps = React$1.ComponentProps<typeof Dialog$1.Description>;
+declare function SheetDescription({ className, ...props }: SheetDescriptionProps): react_jsx_runtime.JSX.Element;
 
-type SeparatorProps = React.ComponentPropsWithoutRef<typeof ReactSeparator.Root>;
-declare const Separator: (props: Omit<ReactSeparator.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type SeparatorProps = React$1.ComponentProps<typeof Separator$1.Root>;
+declare function Separator({ className, orientation, decorative, ...props }: SeparatorProps): react_jsx_runtime.JSX.Element;
 
-type HeaderProps = {
-    children?: React__default.ReactNode;
+type HeaderProps = React$1.RefAttributes<HTMLHtmlElement> & {
+    children?: React$1.ReactNode;
 };
-declare function Header({ children }: HeaderProps): react_jsx_runtime.JSX.Element;
+declare function Header({ children, ...props }: HeaderProps): react_jsx_runtime.JSX.Element;
 
-type DialogProps = ReactSheet.DialogProps;
-declare const Dialog: React.FC<ReactSheet.DialogProps>;
+type DialogProps = Dialog$1.DialogProps;
+declare const Dialog: React$1.FC<Dialog$1.DialogProps>;
 
-type DialogCloseProps = ReactSheet.DialogCloseProps;
-declare const DialogClose: React.ForwardRefExoticComponent<ReactSheet.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+type DialogCloseProps = Dialog$1.DialogCloseProps;
+declare const DialogClose: React$1.ForwardRefExoticComponent<Dialog$1.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+type DialogContentProps = React$1.ComponentProps<typeof Dialog$1.Content> & {
+    width?: DialogContentWidth;
+};
+declare function DialogContent({ className, children, width, ...props }: DialogContentProps): react_jsx_runtime.JSX.Element;
 
 declare const dialogContentStyles: (props?: ({
     width?: "sm" | "md" | "lg" | "xs" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "full" | null | undefined;
@@ -219,54 +203,50 @@ declare const dialogContentStyles: (props?: ({
 type DialogContentCvaProps = VariantProps<typeof dialogContentStyles>;
 type DialogContentWidth = NonNullable<DialogContentCvaProps["width"]>;
 
-type DialogContentProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Content> & {
-    width?: DialogContentWidth;
-};
-declare const DialogContent: (props: Omit<ReactSheet.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    width?: DialogContentWidth | undefined;
-} & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type DialogTriggerProps = Dialog$1.DialogTriggerProps;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<Dialog$1.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-type DialogTriggerProps = ReactSheet.DialogTriggerProps;
-declare const DialogTrigger: React.ForwardRefExoticComponent<ReactSheet.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-
-type DialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogHeaderProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function DialogHeader({ className, ...props }: DialogHeaderProps): react_jsx_runtime.JSX.Element;
 
-type DialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogFooterProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function DialogFooter({ className, ...props }: DialogFooterProps): react_jsx_runtime.JSX.Element;
 
-type DialogTitleProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Title>;
-declare const DialogTitle: (props: Omit<ReactSheet.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type DialogTitleProps = React$1.ComponentProps<typeof Dialog$1.Title>;
+declare function DialogTitle({ className, ...props }: DialogTitleProps): react_jsx_runtime.JSX.Element;
 
-type DialogDescriptionProps = React.ComponentPropsWithoutRef<typeof ReactSheet.Description>;
-declare const DialogDescription: (props: Omit<ReactSheet.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type DialogDescriptionProps = React$1.ComponentProps<typeof Dialog$1.Description>;
+declare function DialogDescription({ className, ...props }: DialogDescriptionProps): react_jsx_runtime.JSX.Element;
 
 type FormProps = FormProviderProps;
 declare const Form: <TFieldValues extends react_hook_form.FieldValues, TContext = any, TTransformedValues extends react_hook_form.FieldValues | undefined = undefined>(props: FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
 
-type FormItemProps = React.HTMLAttributes<HTMLDivElement>;
-declare const FormItem: (props: FormItemProps & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type FormItemProps = React$1.HTMLAttributes<HTMLDivElement>;
+declare const FormItem: React$1.ForwardRefExoticComponent<FormItemProps & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => react_jsx_runtime.JSX.Element;
 
-type LabelProps = React.ComponentPropsWithoutRef<typeof ReactLabel.Root>;
-declare const Label: (props: Omit<ReactLabel.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type LabelProps = React$1.ComponentProps<typeof Label$1.Root>;
+declare function Label({ className, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
 
 type FormLabelProps = LabelProps & {
-    caption?: React.ReactNode;
+    caption?: React$1.ReactNode;
 };
-declare const FormLabel: (props: Omit<ReactLabel.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & {
-    caption?: React.ReactNode;
-} & React.RefAttributes<HTMLLabelElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare const FormLabel: React$1.ForwardRefExoticComponent<Omit<FormLabelProps, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
 
-type FormControlProps = React.ComponentPropsWithoutRef<typeof Slot>;
-declare const FormControl: (props: Omit<_radix_ui_react_slot.SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type FormControlProps = React$1.ComponentPropsWithoutRef<typeof Slot>;
+declare const FormControl: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_slot.SlotProps & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
 
-type FormMessageProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare const FormMessage: (props: FormMessageProps & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type FormMessageProps = React$1.HTMLAttributes<HTMLParagraphElement>;
+declare const FormMessage: React$1.ForwardRefExoticComponent<FormMessageProps & React$1.RefAttributes<HTMLParagraphElement>>;
 
-type FormDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
-declare const FormDescription: (props: FormDescriptionProps & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type FormDescriptionProps = React$1.HTMLAttributes<HTMLParagraphElement>;
+declare const FormDescription: React$1.ForwardRefExoticComponent<FormDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+
+type HelperTextProps = React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement> & {
+    type?: HelperTextType;
+};
+declare function HelperText({ className, children, type, role, ref, ...props }: HelperTextProps): react_jsx_runtime.JSX.Element;
 
 declare const helperTextCva: (props?: ({
     type?: "error" | "description" | null | undefined;
@@ -275,64 +255,31 @@ declare const helperTextCva: (props?: ({
 type HelperTextCvaProps = VariantProps<typeof helperTextCva>;
 type HelperTextType = NonNullable<HelperTextCvaProps["type"]>;
 
-type HelperTextProps = React.HTMLAttributes<HTMLParagraphElement> & {
-    type?: HelperTextType;
-};
-declare const HelperText: (props: React.HTMLAttributes<HTMLParagraphElement> & {
-    type?: HelperTextType | undefined;
-} & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type AlertDialogProps = ReactAlertDialog.AlertDialogProps;
-declare const AlertDialog: React.FC<ReactAlertDialog.AlertDialogProps>;
+type AlertDialogProps = AlertDialog$1.AlertDialogProps;
+declare const AlertDialog: React$1.FC<AlertDialog$1.AlertDialogProps>;
 
-type AlertDialogTriggerProps = ReactAlertDialog.AlertDialogTriggerProps;
-declare const AlertDialogTrigger: React.ForwardRefExoticComponent<ReactAlertDialog.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type AlertDialogTriggerProps = AlertDialog$1.AlertDialogTriggerProps;
+declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialog$1.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-type AlertDialogContentProps = React.ComponentPropsWithoutRef<typeof ReactAlertDialog.Content>;
-declare const AlertDialogContent: (props: Omit<ReactAlertDialog.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+type AlertDialogContentProps = React$1.ComponentProps<typeof AlertDialog$1.Content>;
+declare function AlertDialogContent({ className, ...props }: AlertDialogContentProps): react_jsx_runtime.JSX.Element;
 
-type AlertDialogHeaderProps = React__default.HTMLAttributes<HTMLDivElement>;
+type AlertDialogHeaderProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): react_jsx_runtime.JSX.Element;
 
-type AlertDialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type AlertDialogFooterProps = React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
 declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): react_jsx_runtime.JSX.Element;
 
-type AlertDialogTitleProps = React.ComponentPropsWithoutRef<typeof ReactAlertDialog.Title>;
-declare const AlertDialogTitle: (props: Omit<ReactAlertDialog.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type AlertDialogDescriptionProps = React.ComponentPropsWithoutRef<typeof ReactAlertDialog.Description>;
-declare const AlertDialogDescription: (props: Omit<ReactAlertDialog.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-
-type AlertDialogActionProps = ReactAlertDialog.AlertDialogActionProps;
-declare const AlertDialogAction: React.ForwardRefExoticComponent<ReactAlertDialog.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
+type AlertDialogTitleProps = React$1.ComponentProps<typeof AlertDialog$1.Title>;
+declare function AlertDialogTitle({ className, ref, ...props }: AlertDialogTitleProps): react_jsx_runtime.JSX.Element;
 
-type AlertDialogCancelProps = ReactAlertDialog.AlertDialogCancelProps;
-declare const AlertDialogCancel: React.ForwardRefExoticComponent<ReactAlertDialog.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
+type AlertDialogDescriptionProps = React$1.ComponentProps<typeof AlertDialog$1.Description>;
+declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): react_jsx_runtime.JSX.Element;
 
-type ThemeType = "light" | "dark";
-interface ThemeContextType {
-    theme: ThemeType;
-    setTheme: React__default.Dispatch<React__default.SetStateAction<ThemeType>>;
-}
-
-declare const ThemeContext: React__default.Context<ThemeContextType>;
-
-interface ThemeProviderProps {
-    /**
-     * Children Components using theming.
-     */
-    children?: React__default.ReactNode;
-    /**
-     * Define the default theme which is set at the beginning if neither local storage nor media is defined.
-     */
-    defaultTheme?: ThemeType;
-    /**
-     * Define theme that is always set initially.
-     */
-    theme?: ThemeType;
-}
-declare function ThemeProvider({ children, defaultTheme, theme }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+type AlertDialogActionProps = AlertDialog$1.AlertDialogActionProps;
+declare const AlertDialogAction: React$1.ForwardRefExoticComponent<AlertDialog$1.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const useTheme: () => ThemeContextType;
+type AlertDialogCancelProps = AlertDialog$1.AlertDialogCancelProps;
+declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<AlertDialog$1.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-export { AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, type AlertDialogProps, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertDialogTriggerProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, type AvatarSizeType, Button, type ButtonColorType, type ButtonProps, type ButtonSizeType, type ButtonVariantType, Card, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, type DialogContentWidth, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, Header, type HeaderProps, HelperText, type HelperTextProps, type HelperTextType, Input, type InputProps, Label, type LabelProps, Select, SelectItem, type SelectItemProps, type SelectProps, Separator, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, type SheetContentSide, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, type SheetProps, SheetTitle, type SheetTitleProps, SheetTrigger, type SheetTriggerProps, Textarea, type TextareaProps, ThemeContext, type ThemeContextType, ThemeProvider, type ThemeProviderProps, type ThemeType, Tooltip, type TooltipProps, TooltipProvider, type TooltipProviderProps, useTheme };
+export { AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, type AlertDialogProps, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertDialogTriggerProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, type AvatarSizeType, Button, type ButtonColorType, type ButtonProps, type ButtonSizeType, type ButtonVariantType, Card, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, type DialogContentWidth, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, type FormProps, Header, type HeaderProps, HelperText, type HelperTextProps, type HelperTextType, Input, type InputProps, Label, type LabelProps, Select, SelectItem, type SelectItemProps, type SelectProps, Separator, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, type SheetContentSide, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, type SheetProps, SheetTitle, type SheetTitleProps, SheetTrigger, type SheetTriggerProps, Textarea, type TextareaProps, Tooltip, type TooltipProps, TooltipProvider, type TooltipProviderProps };