frey-ui 1.0.9 → 1.0.11

package/dist/esm/utils/slot.mjs

@@ -0,0 +1,58 @@
+'use client';
+import clsx from 'clsx';
+import React from 'react';
+import { mergeRefs } from './mergeRefs.mjs';
+
+function isEventHandler(propName, value) {
+    return propName.startsWith('on') && typeof value === 'function';
+}
+function composeEventHandlers(childHandler, slotHandler) {
+    return (event) => {
+        childHandler?.(event);
+        if (!event.defaultPrevented) {
+            slotHandler?.(event);
+        }
+    };
+}
+function mergeProps(slotProps, childProps) {
+    const mergedProps = {
+        ...slotProps,
+        ...childProps
+    };
+    if (slotProps.style || childProps.style) {
+        mergedProps.style = {
+            ...slotProps.style,
+            ...childProps.style
+        };
+    }
+    if (slotProps.className || childProps.className) {
+        mergedProps.className = clsx(slotProps.className, childProps.className);
+    }
+    for (const propName of Object.keys(slotProps)) {
+        const slotValue = slotProps[propName];
+        const childValue = childProps[propName];
+        if (isEventHandler(propName, slotValue)) {
+            mergedProps[propName] = composeEventHandlers(childValue, slotValue);
+        }
+    }
+    return mergedProps;
+}
+function getElementRef(element) {
+    return (element.props.ref ??
+        element.ref);
+}
+const Slot = React.forwardRef(function Slot({ children, ...slotProps }, forwardedRef) {
+    if (!React.isValidElement(children)) {
+        return null;
+    }
+    const mergedProps = mergeProps(slotProps, children.props);
+    const childRef = getElementRef(children);
+    return React.cloneElement(children, {
+        ...mergedProps,
+        ref: mergeRefs(childRef, forwardedRef)
+    });
+});
+Slot.displayName = 'Slot';
+
+export { Slot, composeEventHandlers };
+//# sourceMappingURL=slot.mjs.map

package/dist/esm/utils/slot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.mjs","sources":["../../../src/utils/slot.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAWA,SAAS,cAAc,CACrB,QAAgB,EAChB,KAAc,EAAA;IAEd,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU;AACjE;AAEM,SAAU,oBAAoB,CAClC,YAAsC,EACtC,WAAqC,EAAA;IAErC,OAAO,CAAC,KAAK,KAAI;AACf,QAAA,YAAY,GAAG,KAAK,CAAC;AAErB,QAAA,IAAI,CAAE,KAAkB,CAAC,gBAAgB,EAAE;AACzC,YAAA,WAAW,GAAG,KAAK,CAAC;QACtB;AACF,IAAA,CAAC;AACH;AAEA,SAAS,UAAU,CAAC,SAAmB,EAAE,UAAoB,EAAA;AAC3D,IAAA,MAAM,WAAW,GAAa;AAC5B,QAAA,GAAG,SAAS;AACZ,QAAA,GAAG;KACJ;IAED,IAAI,SAAS,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,EAAE;QACvC,WAAW,CAAC,KAAK,GAAG;YAClB,GAAI,SAAS,CAAC,KAAyC;YACvD,GAAI,UAAU,CAAC;SAChB;IACH;IAEA,IAAI,SAAS,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,EAAE;AAC/C,QAAA,WAAW,CAAC,SAAS,GAAG,IAAI,CAC1B,SAAS,CAAC,SAA+B,EACzC,UAAU,CAAC,SAA+B,CAC3C;IACH;IAEA,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;AAC7C,QAAA,MAAM,SAAS,GAAG,SAAS,CAAC,QAAQ,CAAC;AACrC,QAAA,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC;AAEvC,QAAA,IAAI,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE;YACvC,WAAW,CAAC,QAAQ,CAAC,GAAG,oBAAoB,CAC1C,UAAsC,EACtC,SAAS,CACV;QACH;IACF;AAEA,IAAA,OAAO,WAAW;AACpB;AAEA,SAAS,aAAa,CACpB,OAA2B,EAAA;AAE3B,IAAA,QACG,OAAO,CAAC,KAAsC,CAAC,GAAG;QAClD,OAAmD,CAAC,GAAG;AAE5D;AAMO,MAAM,IAAI,GAEb,KAAK,CAAC,UAAU,CAAyB,SAAS,IAAI,CACxD,EAAE,QAAQ,EAAE,GAAG,SAAS,EAAE,EAC1B,YAAY,EAAA;IAEZ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;AACnC,QAAA,OAAO,IAAI;IACb;IAEA,MAAM,WAAW,GAAG,UAAU,CAC5B,SAAqB,EACrB,QAAQ,CAAC,KAAiB,CAC3B;AACD,IAAA,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;AAExC,IAAA,OAAO,KAAK,CAAC,YAAY,CAAC,QAAQ,EAAE;AAClC,QAAA,GAAG,WAAW;AACd,QAAA,GAAG,EAAE,SAAS,CAAC,QAAkC,EAAE,YAAY;AACrC,KAAA,CAAC;AAC/B,CAAC;AAED,IAAI,CAAC,WAAW,GAAG,MAAM;;;;"}

package/dist/index.d.ts

@@ -1,5 +1,31 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import React from 'react';
+import React, { ReactNode, CSSProperties } from 'react';
+
+type AccordionType = 'single' | 'multiple';
+type AccordionProps = React.HTMLAttributes<HTMLDivElement> & {
+    type?: AccordionType;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+};
+type AccordionRootComponent = React.ForwardRefExoticComponent<Readonly<AccordionProps> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionRoot: AccordionRootComponent;
+type AccordionItemProps = React.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+};
+type AccordionItemComponent = React.ForwardRefExoticComponent<Readonly<AccordionItemProps> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: AccordionItemComponent;
+type AccordionTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+type AccordionTriggerComponent = React.ForwardRefExoticComponent<Readonly<AccordionTriggerProps> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionTrigger: AccordionTriggerComponent;
+type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
+type AccordionContentComponent = React.ForwardRefExoticComponent<Readonly<AccordionContentProps> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionContent: AccordionContentComponent;
+type AccordionComponent = typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
+};
+declare const Accordion: AccordionComponent;
 
 type AlertVariant = 'error' | 'success' | 'warning' | 'info';
 type AlertProps = {
@@ -9,7 +35,25 @@ type AlertProps = {
     className?: string;
     style?: React.CSSProperties;
 };
-declare function Alert({ variant, title, children, className, style }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
+type AlertComponent = React.ForwardRefExoticComponent<Readonly<AlertProps> & React.RefAttributes<HTMLDivElement>>;
+declare const Alert: AlertComponent;
+
+type AvatarSize = 'sm' | 'md' | 'lg';
+type AvatarStatus = 'online' | 'offline' | 'idle' | 'dnd';
+type AvatarProps = React.HTMLAttributes<HTMLSpanElement> & {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: AvatarSize;
+    status?: AvatarStatus;
+};
+type AvatarComponent = React.ForwardRefExoticComponent<Readonly<AvatarProps> & React.RefAttributes<HTMLSpanElement>>;
+declare const Avatar: AvatarComponent;
+
+type PolymorphicRef<Element extends React.ElementType> = React.ComponentPropsWithRef<Element>['ref'];
+type PolymorphicComponentProps<Element extends React.ElementType, OwnProps extends object = Record<string, never>> = OwnProps & {
+    as?: Element;
+} & Omit<React.ComponentPropsWithoutRef<Element>, keyof OwnProps | 'as'>;
 
 type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'destructive';
 type ButtonSize = 'sm' | 'md' | 'lg';
@@ -22,14 +66,37 @@ type ButtonBaseProps = {
     className?: string;
     style?: React.CSSProperties;
 };
-type ButtonProps<E extends ButtonElement = 'button'> = ButtonBaseProps & {
-    as?: E;
-} & Omit<React.ComponentPropsWithRef<E>, 'as' | 'className' | 'style' | 'ref' | 'disabled'>;
-type ButtonComponent = <E extends ButtonElement = 'button'>(props: Readonly<ButtonProps<E>> & {
-    ref?: React.Ref<E extends 'a' ? HTMLAnchorElement : HTMLButtonElement>;
-}) => React.ReactElement | null;
+type ButtonProps<E extends ButtonElement = 'button'> = PolymorphicComponentProps<E, ButtonBaseProps>;
+type ButtonComponent = (<E extends ButtonElement = 'button'>(props: Readonly<ButtonProps<E>> & {
+    ref?: PolymorphicRef<E>;
+}) => React.ReactElement | null) & {
+    displayName?: string;
+};
 declare const Button: ButtonComponent;
 
+type CardProps = React.HTMLAttributes<HTMLDivElement>;
+type CardRootComponent = React.ForwardRefExoticComponent<Readonly<CardProps> & React.RefAttributes<HTMLDivElement>>;
+declare const CardRoot: CardRootComponent;
+type CardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type CardHeaderComponent = React.ForwardRefExoticComponent<Readonly<CardHeaderProps> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: CardHeaderComponent;
+type CardTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+type CardTitleComponent = React.ForwardRefExoticComponent<Readonly<CardTitleProps> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardTitle: CardTitleComponent;
+type CardContentProps = React.HTMLAttributes<HTMLDivElement>;
+type CardContentComponent = React.ForwardRefExoticComponent<Readonly<CardContentProps> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: CardContentComponent;
+type CardFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type CardFooterComponent = React.ForwardRefExoticComponent<Readonly<CardFooterProps> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: CardFooterComponent;
+type CardComponent = typeof CardRoot & {
+    Header: typeof CardHeader;
+    Title: typeof CardTitle;
+    Content: typeof CardContent;
+    Footer: typeof CardFooter;
+};
+declare const Card: CardComponent;
+
 type CheckboxSize = 'sm' | 'md' | 'lg';
 type CheckboxProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'style'> & {
     label: string;
@@ -39,7 +106,8 @@ type CheckboxProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' |
     className?: string;
     style?: React.CSSProperties;
 };
-declare const Checkbox: React.ForwardRefExoticComponent<Readonly<CheckboxProps> & React.RefAttributes<HTMLInputElement>>;
+type CheckboxComponent = React.ForwardRefExoticComponent<Readonly<CheckboxProps> & React.RefAttributes<HTMLInputElement>>;
+declare const Checkbox: CheckboxComponent;
 
 type Variant = 'default' | 'outlined';
 type ChipElement = 'button' | 'div' | 'span' | 'a';
@@ -50,15 +118,245 @@ type ChipBaseProps = {
     style?: React.CSSProperties;
     className?: string;
 };
-type ChipProps<E extends ChipElement = 'span'> = ChipBaseProps & {
-    as?: E;
+type ChipProps<E extends ChipElement = 'span'> = PolymorphicComponentProps<E, ChipBaseProps & {
     onClick?: React.MouseEventHandler<ChipElementNode<E>>;
-} & Omit<React.ComponentPropsWithRef<E>, 'as' | 'children' | 'className' | 'style' | 'onClick' | 'ref'>;
-type ChipComponent = <E extends ChipElement = 'span'>(props: Readonly<ChipProps<E>> & {
+    children?: never;
+}>;
+type ChipComponent = (<E extends ChipElement = 'span'>(props: Readonly<ChipProps<E>> & {
     ref?: React.Ref<ChipElementNode<E>>;
-}) => React.ReactElement | null;
+}) => React.ReactElement | null) & {
+    displayName?: string;
+};
 declare const Chip: ChipComponent;
 
+type DialogProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+};
+type DialogRootComponent = {
+    (props: Readonly<DialogProps>): React.JSX.Element;
+    displayName?: string;
+};
+declare const DialogRoot: DialogRootComponent;
+type DialogTriggerProps = {
+    children: React.ReactNode;
+    asChild?: boolean;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
+type DialogTriggerComponent = React.ForwardRefExoticComponent<Readonly<DialogTriggerProps> & React.RefAttributes<HTMLElement>>;
+declare const DialogTrigger: DialogTriggerComponent;
+type DialogContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    closeLabel?: string;
+    closeOnEscape?: boolean;
+    closeOnOverlayClick?: boolean;
+    hideCloseButton?: boolean;
+    containerClassName?: string;
+};
+type DialogContentComponent = React.ForwardRefExoticComponent<Readonly<DialogContentProps> & React.RefAttributes<HTMLDialogElement>>;
+declare const DialogContent: DialogContentComponent;
+type DialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogHeaderComponent = React.ForwardRefExoticComponent<Readonly<DialogHeaderProps> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: DialogHeaderComponent;
+type DialogTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+type DialogTitleComponent = React.ForwardRefExoticComponent<Readonly<DialogTitleProps> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogTitle: DialogTitleComponent;
+type DialogDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+type DialogDescriptionComponent = React.ForwardRefExoticComponent<Readonly<DialogDescriptionProps> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DialogDescription: DialogDescriptionComponent;
+type DialogBodyProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogBodyComponent = React.ForwardRefExoticComponent<Readonly<DialogBodyProps> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogBody: DialogBodyComponent;
+type DialogFooterProps = React.HTMLAttributes<HTMLDivElement>;
+type DialogFooterComponent = React.ForwardRefExoticComponent<Readonly<DialogFooterProps> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogFooter: DialogFooterComponent;
+type DialogComponent = typeof DialogRoot & {
+    Trigger: typeof DialogTrigger;
+    Content: typeof DialogContent;
+    Header: typeof DialogHeader;
+    Title: typeof DialogTitle;
+    Description: typeof DialogDescription;
+    Body: typeof DialogBody;
+    Footer: typeof DialogFooter;
+};
+declare const Dialog: DialogComponent;
+
+type DropdownMenuPlacement = 'top' | 'right' | 'bottom' | 'left';
+type DropdownMenuProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: DropdownMenuPlacement;
+    offset?: number;
+    closeOnEscape?: boolean;
+    closeOnOutsideClick?: boolean;
+    children: React.ReactNode;
+};
+type DropdownMenuRootComponent = {
+    (props: Readonly<DropdownMenuProps>): React.JSX.Element;
+    displayName?: string;
+};
+declare const DropdownMenuRoot: DropdownMenuRootComponent;
+type DropdownMenuTriggerProps = {
+    children: React.ReactNode;
+    asChild?: boolean;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
+type DropdownMenuTriggerComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuTriggerProps> & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuTrigger: DropdownMenuTriggerComponent;
+type DropdownMenuContentProps = React.HTMLAttributes<HTMLMenuElement>;
+type DropdownMenuContentComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuContentProps> & React.RefAttributes<HTMLMenuElement>>;
+declare const DropdownMenuContent: DropdownMenuContentComponent;
+type DropdownMenuItemProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    destructive?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+};
+type DropdownMenuItemComponent = React.ForwardRefExoticComponent<Readonly<DropdownMenuItemProps> & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuItem: DropdownMenuItemComponent;
+type DropdownMenuComponent = typeof DropdownMenuRoot & {
+    Trigger: typeof DropdownMenuTrigger;
+    Content: typeof DropdownMenuContent;
+    Item: typeof DropdownMenuItem;
+};
+declare const DropdownMenu: DropdownMenuComponent;
+
+type FieldRenderProps = {
+    inputId: string;
+    labelId: string;
+    describedBy?: string;
+    hasError: boolean;
+};
+type FieldProps = {
+    children: (props: Readonly<FieldRenderProps>) => ReactNode;
+    label: string;
+    hideLabel?: boolean;
+    error?: string;
+    helperText?: string;
+    required?: boolean;
+    disabled?: boolean;
+    id?: string;
+    className?: string;
+    style?: CSSProperties;
+    labelElement?: 'label' | 'span';
+};
+declare function Field({ children, label, hideLabel, error, helperText, required, disabled, id, className, style, labelElement }: Readonly<FieldProps>): ReactNode;
+
+type IconSizeToken = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type IconStrokeToken = 'thin' | 'regular' | 'bold';
+type IconProps = {
+    size?: IconSizeToken | number;
+    strokeWidth?: IconStrokeToken | number;
+    title?: string;
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare function CloseIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function ChevronDownIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function CheckIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function MinusIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function CircleXIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function CircleCheckIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function TriangleAlertIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+declare function CircleInfoIcon({ size, strokeWidth, title, className, style }: Readonly<IconProps>): React.JSX.Element;
+type IconsMap = {
+    CloseIcon: typeof CloseIcon;
+    ChevronDownIcon: typeof ChevronDownIcon;
+    CheckIcon: typeof CheckIcon;
+    MinusIcon: typeof MinusIcon;
+    CircleXIcon: typeof CircleXIcon;
+    CircleCheckIcon: typeof CircleCheckIcon;
+    TriangleAlertIcon: typeof TriangleAlertIcon;
+    CircleInfoIcon: typeof CircleInfoIcon;
+};
+declare const Icons: IconsMap;
+
+type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
+type PopoverProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: PopoverPlacement;
+    offset?: number;
+    closeOnEscape?: boolean;
+    closeOnOutsideClick?: boolean;
+    children: React.ReactNode;
+};
+type PopoverRootComponent = {
+    (props: Readonly<PopoverProps>): React.JSX.Element;
+    displayName?: string;
+};
+declare const PopoverRoot: PopoverRootComponent;
+type PopoverTriggerProps = {
+    children: React.ReactNode;
+    asChild?: boolean;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>;
+type PopoverTriggerComponent = React.ForwardRefExoticComponent<Readonly<PopoverTriggerProps> & React.RefAttributes<HTMLElement>>;
+declare const PopoverTrigger: PopoverTriggerComponent;
+type PopoverContentProps = React.HTMLAttributes<HTMLDivElement>;
+type PopoverContentComponent = React.ForwardRefExoticComponent<Readonly<PopoverContentProps> & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: PopoverContentComponent;
+type PopoverComponent = typeof PopoverRoot & {
+    Trigger: typeof PopoverTrigger;
+    Content: typeof PopoverContent;
+};
+declare const Popover: PopoverComponent;
+
+type ProgressSize = 'sm' | 'md' | 'lg';
+type ProgressProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'style'> & {
+    value?: number;
+    max?: number;
+    indeterminate?: boolean;
+    label?: string;
+    showValue?: boolean;
+    size?: ProgressSize;
+    className?: string;
+    style?: React.CSSProperties;
+    barClassName?: string;
+};
+type ProgressComponent = React.ForwardRefExoticComponent<Readonly<ProgressProps> & React.RefAttributes<HTMLDivElement>>;
+declare const Progress: ProgressComponent;
+
+type RadioGroupOrientation = 'vertical' | 'horizontal';
+type RadioOption = {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+};
+type RadioGroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'className' | 'style' | 'children'> & {
+    label: string;
+    options: ReadonlyArray<RadioOption>;
+    value?: string;
+    defaultValue?: string;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    hideLabel?: boolean;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    orientation?: RadioGroupOrientation;
+    name?: string;
+    id?: string;
+    className?: string;
+    style?: React.CSSProperties;
+};
+type RadioGroupComponent = React.ForwardRefExoticComponent<Readonly<RadioGroupProps> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: RadioGroupComponent;
+
+type SelectSize = 'sm' | 'md' | 'lg';
+type SelectProps = Omit<React.SelectHTMLAttributes<HTMLSelectElement>, 'size' | 'className' | 'style'> & {
+    label: string;
+    hideLabel?: boolean;
+    error?: string;
+    helperText?: string;
+    placeholder?: string;
+    size?: SelectSize;
+    className?: string;
+    style?: React.CSSProperties;
+};
+type SelectComponent = React.ForwardRefExoticComponent<Readonly<SelectProps> & React.RefAttributes<HTMLSelectElement>>;
+declare const Select: SelectComponent;
+
 type SkeletonShape = 'rectangle' | 'circle';
 type SkeletonProps = {
     width?: string | number;
@@ -67,7 +365,18 @@ type SkeletonProps = {
     className?: string;
     style?: React.CSSProperties;
 };
-declare function Skeleton({ width, height, shape, className, style }: Readonly<SkeletonProps>): react_jsx_runtime.JSX.Element;
+type SkeletonComponent = React.ForwardRefExoticComponent<Readonly<SkeletonProps> & React.RefAttributes<HTMLSpanElement>>;
+declare const Skeleton: SkeletonComponent;
+
+type SpinnerSize = 'sm' | 'md' | 'lg';
+type SpinnerProps = {
+    size?: SpinnerSize | number;
+    label?: string;
+    className?: string;
+    style?: React.CSSProperties;
+};
+type SpinnerComponent = React.ForwardRefExoticComponent<Readonly<SpinnerProps> & React.RefAttributes<HTMLOutputElement>>;
+declare const Spinner: SpinnerComponent;
 
 type SwitchSize = 'sm' | 'md' | 'lg';
 type SwitchProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'className' | 'style'> & {
@@ -77,7 +386,48 @@ type SwitchProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 's
     className?: string;
     style?: React.CSSProperties;
 };
-declare const Switch: React.ForwardRefExoticComponent<Readonly<SwitchProps> & React.RefAttributes<HTMLInputElement>>;
+type SwitchComponent = React.ForwardRefExoticComponent<Readonly<SwitchProps> & React.RefAttributes<HTMLInputElement>>;
+declare const Switch: SwitchComponent;
+
+type TabsProps = React.HTMLAttributes<HTMLDivElement> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type TabsRootComponent = React.ForwardRefExoticComponent<Readonly<TabsProps> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsRoot: TabsRootComponent;
+type TabsListProps = React.HTMLAttributes<HTMLDivElement>;
+type TabsListComponent = React.ForwardRefExoticComponent<Readonly<TabsListProps> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: TabsListComponent;
+type TabsTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+};
+type TabsTriggerComponent = React.ForwardRefExoticComponent<Readonly<TabsTriggerProps> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsTrigger: TabsTriggerComponent;
+type TabsContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+};
+type TabsContentComponent = React.ForwardRefExoticComponent<Readonly<TabsContentProps> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsContent: TabsContentComponent;
+type TabsComponent = typeof TabsRoot & {
+    List: typeof TabsList;
+    Trigger: typeof TabsTrigger;
+    Content: typeof TabsContent;
+};
+declare const Tabs: TabsComponent;
+
+type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
+type TextareaProps = Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'className' | 'style'> & {
+    label: string;
+    hideLabel?: boolean;
+    error?: string;
+    helperText?: string;
+    resize?: TextareaResize;
+    className?: string;
+    style?: React.CSSProperties;
+};
+type TextareaComponent = React.ForwardRefExoticComponent<Readonly<TextareaProps> & React.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: TextareaComponent;
 
 type TextInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'className' | 'style'> & {
     label: string;
@@ -88,17 +438,65 @@ type TextInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' |
     className?: string;
     style?: React.CSSProperties;
 };
-declare const TextInput: React.ForwardRefExoticComponent<Readonly<TextInputProps> & React.RefAttributes<HTMLInputElement>>;
+type TextInputComponent = React.ForwardRefExoticComponent<Readonly<TextInputProps> & React.RefAttributes<HTMLInputElement>>;
+declare const TextInput: TextInputComponent;
 
-type FreyTheme = 'light' | 'dark';
+type FreyTheme = 'light' | 'dark' | 'system';
 type ThemeProviderProps = {
     children: React.ReactNode;
     theme?: FreyTheme;
+    highContrast?: boolean;
+    id?: string;
+    className?: string;
+    style?: React.CSSProperties;
+};
+declare function ThemeProvider({ children, theme, highContrast, id, className, style }: Readonly<ThemeProviderProps>): React.JSX.Element;
+
+type ToastVariant = 'info' | 'success' | 'warning' | 'error';
+type ToastPlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+type ToastAction = {
+    label: string;
+    onClick: () => void;
+};
+type ToastOptions = {
+    id?: string;
+    title?: string;
+    description: string;
+    variant?: ToastVariant;
+    duration?: number;
+    action?: ToastAction;
+};
+type ToastProviderProps = {
+    children: React.ReactNode;
+    placement?: ToastPlacement;
+    limit?: number;
+    className?: string;
+    style?: React.CSSProperties;
+};
+type ToastContextValue = {
+    toast: (options: ToastOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+};
+declare function ToastProvider({ children, placement, limit, className, style }: Readonly<ToastProviderProps>): React.JSX.Element;
+declare function useToast(): ToastContextValue;
+
+type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+type TooltipProps = {
+    children: React.ReactNode;
+    asChild?: boolean;
+    content: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: TooltipPlacement;
+    offset?: number;
+    delay?: number;
     id?: string;
     className?: string;
     style?: React.CSSProperties;
 };
-declare function ThemeProvider({ children, theme, id, className, style }: Readonly<ThemeProviderProps>): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ children, asChild, content, open, defaultOpen, onOpenChange, placement, offset, delay, id, className, style }: Readonly<TooltipProps>): React.JSX.Element;
 
-export { Alert, Button, Checkbox, Chip, Skeleton, Switch, TextInput, ThemeProvider };
-export type { AlertProps, AlertVariant, ButtonElement, ButtonProps, ButtonSize, ButtonVariant, CheckboxProps, CheckboxSize, ChipElement, ChipProps, FreyTheme, SkeletonProps, SkeletonShape, SwitchProps, SwitchSize, TextInputProps, ThemeProviderProps, Variant };
+export { Accordion, Alert, Avatar, Button, Card, CheckIcon, Checkbox, ChevronDownIcon, Chip, CircleCheckIcon, CircleInfoIcon, CircleXIcon, CloseIcon, Dialog, DropdownMenu, Field, Icons, MinusIcon, Popover, Progress, RadioGroup, Select, Skeleton, Spinner, Switch, Tabs, TextInput, Textarea, ThemeProvider, ToastProvider, Tooltip, TriangleAlertIcon, useToast };
+export type { AccordionContentProps, AccordionItemProps, AccordionProps, AccordionTriggerProps, AccordionType, AlertProps, AlertVariant, AvatarProps, AvatarSize, AvatarStatus, ButtonElement, ButtonProps, ButtonSize, ButtonVariant, CardContentProps, CardFooterProps, CardHeaderProps, CardProps, CardTitleProps, CheckboxProps, CheckboxSize, ChipElement, ChipProps, DialogBodyProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DialogTitleProps, DialogTriggerProps, DropdownMenuContentProps, DropdownMenuItemProps, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuTriggerProps, FieldProps, FieldRenderProps, FreyTheme, IconProps, IconSizeToken, IconStrokeToken, PopoverContentProps, PopoverPlacement, PopoverProps, PopoverTriggerProps, ProgressProps, ProgressSize, RadioGroupOrientation, RadioGroupProps, RadioOption, SelectProps, SelectSize, SkeletonProps, SkeletonShape, SpinnerProps, SpinnerSize, SwitchProps, SwitchSize, TabsContentProps, TabsListProps, TabsProps, TabsTriggerProps, TextInputProps, TextareaProps, TextareaResize, ThemeProviderProps, ToastAction, ToastOptions, ToastPlacement, ToastProviderProps, ToastVariant, TooltipPlacement, TooltipProps, Variant };