@aivex/ui 1.1.0-dev.2 → 1.1.0-dev.20

package/dist/components/BreadCrumb/BreadCrumb.d.ts

@@ -1,19 +1,25 @@
-import type { AnchorHTMLAttributes, HTMLAttributes, Ref } from "react";
-export interface BreadCrumbItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    label: string;
-    href?: string;
-    current?: boolean;
-    ref?: Ref<HTMLAnchorElement>;
-}
-declare function BreadCrumbItem({ className, label, href, current, ref, ...props }: BreadCrumbItemProps): import("react/jsx-runtime").JSX.Element;
+import type { ElementType, HTMLAttributes, ReactNode, Ref } from "react";
 export interface BreadCrumbItemDef {
-    label: string;
+    label: ReactNode;
+    /**
+     * 렌더링할 컴포넌트를 직접 지정합니다.
+     * 예: Next.js `Link`, React Router `NavLink` 등
+     * 지정하지 않으면 href 유무에 따라 <a> 또는 <button>으로 자동 선택됩니다.
+     */
+    as?: ElementType;
+    /** 있으면 <a href> 로 렌더링 (시맨틱 / 새 탭 열기 지원) */
     href?: string;
-    current?: boolean;
+    /** 클릭 핸들러 (SPA 라우팅 등) */
+    onClick?: () => void;
 }
 export interface BreadCrumbProps extends HTMLAttributes<HTMLElement> {
     items: BreadCrumbItemDef[];
+    /**
+     * 이 값을 초과하면 중간 항목을 ··· 으로 축소합니다.
+     * 예: maxItems=3이고 항목이 5개면 → 첫번째 / ··· / 마지막
+     */
+    maxItems?: number;
     ref?: Ref<HTMLElement>;
 }
-declare function BreadCrumb({ className, items, ref, ...props }: BreadCrumbProps): import("react/jsx-runtime").JSX.Element;
-export { BreadCrumb, BreadCrumbItem };
+declare function BreadCrumb({ className, items, maxItems, ref, ...props }: BreadCrumbProps): import("react/jsx-runtime").JSX.Element;
+export { BreadCrumb };

package/dist/components/BreadCrumb/index.d.ts

@@ -1,2 +1,2 @@
-export type { BreadCrumbItemDef, BreadCrumbItemProps, BreadCrumbProps } from "./BreadCrumb";
-export { BreadCrumb, BreadCrumbItem } from "./BreadCrumb";
+export type { BreadCrumbItemDef, BreadCrumbProps } from "./BreadCrumb";
+export { BreadCrumb } from "./BreadCrumb";

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

@@ -3,17 +3,16 @@ import type { ButtonHTMLAttributes, ReactNode, Ref } from "react";
 declare const buttonVariantStyles: (props?: ({
     variant?: "solid" | "outline" | "ghost" | null | undefined;
     color?: "danger" | "primary" | "secondary" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon-sm" | "icon-md" | "icon-lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 type ButtonVariantProps = VariantProps<typeof buttonVariantStyles>;
 declare function buttonVariants({ variant, color, size, className, }?: ButtonVariantProps & {
     className?: string;
 }): string;
-export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "color" | "prefix">, ButtonVariantProps {
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "color">, ButtonVariantProps {
     asChild?: boolean;
-    prefix?: ReactNode;
-    suffix?: ReactNode;
+    children?: ReactNode;
     ref?: Ref<HTMLButtonElement>;
 }
-declare function Button({ className, variant, color, size, asChild, ref, prefix, suffix, children, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;
+declare function Button({ className, variant, color, size, asChild, ref, children, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;
 export { Button, buttonVariants };

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

@@ -1,7 +1,7 @@
 import { type VariantProps } from "class-variance-authority";
 import { type InputHTMLAttributes, type Ref } from "react";
 declare const checkboxVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type">, VariantProps<typeof checkboxVariants> {
     label?: string;

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

@@ -0,0 +1,7 @@
+import React, { type InputHTMLAttributes, type Ref } from "react";
+export interface ChipsCheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onClick"> {
+    ref?: Ref<HTMLInputElement>;
+    onClick?: React.MouseEventHandler<HTMLLabelElement>;
+}
+declare function ChipsCheckbox({ className, disabled, checked, defaultChecked, onChange, onClick, id, ref, ...props }: ChipsCheckboxProps): import("react/jsx-runtime").JSX.Element;
+export { ChipsCheckbox };

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

@@ -1,2 +1,4 @@
 export type { CheckboxProps } from "./Checkbox";
 export { Checkbox, checkboxVariants } from "./Checkbox";
+export type { ChipsCheckboxProps } from "./ChipsCheckbox";
+export { ChipsCheckbox } from "./ChipsCheckbox";

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

@@ -1,14 +1,17 @@
 import { type VariantProps } from "class-variance-authority";
 import type { ButtonHTMLAttributes, ReactNode, Ref } from "react";
 declare const iconButtonVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
     shape?: "rounded" | "rectangle" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface IconButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type">, VariantProps<typeof iconButtonVariants> {
-    variant?: "default" | "on-color";
+    /** 아이콘 색상 — primary: 기본(어두운) 배경, white: 어두운 배경 위 */
+    color?: "primary" | "white";
+    /** true 이면 danger 색상 적용 (color 보다 우선) */
+    error?: boolean;
     asChild?: boolean;
     children?: ReactNode;
     ref?: Ref<HTMLButtonElement>;
 }
-declare function IconButton({ className, size, shape, variant, asChild, children, ref, ...props }: IconButtonProps): import("react/jsx-runtime").JSX.Element;
+declare function IconButton({ className, size, shape, color, error, asChild, children, ref, ...props }: IconButtonProps): import("react/jsx-runtime").JSX.Element;
 export { IconButton, iconButtonVariants };

package/dist/components/InputBase/InputBase.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from "react";
+declare const inputContainerVariants: (props?: ({
+    state?: "default" | "disabled" | "error" | "focused" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+    layout?: "wrap" | "inline" | "block" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type InputLayout = "inline" | "block" | "wrap";
+export type InputState = "default" | "focused" | "error" | "disabled";
+export interface InputBaseProps {
+    id?: string;
+    label?: string;
+    /** 인풋 하단 도움말 텍스트. error=true 이면 danger 색상으로 표시 */
+    helperText?: string;
+    error?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+    size?: "sm" | "md";
+    layout?: InputLayout;
+    /** 인풋 컨테이너 왼쪽 슬롯 */
+    leadingElement?: ReactNode;
+    /** 인풋 컨테이너 오른쪽 슬롯 */
+    trailingElement?: ReactNode;
+    /** 인풋 컨테이너(border 박스)에 추가할 className */
+    containerClassName?: string;
+    /** 최외곽 래퍼 div 에 추가할 className */
+    className?: string;
+    children: ReactNode;
+}
+declare function InputBase({ id, label, helperText, error, disabled, focused, size, layout, leadingElement, trailingElement, containerClassName, className, children, }: InputBaseProps): import("react/jsx-runtime").JSX.Element;
+export { InputBase, inputContainerVariants };

package/dist/components/InputBase/index.d.ts

@@ -0,0 +1 @@
+export * from "./InputBase";

package/dist/components/Menu/Menu.d.ts

@@ -1,18 +1,84 @@
-import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode, Ref } from "react";
-declare const menuItemVariants: (props?: ({
-    danger?: boolean | null | undefined;
-    activated?: boolean | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export interface MenuItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
-    label: string;
+import * as DropdownMenu from "@radix-ui/react-dropdown-menu";
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from "react";
+type MenuRootProps = ComponentPropsWithoutRef<typeof DropdownMenu.Root>;
+declare function MenuRoot(props: MenuRootProps): import("react/jsx-runtime").JSX.Element;
+type MenuTriggerProps = ComponentPropsWithoutRef<typeof DropdownMenu.Trigger> & {
+    ref?: Ref<HTMLButtonElement>;
+};
+declare function MenuTrigger({ ref, ...props }: MenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+type MenuContentProps = ComponentPropsWithoutRef<typeof DropdownMenu.Content> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuContent({ className, sideOffset, ref, ...props }: MenuContentProps): import("react/jsx-runtime").JSX.Element;
+type MenuGroupProps = ComponentPropsWithoutRef<typeof DropdownMenu.Group> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuGroup({ className, ref, ...props }: MenuGroupProps): import("react/jsx-runtime").JSX.Element;
+type MenuSeparatorProps = ComponentPropsWithoutRef<typeof DropdownMenu.Separator> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuSeparator({ className, ref, ...props }: MenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+type MenuLabelProps = ComponentPropsWithoutRef<typeof DropdownMenu.Label> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuLabel({ className, ref, ...props }: MenuLabelProps): import("react/jsx-runtime").JSX.Element;
+interface MenuItemProps extends Omit<ComponentPropsWithoutRef<typeof DropdownMenu.Item>, "children"> {
+    /** label/icon으로 렌더할 때 사용. asChild 모드에선 무시 */
+    label?: ReactNode;
     icon?: ReactNode;
     danger?: boolean;
-    activated?: boolean;
-    ref?: Ref<HTMLButtonElement>;
+    /** Radix asChild — 자식 컴포넌트(Link 등)에 메뉴 동작/스타일 위임 */
+    asChild?: boolean;
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function MenuItem({ className, label, icon, danger, asChild, children, ref, ...props }: MenuItemProps): import("react/jsx-runtime").JSX.Element;
+interface MenuCheckboxItemProps extends ComponentPropsWithoutRef<typeof DropdownMenu.CheckboxItem> {
+    label?: ReactNode;
+    icon?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare function MenuCheckboxItem({ className, label, icon, children, ref, ...props }: MenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+type MenuRadioGroupProps = ComponentPropsWithoutRef<typeof DropdownMenu.RadioGroup> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuRadioGroup({ className, ref, ...props }: MenuRadioGroupProps): import("react/jsx-runtime").JSX.Element;
+interface MenuRadioItemProps extends ComponentPropsWithoutRef<typeof DropdownMenu.RadioItem> {
+    label?: ReactNode;
+    icon?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
 }
-declare function MenuItem({ className, label, icon, danger, activated, disabled, onClick, ref, ...props }: MenuItemProps): import("react/jsx-runtime").JSX.Element;
-export interface MenuRootProps extends HTMLAttributes<HTMLDivElement> {
+declare function MenuRadioItem({ className, label, icon, children, ref, ...props }: MenuRadioItemProps): import("react/jsx-runtime").JSX.Element;
+type MenuShortcutProps = ComponentPropsWithoutRef<"span"> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+declare function MenuShortcut({ className, ref, ...props }: MenuShortcutProps): import("react/jsx-runtime").JSX.Element;
+type MenuSubProps = ComponentPropsWithoutRef<typeof DropdownMenu.Sub>;
+declare function MenuSub(props: MenuSubProps): import("react/jsx-runtime").JSX.Element;
+interface MenuSubTriggerProps extends ComponentPropsWithoutRef<typeof DropdownMenu.SubTrigger> {
+    label?: ReactNode;
+    icon?: ReactNode;
     ref?: Ref<HTMLDivElement>;
 }
-declare function MenuRoot({ className, children, ref, ...props }: MenuRootProps): import("react/jsx-runtime").JSX.Element;
-export { MenuItem, MenuRoot, menuItemVariants };
+declare function MenuSubTrigger({ className, label, icon, children, ref, ...props }: MenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+type MenuSubContentProps = ComponentPropsWithoutRef<typeof DropdownMenu.SubContent> & {
+    ref?: Ref<HTMLDivElement>;
+};
+declare function MenuSubContent({ className, sideOffset, ref, ...props }: MenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+declare const Menu: typeof MenuRoot & {
+    Trigger: typeof MenuTrigger;
+    Content: typeof MenuContent;
+    Item: typeof MenuItem;
+    Group: typeof MenuGroup;
+    Separator: typeof MenuSeparator;
+    Label: typeof MenuLabel;
+    CheckboxItem: typeof MenuCheckboxItem;
+    RadioGroup: typeof MenuRadioGroup;
+    RadioItem: typeof MenuRadioItem;
+    Sub: typeof MenuSub;
+    SubTrigger: typeof MenuSubTrigger;
+    SubContent: typeof MenuSubContent;
+    Shortcut: typeof MenuShortcut;
+};
+export type { MenuCheckboxItemProps, MenuContentProps, MenuGroupProps, MenuItemProps, MenuLabelProps, MenuRadioGroupProps, MenuRadioItemProps, MenuRootProps, MenuSeparatorProps, MenuShortcutProps, MenuSubContentProps, MenuSubProps, MenuSubTriggerProps, MenuTriggerProps, };
+export { Menu };

package/dist/components/Menu/index.d.ts

@@ -1,2 +1,2 @@
-export type { MenuItemProps, MenuRootProps } from "./Menu";
-export { MenuItem, MenuRoot, menuItemVariants } from "./Menu";
+export type { MenuCheckboxItemProps, MenuContentProps, MenuGroupProps, MenuItemProps, MenuLabelProps, MenuRadioGroupProps, MenuRadioItemProps, MenuRootProps, MenuSeparatorProps, MenuShortcutProps, MenuSubContentProps, MenuSubProps, MenuSubTriggerProps, MenuTriggerProps, } from "./Menu";
+export { Menu } from "./Menu";

package/dist/components/Nav/Nav.d.ts

@@ -5,19 +5,17 @@ declare const navTileVariants: (props?: ({
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface NavTileProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof navTileVariants> {
     icon?: ReactNode;
-    label?: string;
     ref?: Ref<HTMLButtonElement>;
 }
-declare function NavTile({ className, active, icon, label, children, ref, ...props }: NavTileProps): import("react/jsx-runtime").JSX.Element;
+declare function NavTile({ className, active, icon, children, ref, ...props }: NavTileProps): import("react/jsx-runtime").JSX.Element;
 declare const navItemVariants: (props?: ({
-    selected?: boolean | null | undefined;
+    active?: boolean | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface NavItemProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof navItemVariants> {
     icon?: ReactNode;
-    label?: string;
     ref?: Ref<HTMLButtonElement>;
 }
-declare function NavItem({ className, selected, icon, label, children, ref, ...props }: NavItemProps): import("react/jsx-runtime").JSX.Element;
+declare function NavItem({ className, active, icon, children, ref, ...props }: NavItemProps): import("react/jsx-runtime").JSX.Element;
 export interface NavProps extends HTMLAttributes<HTMLElement> {
     ref?: Ref<HTMLElement>;
 }

package/dist/components/Pagination/Pagination.d.ts

@@ -1,11 +1,25 @@
 import { type HTMLAttributes, type Ref } from "react";
 export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
-    total: number;
-    page?: number;
-    defaultPage?: number;
-    pageSize?: number;
-    onChange?: (page: number) => void;
+    /**
+     * undefined면 컴포넌트를 렌더하지 않음 (최초 로드 시).
+     * 한 번 정의된 후 다시 undefined가 되면 직전 값을 유지해서 깜빡임 방지.
+     */
+    totalPages?: number;
+    page: number;
+    pageSize: number;
+    /** 명시적으로 모든 상호작용 비활성화 (refetch 중, 권한 없음 등) */
+    disabled?: boolean;
+    /**
+     * 페이지 사이즈 셀렉터 옵션. 생략하면 셀렉터가 숨겨짐.
+     * @example [{ value: 10, label: "10 each" }, { value: 50, label: "50 each" }]
+     */
+    pageSizeOptions?: Array<{
+        value: number;
+        label: string;
+    }>;
+    onChange: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
     ref?: Ref<HTMLElement>;
 }
-declare function Pagination({ className, total, page, defaultPage, pageSize, onChange, ref, ...props }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+declare function Pagination({ className, totalPages, page, pageSize, disabled, pageSizeOptions, onChange, onPageSizeChange, ref, ...props }: PaginationProps): import("react/jsx-runtime").JSX.Element | null;
 export { Pagination };

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

@@ -1,7 +1,7 @@
 import { type VariantProps } from "class-variance-authority";
 import type { InputHTMLAttributes, Ref } from "react";
 declare const radioVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type">, VariantProps<typeof radioVariants> {
     label?: string;

package/dist/components/Segmented/Segmented.d.ts

@@ -1,21 +1,15 @@
-import { type VariantProps } from "class-variance-authority";
-import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactNode, type Ref } from "react";
-declare const segmentedRootVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export interface SegmentedRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof segmentedRootVariants> {
-    value?: string;
-    defaultValue?: string;
-    onChange?: (value: string) => void;
-    iconOnly?: boolean;
+import type { ToggleGroupItemProps, ToggleGroupSingleProps } from "@radix-ui/react-toggle-group";
+import { type ReactNode, type RefAttributes } from "react";
+type SegmentedSize = "sm" | "md" | "lg" | "icon-sm" | "icon-md" | "icon-lg";
+export interface SegmentedRootProps extends Omit<ToggleGroupSingleProps, "onValueChange" | "type">, RefAttributes<HTMLDivElement> {
+    size?: SegmentedSize;
+    onValueChange?: (value: string) => void;
+    fullWidth?: boolean;
     children?: ReactNode;
-    ref?: Ref<HTMLDivElement>;
 }
-declare function SegmentedRoot({ className, size, value, defaultValue, onChange, iconOnly, children, ref, ...props }: SegmentedRootProps): import("react/jsx-runtime").JSX.Element;
-export interface SegmentedItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    value: string;
+declare function SegmentedRoot({ className, size, value, defaultValue, onValueChange, fullWidth, children, ref, ...props }: SegmentedRootProps): import("react/jsx-runtime").JSX.Element;
+export type SegmentedItemProps = ToggleGroupItemProps & RefAttributes<HTMLButtonElement> & {
     children?: ReactNode;
-    ref?: Ref<HTMLButtonElement>;
-}
-declare function SegmentedItem({ className, value, children, onClick, ref, ...props }: SegmentedItemProps): import("react/jsx-runtime").JSX.Element;
+};
+declare function SegmentedItem({ className, children, ref, ...props }: SegmentedItemProps): import("react/jsx-runtime").JSX.Element;
 export { SegmentedItem, SegmentedRoot };

package/dist/components/SelectBox/SelectBox.d.ts

@@ -0,0 +1,34 @@
+export interface SelectBoxOption {
+    value: string;
+    label: string;
+    /** option의 key. 미지정 시 value 사용 */
+    key?: string;
+    /** 위험 액션 강조 (빨간색) */
+    danger?: boolean;
+}
+export interface SelectBoxGroup {
+    /** 그룹 타이틀 */
+    title?: string;
+    options: SelectBoxOption[];
+}
+export interface SelectBoxProps {
+    groups: SelectBoxGroup[];
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: "sm" | "md";
+    onChange?: (value: string) => void;
+    /**
+     * 선택된 값이 트리거에 표시될 텍스트를 커스텀하는 함수.
+     * 미지정 시 option.label 을 그대로 표시.
+     * @example renderValue={(option, group) => `${group.title} / ${option.label}`}
+     */
+    renderValue?: (option: SelectBoxOption, group: SelectBoxGroup) => string;
+    /** 최외곽 래퍼에 추가할 className */
+    className?: string;
+    label?: string;
+    helperText?: string;
+    error?: boolean;
+}
+declare function SelectBox({ groups, value, placeholder, disabled, size, onChange, renderValue, className, label, helperText, error, }: SelectBoxProps): import("react/jsx-runtime").JSX.Element;
+export { SelectBox };

package/dist/components/SelectBox/index.d.ts

@@ -0,0 +1,2 @@
+export type { SelectBoxGroup, SelectBoxOption, SelectBoxProps } from "./SelectBox";
+export { SelectBox } from "./SelectBox";

package/dist/components/Shortcut/Shortcut.d.ts

@@ -1,6 +1,7 @@
-import { type HTMLAttributes, type Ref } from "react";
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ShortcutKey = string | ReactNode;
 export interface ShortcutProps extends HTMLAttributes<HTMLSpanElement> {
-    keys: string[];
+    keys: ShortcutKey[];
     ref?: Ref<HTMLSpanElement>;
 }
 declare function Shortcut({ className, keys, ref, ...props }: ShortcutProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Tab/Tab.d.ts

@@ -1,18 +1,19 @@
-import { type VariantProps } from "class-variance-authority";
-import { type ButtonHTMLAttributes, type HTMLAttributes, type Ref } from "react";
-export interface TabRootProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
-    value?: string;
-    defaultValue?: string;
-    onChange?: (value: string) => void;
-    ref?: Ref<HTMLDivElement>;
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import type { ComponentPropsWithoutRef, ComponentRef, Ref } from "react";
+export interface TabRootProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.Root> {
+    ref?: Ref<ComponentRef<typeof TabsPrimitive.Root>>;
 }
-declare function TabRoot({ className, value, defaultValue, onChange, children, ref, ...props }: TabRootProps): import("react/jsx-runtime").JSX.Element;
-declare const tabItemVariants: (props?: ({
-    active?: boolean | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export interface TabItemProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof tabItemVariants> {
-    value: string;
-    ref?: Ref<HTMLButtonElement>;
+declare function TabRoot({ className, ref, ...props }: TabRootProps): import("react/jsx-runtime").JSX.Element;
+export interface TabListProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+    ref?: Ref<ComponentRef<typeof TabsPrimitive.List>>;
 }
-declare function TabItem({ className, value, children, active: activeProp, ref, ...props }: TabItemProps): import("react/jsx-runtime").JSX.Element;
-export { TabItem, TabRoot, tabItemVariants };
+declare function TabList({ className, ref, ...props }: TabListProps): import("react/jsx-runtime").JSX.Element;
+export interface TabTriggerProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> {
+    ref?: Ref<ComponentRef<typeof TabsPrimitive.Trigger>>;
+}
+declare function TabTrigger({ className, ref, ...props }: TabTriggerProps): import("react/jsx-runtime").JSX.Element;
+export interface TabContentProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.Content> {
+    ref?: Ref<ComponentRef<typeof TabsPrimitive.Content>>;
+}
+declare function TabContent({ className, ref, ...props }: TabContentProps): import("react/jsx-runtime").JSX.Element;
+export { TabContent, TabList, TabRoot, TabTrigger };

package/dist/components/Tab/index.d.ts

@@ -1,2 +1,2 @@
-export type { TabItemProps, TabRootProps } from "./Tab";
-export { TabItem, TabRoot, tabItemVariants } from "./Tab";
+export type { TabContentProps, TabListProps, TabRootProps, TabTriggerProps, } from "./Tab";
+export { TabContent, TabList, TabRoot, TabTrigger } from "./Tab";

package/dist/components/Tagbox/Tagbox.d.ts

@@ -1,12 +1,19 @@
 import { type InputHTMLAttributes, type Ref } from "react";
-export interface TagboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange"> {
+export interface TagboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange" | "onPaste"> {
     size?: "sm" | "md";
     label?: string;
+    /** 인풋 하단 도움말 텍스트 */
+    helperText?: string;
     error?: boolean;
     value?: string[];
     defaultValue?: string[];
     onChange?: (tags: string[]) => void;
+    /** 붙여넣기 텍스트를 태그 배열로 파싱하는 함수 */
+    parsePaste?: (text: string) => string[];
+    onPaste?: (e: React.ClipboardEvent<HTMLInputElement>) => void;
+    /** 태그 유효성 검사. false 반환 시 인풋이 error 상태로 전환 */
+    validate?: (tag: string) => boolean;
     ref?: Ref<HTMLInputElement>;
 }
-declare function Tagbox({ className, size, label, error, disabled, value, defaultValue, onChange, placeholder, id, ref, onBlur, onCompositionEnd, onCompositionStart, onFocus, onKeyDown, ...props }: TagboxProps): import("react/jsx-runtime").JSX.Element;
+declare function Tagbox({ className, size, label, helperText, error, disabled, value, defaultValue, onChange, parsePaste, validate, placeholder, id, ref, onBlur, onCompositionEnd, onCompositionStart, onFocus, onKeyDown, onPaste, ...props }: TagboxProps): import("react/jsx-runtime").JSX.Element;
 export { Tagbox };

package/dist/components/Textarea/Textarea.d.ts

@@ -1,13 +1,19 @@
-import { type VariantProps } from "class-variance-authority";
-import type { Ref, TextareaHTMLAttributes } from "react";
-declare const textareaWrapperVariants: (props?: ({
-    state?: "default" | "disabled" | "focused" | "error" | null | undefined;
-    size?: "sm" | "md" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size">, Pick<VariantProps<typeof textareaWrapperVariants>, "size"> {
+import type { ReactNode, Ref, TextareaHTMLAttributes } from "react";
+export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    size?: "sm" | "md";
     label?: string;
+    /** 인풋 하단 도움말 텍스트 */
+    helperText?: string;
     error?: boolean;
+    /** 초기 최소 높이 (CSS 값. 예: "120px", "8rem") */
+    minHeight?: string | number;
+    /** true 이면 높이를 고정하여 resize 비활성화 */
+    fixedHeight?: boolean;
+    /** Textarea 좌측 슬롯 */
+    leadingElement?: ReactNode;
+    /** Textarea 우측 슬롯 */
+    trailingElement?: ReactNode;
     ref?: Ref<HTMLTextAreaElement>;
 }
-declare function Textarea({ className, label, error, disabled, size, id, ref, onFocus, onBlur, ...props }: TextareaProps): import("react/jsx-runtime").JSX.Element;
-export { Textarea, textareaWrapperVariants };
+declare function Textarea({ className, label, helperText, error, disabled, size, minHeight, fixedHeight, leadingElement, trailingElement, id, ref, onFocus, onBlur, ...props }: TextareaProps): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/dist/components/Textarea/index.d.ts

@@ -1,2 +1,2 @@
 export type { TextareaProps } from "./Textarea";
-export { Textarea, textareaWrapperVariants } from "./Textarea";
+export { Textarea } from "./Textarea";

package/dist/components/Textbox/Textbox.d.ts

@@ -0,0 +1,18 @@
+import type { InputHTMLAttributes, ReactNode, Ref } from "react";
+import { inputContainerVariants } from "@/components/InputBase";
+export interface TextboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    size?: "sm" | "md";
+    label?: string;
+    /** 인풋 하단 도움말 텍스트 */
+    helperText?: string;
+    error?: boolean;
+    /** 입력값 전체 삭제 버튼 표시 여부 */
+    clearable?: boolean;
+    /** 인풋 좌측 슬롯 */
+    leadingElement?: ReactNode;
+    /** 인풋 우측 슬롯 (clearable=true 이고 값이 있으면 삭제 버튼이 추가됨) */
+    trailingElement?: ReactNode;
+    ref?: Ref<HTMLInputElement>;
+}
+declare function Textbox({ className, label, helperText, error, disabled, clearable, leadingElement, trailingElement, size, id, ref, value, defaultValue, onChange, onFocus, onBlur, ...props }: TextboxProps): import("react/jsx-runtime").JSX.Element;
+export { inputContainerVariants as inputWrapperVariants, Textbox };

package/dist/components/Textbox/index.d.ts

@@ -0,0 +1,2 @@
+export type { TextboxProps } from "./Textbox";
+export { inputWrapperVariants, Textbox } from "./Textbox";