@olundot/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,976 @@
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { SVGProps } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { LucideIcon } from 'lucide-react';
+import { Select as Select$1, Tabs as Tabs$1, Dialog as Dialog$1, Separator as Separator$1, Avatar as Avatar$1, DropdownMenu as DropdownMenu$1, Tooltip as Tooltip$1, Checkbox as Checkbox$1, RadioGroup, ScrollArea as ScrollArea$1 } from 'radix-ui';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "destructive" | "outline" | "ghost" | "danger" | "emergency" | "subtle" | "default" | "link" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "default" | "icon" | "icon-xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariant = NonNullable<VariantProps<typeof buttonVariants>['variant']>;
+type ButtonSize = NonNullable<VariantProps<typeof buttonVariants>['size']>;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    leadingIcon?: LucideIcon;
+    trailingIcon?: LucideIcon;
+    loading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type CopyButtonProps = Omit<ButtonProps, 'children' | 'leadingIcon' | 'loading' | 'size' | 'trailingIcon' | 'variant'> & {
+    value: string;
+    label?: React.ReactNode;
+    copiedLabel?: React.ReactNode;
+    onCopied?: () => void;
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+    duration?: number;
+};
+declare const CopyButton: React.ForwardRefExoticComponent<Omit<ButtonProps, "variant" | "size" | "leadingIcon" | "trailingIcon" | "loading" | "children"> & {
+    value: string;
+    label?: React.ReactNode;
+    copiedLabel?: React.ReactNode;
+    onCopied?: () => void;
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+    duration?: number;
+} & React.RefAttributes<HTMLButtonElement>>;
+
+declare const inputVariants: (props?: ({
+    inputSize?: "xs" | "sm" | "md" | "lg" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const inputMessageVariants: (props?: ({
+    state?: "error" | "success" | "default" | null | undefined;
+    inputSize?: "xs" | "sm" | "md" | "lg" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputState = NonNullable<VariantProps<typeof inputMessageVariants>["state"]>;
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+    invalid?: boolean;
+    label?: React.ReactNode;
+    message?: React.ReactNode;
+    state?: InputState;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const fileUploadZoneVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const fileUploadIconVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface FileUploadZoneProps extends Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "onChange">, VariantProps<typeof fileUploadZoneVariants> {
+    accept?: string;
+    multiple?: boolean;
+    onFiles?: (files: FileList) => void;
+    label?: React.ReactNode;
+    hint?: React.ReactNode;
+    error?: React.ReactNode;
+    disabled?: boolean;
+}
+declare const FileUploadZone: React.ForwardRefExoticComponent<FileUploadZoneProps & React.RefAttributes<HTMLLabelElement>>;
+
+declare const alertVariants: (props?: ({
+    variant?: "error" | "warning" | "info" | "success" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const inlineAlertVariants: (props?: ({
+    variant?: "error" | "warning" | "info" | "success" | null | undefined;
+    surface?: "filled" | "plain" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariant = NonNullable<VariantProps<typeof alertVariants>['variant']>;
+interface AlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title' | 'children'>, VariantProps<typeof alertVariants> {
+    title?: React.ReactNode;
+    children: React.ReactNode;
+    icon?: React.ReactNode;
+    onDismiss?: () => void;
+}
+interface InlineAlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof inlineAlertVariants> {
+    children: React.ReactNode;
+    icon?: React.ReactNode;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * InlineAlert is for inline status text only. Use Alert or Toast when the UI needs dismissal.
+ *
+ * surface variants:
+ *   - `filled` (default): accent tint 배경. table toolbar / 영역 분리가 필요한 위치.
+ *   - `plain`: 배경 없음. form field 바로 아래처럼 인접 input과 영역 충돌을 피해야 하는 위치.
+ */
+declare const InlineAlert: React.ForwardRefExoticComponent<InlineAlertProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const textareaVariants: (props?: ({
+    textareaSize?: "default" | "compact" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const textareaMessageVariants: (props?: ({
+    state?: "error" | "success" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TextareaState = NonNullable<VariantProps<typeof textareaMessageVariants>["state"]>;
+type TextareaSize = NonNullable<VariantProps<typeof textareaVariants>["textareaSize"]>;
+interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "children">, VariantProps<typeof textareaVariants> {
+    invalid?: boolean;
+    label?: React.ReactNode;
+    message?: React.ReactNode;
+    state?: TextareaState;
+    valueLength?: number;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+declare const selectVariants: (props?: ({
+    selectVariant?: "inline" | "field" | null | undefined;
+    selectSize?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const selectMessageVariants: (props?: ({
+    state?: "error" | "success" | "default" | null | undefined;
+    selectSize?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SelectState = NonNullable<VariantProps<typeof selectMessageVariants>["state"]>;
+type SelectSize = NonNullable<VariantProps<typeof selectVariants>["selectSize"]>;
+interface SelectOption {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+}
+interface SelectProps extends Omit<React.ComponentPropsWithoutRef<typeof Select$1.Root>, "children" | "dir">, VariantProps<typeof selectVariants> {
+    className?: string;
+    id?: string;
+    label?: React.ReactNode;
+    message?: React.ReactNode;
+    invalid?: boolean;
+    state?: SelectState;
+    options: readonly SelectOption[];
+    placeholder?: React.ReactNode;
+    "aria-label"?: React.AriaAttributes["aria-label"];
+    "aria-describedby"?: string;
+    "aria-invalid"?: React.AriaAttributes["aria-invalid"];
+}
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const formFieldVariants: (props?: ({
+    layout?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const formFieldLabelClassName = "text-[13px] font-medium leading-[1.35] text-[var(--text-secondary)]";
+declare const formFieldRequiredClassName = "ml-[2px] text-[var(--semantic-error,var(--error))]";
+declare const formFieldDescriptionClassName = "ml-[var(--space-1-5)] text-[12px] leading-[1.4] text-[var(--text-tertiary)]";
+declare const formFieldErrorClassName = "ml-[var(--space-1-5)] text-[12px] leading-[1.4] text-[var(--semantic-error,var(--error))]";
+declare const formFieldControlStackClassName = "flex min-w-0 flex-col gap-[var(--space-0-5)]";
+interface FormFieldProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    label: React.ReactNode;
+    required?: boolean;
+    description?: React.ReactNode;
+    error?: React.ReactNode;
+    children: React.ReactNode | ((field: FormFieldRenderProps) => React.ReactNode);
+    layout?: "vertical" | "horizontal";
+    id?: string;
+}
+interface FormFieldRenderProps {
+    controlProps: {
+        id?: string;
+        "aria-describedby"?: string;
+        "aria-invalid"?: true;
+    };
+    descriptionId?: string;
+    errorId?: string;
+    invalid: boolean;
+}
+declare function FormField({ label, required, description, error, children, layout, id, className, ...props }: FormFieldProps): react_jsx_runtime.JSX.Element;
+
+type PermissionFallback = "hide" | "disabled" | React.ReactNode;
+interface PermissionScope {
+    resourceId?: string;
+    resourceType?: string;
+}
+interface PermissionState {
+    permissions?: readonly string[];
+    grants?: readonly string[];
+    denies?: readonly string[];
+    delegations?: readonly string[];
+    rolePermissions?: readonly string[];
+}
+type PermissionEvaluator = PermissionState | readonly string[] | ((permission: string, scope?: PermissionScope) => boolean);
+interface PermissionProviderProps {
+    children: React.ReactNode;
+    permissions?: PermissionEvaluator;
+    value?: PermissionEvaluator;
+}
+interface PermissionGuardProps {
+    permission: string;
+    children: React.ReactNode;
+    fallback?: PermissionFallback;
+    scope?: PermissionScope;
+    permissions?: PermissionEvaluator;
+    disabledReason?: React.ReactNode;
+}
+declare const PermissionContext: React.Context<PermissionEvaluator | undefined>;
+declare function PermissionProvider({ children, permissions, value, }: PermissionProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePermission(permission: string, scope?: PermissionScope): boolean;
+declare function evaluatePermission(permission: string, state?: PermissionEvaluator, scope?: PermissionScope): boolean;
+declare function PermissionGuard({ permission, children, fallback, scope, permissions, disabledReason, }: PermissionGuardProps): react_jsx_runtime.JSX.Element | null;
+
+declare const choiceGroupVariants: (props?: ({
+    type?: "single" | "multi" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const choiceRowVariants: (props?: ({
+    interactive?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const choiceMarkerVariants: (props?: ({
+    interactive?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const choiceBodyVariants: (props?: ({
+    disabled?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ChoiceGroupType = "single" | "multi";
+type ChoiceGroupVariant = "default" | "review-only" | "corrected-answer-display";
+interface ChoiceGroupOption {
+    value: string;
+    body: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    correct?: boolean;
+}
+type AccessibleGroupName$1 = {
+    "aria-label": string;
+    "aria-labelledby"?: never;
+} | {
+    "aria-label"?: never;
+    "aria-labelledby": string;
+};
+interface ChoiceGroupBaseProps {
+    className?: string;
+    options: readonly ChoiceGroupOption[];
+    variant?: ChoiceGroupVariant;
+    type: ChoiceGroupType;
+    name?: string;
+}
+type ChoiceGroupSingleProps = ChoiceGroupBaseProps & AccessibleGroupName$1 & {
+    type: "single";
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type ChoiceGroupMultiProps = ChoiceGroupBaseProps & AccessibleGroupName$1 & {
+    type: "multi";
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onValueChange?: (value: string[]) => void;
+};
+type ChoiceGroupProps = ChoiceGroupSingleProps | ChoiceGroupMultiProps;
+declare const ChoiceGroup: React.ForwardRefExoticComponent<ChoiceGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const cardVariants: (props?: ({
+    variant?: "default" | "interactive" | "elevated" | "notice" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CardVariant = NonNullable<VariantProps<typeof cardVariants>["variant"]>;
+interface CardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+}
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+
+interface PageHeaderProps extends Omit<React.HTMLAttributes<HTMLElement>, "title"> {
+    breadcrumb?: React.ReactNode;
+    back?: React.ReactNode;
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    meta?: React.ReactNode;
+    actions?: React.ReactNode;
+}
+declare const PageHeader: React.ForwardRefExoticComponent<PageHeaderProps & React.RefAttributes<HTMLElement>>;
+
+type WizardStepState = "upcoming" | "current" | "complete";
+interface WizardStep {
+    id: string;
+    label: string;
+    description?: string;
+    state?: WizardStepState;
+}
+interface WizardLayoutProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    header: React.ReactNode;
+    steps: WizardStep[];
+    activeStep: number;
+    onStepChange?: (step: number) => void;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    status?: React.ReactNode;
+    allowStepNavigation?: boolean;
+}
+declare const WizardLayout: React.ForwardRefExoticComponent<WizardLayoutProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const tabsListVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const tabsTriggerVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const tabsBadgeVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface TabItem {
+    key: string;
+    label: string;
+    badge?: number;
+    disabled?: boolean;
+}
+type TabsListVariantProps = VariantProps<typeof tabsListVariants>;
+interface TabsProps extends Omit<React.ComponentPropsWithoutRef<typeof Tabs$1.Root>, 'value' | 'onValueChange' | 'defaultValue' | 'onChange'>, TabsListVariantProps {
+    tabs: TabItem[];
+    activeKey: string;
+    onChange: (key: string) => void;
+    baseId?: string;
+    listClassName?: string;
+    triggerClassName?: string;
+}
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<Omit<Tabs$1.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref">, "value"> & {
+    tabKey: string;
+    baseId?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+
+interface DetailLayoutPropsBase extends Omit<React.HTMLAttributes<HTMLElement>, 'children'> {
+    header: React.ReactNode;
+    children: React.ReactNode;
+    aside?: React.ReactNode;
+    footer?: React.ReactNode;
+    bodyClassName?: string;
+    contentClassName?: string;
+    asideClassName?: string;
+    stickyAside?: boolean;
+    stickyAsideTopClassName?: string;
+}
+interface DetailLayoutPropsWithTabs {
+    tabs: TabItem[];
+    activeTab: string;
+    onTabChange: (key: string) => void;
+    baseId?: string;
+}
+interface DetailLayoutPropsWithoutTabs {
+    tabs?: undefined;
+    activeTab?: never;
+    onTabChange?: never;
+    baseId?: string;
+}
+type DetailLayoutProps = DetailLayoutPropsBase & (DetailLayoutPropsWithTabs | DetailLayoutPropsWithoutTabs);
+declare const DetailLayout: React.ForwardRefExoticComponent<DetailLayoutProps & React.RefAttributes<HTMLElement>>;
+
+interface FormLayoutSection {
+    id: string;
+    title: string;
+    description?: string;
+    aside?: React.ReactNode;
+    columns?: 1 | 2;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    children: React.ReactNode;
+}
+interface FormLayoutProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    header: React.ReactNode;
+    sections: FormLayoutSection[];
+    footer?: React.ReactNode;
+    status?: React.ReactNode;
+    editorSectionId?: string;
+    sectionClassName?: string;
+    contentClassName?: string;
+}
+declare const FormLayout: React.ForwardRefExoticComponent<FormLayoutProps & React.RefAttributes<HTMLDivElement>>;
+
+interface FormModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    children: React.ReactNode;
+    onSubmit: () => void | Promise<void>;
+    submitLabel?: string;
+    cancelLabel?: string;
+    wide?: boolean;
+    loading?: boolean;
+    status?: React.ReactNode;
+}
+declare function FormModal({ open, onOpenChange, title, description, children, onSubmit, submitLabel, cancelLabel, wide, loading, status, }: FormModalProps): react_jsx_runtime.JSX.Element;
+
+interface InfoModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    children: React.ReactNode;
+    closeLabel?: string;
+    width?: "default" | "wide";
+    footer?: React.ReactNode;
+}
+declare function InfoModal({ open, onOpenChange, title, description, children, closeLabel, width, footer, }: InfoModalProps): react_jsx_runtime.JSX.Element;
+
+interface FilterToolbarProps extends React.HTMLAttributes<HTMLDivElement> {
+    search?: React.ReactNode;
+    filters?: React.ReactNode;
+    resultSummary?: React.ReactNode;
+    clearAction?: React.ReactNode;
+    actions?: React.ReactNode;
+}
+declare const FilterToolbar: React.ForwardRefExoticComponent<FilterToolbarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const dataTableVariants: (props?: ({
+    density?: "compact" | "standard" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const dataTableRowVariants: (props?: ({
+    interactive?: boolean | null | undefined;
+    selected?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DataTableColumn<T> {
+    key: string;
+    header: React.ReactNode;
+    width?: string;
+    align?: 'left' | 'right' | 'center';
+    render?: (row: T) => React.ReactNode;
+    tabular?: boolean;
+    sortable?: boolean;
+}
+interface DataTableSort {
+    key: string;
+    dir: 'asc' | 'desc';
+}
+interface DataTableBulkAction {
+    label: React.ReactNode;
+    onClick: (ids: Set<string>) => void;
+    variant?: 'default' | 'destructive';
+}
+interface DataTableProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof dataTableVariants> {
+    columns: DataTableColumn<T>[];
+    data: T[];
+    keyField: keyof T;
+    selectable?: boolean;
+    selectedIds?: Set<string>;
+    onSelectionChange?: (ids: Set<string>) => void;
+    sortBy?: DataTableSort;
+    onSortChange?: (key: string, dir: 'asc' | 'desc' | null) => void;
+    loading?: boolean;
+    emptyState?: React.ReactNode;
+    bulkActions?: DataTableBulkAction[];
+    rowHref?: (row: T) => string;
+    skeletonRowCount?: number;
+}
+type DataTableComponent = (<T>(props: DataTableProps<T> & React.RefAttributes<HTMLDivElement>) => React.ReactElement | null) & {
+    displayName?: string;
+};
+declare const DataTable: DataTableComponent;
+
+declare const Dialog: React.FC<Dialog$1.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<Dialog$1.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<Dialog$1.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<Dialog$1.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * DialogRawContent — shadcn 기본 스타일 없는 순수 radix Content.
+ * 자체 head/body/foot 슬롯을 가진 ModalShell 등 커스텀 구현용.
+ * DialogPortal + DialogOverlay와 함께 수동으로 조합해서 사용.
+ */
+declare const DialogRawContent: React.ForwardRefExoticComponent<Dialog$1.DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    tone?: "default" | "destructive";
+    confirmLabel: string;
+    cancelLabel?: string;
+    onConfirm: () => void | Promise<void>;
+    loading?: boolean;
+}
+declare function ConfirmDialog({ open, onOpenChange, title, description, tone, confirmLabel, cancelLabel, onConfirm, loading, }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof Separator$1.Root>): react_jsx_runtime.JSX.Element;
+
+declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof Avatar$1.Root> & {
+    size?: "sm" | "md" | "lg";
+}): react_jsx_runtime.JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof Avatar$1.Image>): react_jsx_runtime.JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof Avatar$1.Fallback>): react_jsx_runtime.JSX.Element;
+
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenu$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenu$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenu$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenu$1.Content>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenu$1.Group>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenu$1.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenu$1.CheckboxItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenu$1.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenu$1.RadioItem>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenu$1.Label> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenu$1.Separator>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenu$1.Sub>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenu$1.SubTrigger> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenu$1.SubContent>): react_jsx_runtime.JSX.Element;
+
+declare function Sheet({ ...props }: React.ComponentProps<typeof Dialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function SheetTrigger({ ...props }: React.ComponentProps<typeof Dialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function SheetClose({ ...props }: React.ComponentProps<typeof Dialog$1.Close>): react_jsx_runtime.JSX.Element;
+declare function SheetContent({ className, children, side, mobileSide, showCloseButton, ...props }: React.ComponentProps<typeof Dialog$1.Content> & {
+    side?: "top" | "right" | "bottom" | "left";
+    mobileSide?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function SheetTitle({ className, ...props }: React.ComponentProps<typeof Dialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function SheetDescription({ className, ...props }: React.ComponentProps<typeof Dialog$1.Description>): react_jsx_runtime.JSX.Element;
+
+interface SheetDrawerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    children: React.ReactNode;
+    expandHref?: string;
+    onExpand?: () => void;
+    expandLabel?: string;
+    footer?: React.ReactNode;
+    width?: "default" | "wide";
+    closeLabel?: string;
+}
+declare function SheetDrawer({ open, onOpenChange, title, description, children, expandHref, onExpand, expandLabel, footer, width, closeLabel, }: SheetDrawerProps): react_jsx_runtime.JSX.Element;
+
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof Tooltip$1.Provider>): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof Tooltip$1.Root>): react_jsx_runtime.JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof Tooltip$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof Tooltip$1.Content>): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "brand" | "neutral" | "status" | "semantic" | "pill" | null | undefined;
+    tone?: "accent" | "warning" | "info" | "success" | "neutral" | "danger" | null | undefined;
+    size?: "xs" | "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const badgeDotVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+type BadgeVariant = NonNullable<VariantProps<typeof badgeVariants>['variant']>;
+type BadgeTone = NonNullable<VariantProps<typeof badgeVariants>['tone']>;
+type BadgeSize = NonNullable<VariantProps<typeof badgeVariants>['size']>;
+interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color'>, VariantProps<typeof badgeVariants> {
+    showDot?: boolean;
+    disabled?: boolean;
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const twoTierBadgeVariants: (props?: ({
+    align?: "end" | "center" | "start" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const twoTierBadgeLineVariants: (props?: ({
+    tier?: "primary" | "secondary" | null | undefined;
+    intent?: "muted" | "accent" | "warning" | "success" | "neutral" | "danger" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TwoTierBadgeIntent = NonNullable<VariantProps<typeof twoTierBadgeLineVariants>["intent"]>;
+interface TwoTierBadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof twoTierBadgeVariants> {
+    primary: React.ReactNode;
+    secondary?: React.ReactNode;
+    primaryIntent?: TwoTierBadgeIntent;
+    secondaryIntent?: TwoTierBadgeIntent;
+    primaryClassName?: string;
+    secondaryClassName?: string;
+}
+declare const TwoTierBadge: React.ForwardRefExoticComponent<TwoTierBadgeProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const statusBadgeVariants: (props?: ({
+    status?: "error" | "warning" | "info" | "success" | "active" | "pending" | "archived" | null | undefined;
+    size?: "xs" | "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const statusBadgeDotVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+type StatusBadgeStatus = NonNullable<VariantProps<typeof statusBadgeVariants>["status"]>;
+interface StatusBadgeProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof statusBadgeVariants> {
+    showDot?: boolean;
+}
+declare const StatusBadge: React.ForwardRefExoticComponent<StatusBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const notificationBadgeVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+    placement?: "none" | "inline" | "corner" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type NotificationBadgeSize = NonNullable<VariantProps<typeof notificationBadgeVariants>['size']>;
+type NotificationBadgePlacement = NonNullable<VariantProps<typeof notificationBadgeVariants>['placement']>;
+interface NotificationBadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children' | 'color'>, VariantProps<typeof notificationBadgeVariants> {
+    count: number;
+    max?: number;
+}
+declare const NotificationBadge: React.ForwardRefExoticComponent<NotificationBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const chipVariants: (props?: ({
+    variant?: "filter" | "choice" | "status-filter" | "removable" | null | undefined;
+    tone?: "muted" | "accent" | "warning" | "success" | "neutral" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    pressed?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const chipCountVariants: (props?: ({
+    tone?: "muted" | "accent" | "warning" | "success" | "neutral" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ChipVariant = NonNullable<VariantProps<typeof chipVariants>["variant"]>;
+type ChipTone = NonNullable<VariantProps<typeof chipVariants>["tone"]>;
+type ChipSize = NonNullable<VariantProps<typeof chipVariants>["size"]>;
+interface ChipProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "color">, Omit<VariantProps<typeof chipVariants>, "pressed"> {
+    asChild?: boolean;
+    pressed?: boolean;
+    count?: React.ReactNode;
+    removeLabel?: string;
+}
+declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const emptyStateVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    tone?: "raised" | "muted" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const emptyStateIconVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type EmptyStateSize = NonNullable<VariantProps<typeof emptyStateVariants>["size"]>;
+type EmptyStateTone = NonNullable<VariantProps<typeof emptyStateVariants>["tone"]>;
+interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof emptyStateVariants> {
+    icon?: LucideIcon;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    hint?: React.ReactNode;
+    action?: React.ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const errorStateVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ErrorStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof errorStateVariants> {
+    title?: React.ReactNode;
+    message?: React.ReactNode;
+    errorCode?: string;
+    onRetry?: () => void;
+    retryLabel?: React.ReactNode;
+}
+declare const ErrorState: React.ForwardRefExoticComponent<ErrorStateProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const skeletonVariants: (props?: ({
+    shape?: "text" | "block" | "circle" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const spinnerVariants: (props?: ({
+    size?: 16 | 24 | 32 | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof skeletonVariants> {
+}
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonTextProps extends React.HTMLAttributes<HTMLDivElement> {
+    lines?: number;
+    widths?: Array<string | number>;
+}
+declare const SkeletonText: React.ForwardRefExoticComponent<SkeletonTextProps & React.RefAttributes<HTMLDivElement>>;
+interface SkeletonRowColumn {
+    width?: string;
+    align?: 'left' | 'right' | 'center';
+}
+interface SkeletonRowProps extends React.HTMLAttributes<HTMLDivElement> {
+    columns: SkeletonRowColumn[];
+    count?: number;
+}
+declare const SkeletonRow: React.ForwardRefExoticComponent<SkeletonRowProps & React.RefAttributes<HTMLDivElement>>;
+interface SpinnerProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof spinnerVariants> {
+    label?: string;
+}
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const iconButtonVariants: (props?: ({
+    variant?: "outline" | "ghost" | "danger" | "subtle" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    pressed?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const iconButtonBadgeVariants: (props?: ({
+    tone?: "error" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type IconButtonVariant = NonNullable<VariantProps<typeof iconButtonVariants>["variant"]>;
+type IconButtonSize = NonNullable<VariantProps<typeof iconButtonVariants>["size"]>;
+type IconButtonBadgeTone = NonNullable<VariantProps<typeof iconButtonBadgeVariants>["tone"]>;
+type IconButtonIcon = React.ComponentType<React.SVGProps<SVGSVGElement> & {
+    size?: number | string;
+    strokeWidth?: number | string;
+}>;
+type IconButtonAccessibleName = {
+    "aria-label": string;
+    "aria-labelledby"?: string;
+} | {
+    "aria-label"?: string;
+    "aria-labelledby": string;
+};
+type IconButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "aria-label" | "aria-labelledby" | "children" | "color"> & Omit<VariantProps<typeof iconButtonVariants>, "pressed"> & IconButtonAccessibleName & {
+    icon: IconButtonIcon;
+    pressed?: boolean;
+    badge?: React.ReactNode;
+    badgeTone?: IconButtonBadgeTone;
+};
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const paginationVariants: (props?: ({
+    size?: "compact" | "standard" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const paginationControlVariants: (props?: ({
+    size?: "compact" | "standard" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type PaginationSize = NonNullable<VariantProps<typeof paginationVariants>['size']>;
+interface PaginationProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'>, VariantProps<typeof paginationVariants> {
+    total: number;
+    page: number;
+    pageSize: number;
+    pageSizeOptions?: readonly number[];
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    totalLabel?: (total: number) => React.ReactNode;
+    pageSizeLabel?: string;
+}
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+
+declare const modeToggleVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const modeToggleItemVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface ModeToggleOption<T extends string> {
+    value: T;
+    label: string;
+    icon?: LucideIcon;
+    disabled?: boolean;
+}
+interface ModeToggleProps<T extends string> extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    options: Array<ModeToggleOption<T>>;
+    value: T;
+    onChange: (value: T) => void;
+    itemClassName?: string;
+}
+declare function ModeToggle<T extends string>({ className, itemClassName, options, value, onChange, ...props }: ModeToggleProps<T>): react_jsx_runtime.JSX.Element;
+
+declare const actionFooterVariants: (props?: ({
+    position?: "fixed" | "static" | "sticky" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const actionFooterStatusVariants: (props?: ({
+    kind?: "error" | "saving" | "saved" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ActionFooterStatus {
+    kind: 'saving' | 'saved' | 'error';
+    lastSavedAt?: Date;
+}
+interface ActionFooterAction {
+    id?: string;
+    label: string;
+    variant?: ButtonVariant;
+    onClick: () => void;
+    disabled?: boolean;
+    loading?: boolean;
+    permission?: string;
+    leadingIcon?: LucideIcon;
+}
+interface ActionFooterProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof actionFooterVariants> {
+    status?: ActionFooterStatus;
+    actions: ActionFooterAction[];
+    permissions?: readonly string[] | ((permission: string) => boolean);
+}
+declare const ActionFooter: React.ForwardRefExoticComponent<ActionFooterProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const toastVariants: (props?: ({
+    variant?: "error" | "warning" | "info" | "success" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const toastViewportVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+type ToastVariant = NonNullable<VariantProps<typeof toastVariants>['variant']>;
+interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+interface ToastOptions {
+    message: string;
+    variant?: ToastVariant;
+    duration?: number;
+    action?: ToastAction;
+}
+interface ToastItem extends ToastOptions {
+    id: string;
+}
+interface ToastRootProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'id'>, ToastItem {
+    onClose?: () => void;
+}
+type ToastListener = (items: ToastItem[]) => void;
+declare function limitToasts(items: ToastItem[], max?: number): ToastItem[];
+declare function getToastDuration(options: ToastOptions): number;
+declare function createToast(options: ToastOptions): string;
+declare const toast: {
+    show: typeof createToast;
+    success(message: string, options?: Omit<ToastOptions, "message" | "variant">): string;
+    error(message: string, options?: Omit<ToastOptions, "message" | "variant">): string;
+    warning(message: string, options?: Omit<ToastOptions, "message" | "variant">): string;
+    info(message: string, options?: Omit<ToastOptions, "message" | "variant">): string;
+    dismiss(id: string): void;
+    subscribe(listener: ToastListener): () => void;
+};
+declare const ToastRoot: React.ForwardRefExoticComponent<ToastRootProps & React.RefAttributes<HTMLDivElement>>;
+declare const ToastViewport: React.ForwardRefExoticComponent<React.OlHTMLAttributes<HTMLOListElement> & React.RefAttributes<HTMLOListElement>>;
+interface ToastProviderProps extends React.HTMLAttributes<HTMLDivElement> {
+    maxToasts?: number;
+}
+declare function ToastProvider({ children, maxToasts, className, ...props }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+
+declare const otpFieldVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const otpFieldGroupVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const otpCellVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const otpFieldMessageVariants: (props?: ({
+    state?: "error" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type OTPFieldSize = NonNullable<VariantProps<typeof otpCellVariants>["size"]>;
+interface OTPFieldProps extends Omit<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, "onChange" | "children" | "defaultValue" | "value">, VariantProps<typeof otpFieldVariants> {
+    defaultValue?: string;
+    errorText?: React.ReactNode;
+    helperText?: React.ReactNode;
+    invalid?: boolean;
+    label: React.ReactNode;
+    length?: number;
+    name?: string;
+    onComplete?: (value: string) => void;
+    onValueChange?: (value: string) => void;
+    readOnly?: boolean;
+    size?: OTPFieldSize;
+    value?: string;
+    required?: boolean;
+}
+declare const OTPField: React.ForwardRefExoticComponent<OTPFieldProps & React.RefAttributes<HTMLFieldSetElement>>;
+
+declare const searchFieldVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const searchFieldInputVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    hasClear?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SearchFieldSize = NonNullable<VariantProps<typeof searchFieldVariants>["size"]>;
+interface SearchFieldProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type">, VariantProps<typeof searchFieldVariants> {
+    clearable?: boolean;
+    clearLabel?: string;
+    onClear?: () => void;
+}
+declare const SearchField: React.ForwardRefExoticComponent<SearchFieldProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const checkboxVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const checkboxBoxVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CheckboxSize = NonNullable<VariantProps<typeof checkboxVariants>["size"]>;
+type CheckboxCheckedState = React.ComponentProps<typeof Checkbox$1.Root>["checked"];
+interface CheckboxProps extends Omit<React.ComponentPropsWithoutRef<typeof Checkbox$1.Root>, "children" | "color">, VariantProps<typeof checkboxVariants> {
+    label: React.ReactNode;
+    description?: React.ReactNode;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const radioCardGroupVariants: (props?: ({
+    columns?: "one" | "two" | "three" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const radioCardItemVariants: (props?: ({
+    density?: "compact" | "comfortable" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const radioCardControlVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+type RadioCardColumns = NonNullable<VariantProps<typeof radioCardGroupVariants>["columns"]>;
+type RadioCardDensity = NonNullable<VariantProps<typeof radioCardItemVariants>["density"]>;
+interface RadioCardOption {
+    value: string;
+    title: React.ReactNode;
+    description: React.ReactNode;
+    disabled?: boolean;
+}
+type AccessibleGroupName = {
+    "aria-label": string;
+    "aria-labelledby"?: never;
+} | {
+    "aria-label"?: never;
+    "aria-labelledby": string;
+};
+type RadioCardGroupRootProps = Omit<React.ComponentPropsWithoutRef<typeof RadioGroup.Root>, "children" | "orientation" | "aria-label" | "aria-labelledby">;
+type RadioCardGroupProps = RadioCardGroupRootProps & AccessibleGroupName & VariantProps<typeof radioCardGroupVariants> & {
+    options: readonly RadioCardOption[];
+    density?: RadioCardDensity;
+};
+declare const RadioCardGroup: React.ForwardRefExoticComponent<RadioCardGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollArea$1.Root>): react_jsx_runtime.JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React.ComponentProps<typeof ScrollArea$1.ScrollAreaScrollbar>): react_jsx_runtime.JSX.Element;
+
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** 0~100 진행률 */
+    value: number;
+    /** 너비 px 또는 CSS 값 (기본 120px) */
+    width?: string | number;
+    /** 높이 px (기본 4) */
+    height?: number;
+}
+declare function Progress({ value, width, height, className, style, ...props }: ProgressProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * OLUN 브랜드 로고.
+ *
+ * - symbol: O 원형 테두리 + 우하단 accent-solid 작은 circle
+ * - wordmark: "OLUN" + 마지막 "." 은 accent-fg 색상
+ *
+ * 레퍼런스: apps/web/docs/wireframes/ref/shell-wireframe.html Topbar 브랜드 영역.
+ */
+interface OlunSymbolProps {
+    /** 심볼 크기 px (기본 28) */
+    size?: number;
+    className?: string;
+}
+declare function OlunSymbol({ size, className }: OlunSymbolProps): react_jsx_runtime.JSX.Element;
+interface OlunLogoProps {
+    /** 심볼 크기 px (기본 28) */
+    symbolSize?: number;
+    /** wordmark font-size px (기본 18) */
+    fontSize?: number;
+    /** 심볼 표시 여부 (기본 true) */
+    showSymbol?: boolean;
+    className?: string;
+}
+declare function OlunLogo({ symbolSize, fontSize, showSymbol, className, }: OlunLogoProps): react_jsx_runtime.JSX.Element;
+
+declare function ThemeToggle({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+type ThemeFabVariant = "square" | "circle";
+interface ThemeFabProps {
+    /**
+     * 모양/크기 variant.
+     *  - `square` (default): 36×36 rounded-sm (exam 와이어프레임 기존 사양).
+     *  - `circle`: 56×56 rounded-full + accent border + backdrop blur (web 표준).
+     */
+    variant?: ThemeFabVariant;
+}
+declare function ThemeFab({ variant }?: ThemeFabProps): react_jsx_runtime.JSX.Element | null;
+
+interface JbnuEmblemProps extends SVGProps<SVGSVGElement> {
+    /** 너비·높이 px (기본 32). `className`으로 오버라이드 가능. */
+    size?: number;
+}
+declare function JbnuEmblem({ size, className, style, ...props }: JbnuEmblemProps): react_jsx_runtime.JSX.Element;
+
+export { ActionFooter, type ActionFooterAction, type ActionFooterProps, type ActionFooterStatus, Alert, type AlertProps, type AlertVariant, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, type BadgeSize, type BadgeTone, type BadgeVariant, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardContent, CardDescription, CardFooter, CardHeader, type CardProps, CardTitle, type CardVariant, Checkbox, type CheckboxCheckedState, type CheckboxProps, type CheckboxSize, Chip, type ChipProps, type ChipSize, type ChipTone, type ChipVariant, ChoiceGroup, type ChoiceGroupOption, type ChoiceGroupProps, type ChoiceGroupType, type ChoiceGroupVariant, ConfirmDialog, type ConfirmDialogProps, CopyButton, type CopyButtonProps, DataTable, type DataTableBulkAction, type DataTableColumn, type DataTableProps, type DataTableSort, DetailLayout, type DetailLayoutProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogRawContent, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, type EmptyStateSize, type EmptyStateTone, ErrorState, type ErrorStateProps, FileUploadZone, type FileUploadZoneProps, FilterToolbar, type FilterToolbarProps, FormField, type FormFieldProps, type FormFieldRenderProps, FormLayout, type FormLayoutProps, type FormLayoutSection, FormModal, type FormModalProps, IconButton, type IconButtonBadgeTone, type IconButtonProps, type IconButtonSize, type IconButtonVariant, InfoModal, type InfoModalProps, InlineAlert, type InlineAlertProps, Input, type InputProps, type InputState, JbnuEmblem, type JbnuEmblemProps, ModeToggle, type ModeToggleOption, type ModeToggleProps, NotificationBadge, type NotificationBadgePlacement, type NotificationBadgeProps, type NotificationBadgeSize, OTPField, type OTPFieldProps, type OTPFieldSize, OlunLogo, OlunSymbol, PageHeader, type PageHeaderProps, Pagination, type PaginationProps, type PaginationSize, PermissionContext, type PermissionEvaluator, type PermissionFallback, PermissionGuard, type PermissionGuardProps, PermissionProvider, type PermissionProviderProps, type PermissionScope, type PermissionState, Progress, type RadioCardColumns, type RadioCardDensity, RadioCardGroup, type RadioCardGroupProps, type RadioCardOption, ScrollArea, ScrollBar, SearchField, type SearchFieldProps, type SearchFieldSize, Select, type SelectOption, type SelectProps, type SelectSize, type SelectState, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetDrawer, type SheetDrawerProps, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Skeleton, type SkeletonProps, SkeletonRow, type SkeletonRowColumn, type SkeletonRowProps, SkeletonText, type SkeletonTextProps, Spinner, type SpinnerProps, StatusBadge, type StatusBadgeProps, type StatusBadgeStatus, type TabItem, Tabs, TabsContent, type TabsProps, Textarea, type TextareaProps, type TextareaSize, type TextareaState, ThemeFab, type ThemeFabProps, ThemeToggle, type ToastAction, type ToastItem, type ToastOptions, ToastProvider, ToastRoot, type ToastVariant, ToastViewport, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, TwoTierBadge, type TwoTierBadgeIntent, type TwoTierBadgeProps, WizardLayout, type WizardLayoutProps, type WizardStep, type WizardStepState, actionFooterStatusVariants, actionFooterVariants, alertVariants, badgeDotVariants, badgeVariants, buttonVariants, cardVariants, checkboxBoxVariants, checkboxVariants, chipCountVariants, chipVariants, choiceBodyVariants, choiceGroupVariants, choiceMarkerVariants, choiceRowVariants, cn, dataTableRowVariants, dataTableVariants, emptyStateIconVariants, emptyStateVariants, errorStateVariants, evaluatePermission, fileUploadIconVariants, fileUploadZoneVariants, formFieldControlStackClassName, formFieldDescriptionClassName, formFieldErrorClassName, formFieldLabelClassName, formFieldRequiredClassName, formFieldVariants, getToastDuration, iconButtonBadgeVariants, iconButtonVariants, inlineAlertVariants, inputMessageVariants, inputVariants, limitToasts, modeToggleItemVariants, modeToggleVariants, notificationBadgeVariants, otpCellVariants, otpFieldGroupVariants, otpFieldMessageVariants, otpFieldVariants, paginationControlVariants, paginationVariants, radioCardControlVariants, radioCardGroupVariants, radioCardItemVariants, searchFieldInputVariants, searchFieldVariants, selectMessageVariants, selectVariants, skeletonVariants, spinnerVariants, statusBadgeDotVariants, statusBadgeVariants, tabsBadgeVariants, tabsListVariants, tabsTriggerVariants, textareaMessageVariants, textareaVariants, toast, toastVariants, toastViewportVariants, twoTierBadgeLineVariants, twoTierBadgeVariants, usePermission };