@rainbow-robotics/plugin-ui 0.1.2-dev.9 → 1.0.1

package/dist/react.d.ts

@@ -1,47 +1,3447 @@
-import type { ComponentType, ReactNode, Ref } from "react";
-import { RbSliderElement, RbButtonElement, RbIconButtonElement, RbTextElement, RbTextInputElement, RbSwitchElement, RbSelectElement, type RbButtonProps, type RbIconButtonProps, type RbSelectProps, type RbSliderProps, type RbSwitchProps, type RbTextInputProps, type RbTextProps } from "./elements";
-type NoEventProps = Record<never, never>;
-type RemoteElementComponentProps<Element, Props, EventProps = NoEventProps> = Props & EventProps & {
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as React$1 from 'react';
+import React__default, { ReactNode, MouseEvent, InputHTMLAttributes, MouseEventHandler, ReactElement, ChangeEvent, CSSProperties, TextareaHTMLAttributes, ComponentProps, Dispatch, SetStateAction, HTMLInputAutoCompleteAttribute, RefObject } from 'react';
+import { Matcher, DayPicker } from 'react-day-picker';
+import * as ShadDialogPrimitive from '@radix-ui/react-dialog';
+import { Command } from 'cmdk';
+import { Drawer } from 'vaul';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as _radix_ui_react_context from '@radix-ui/react-context';
+import * as ShadMenubarPrimitive from '@radix-ui/react-menubar';
+import * as ShadSliderPrimitive from '@radix-ui/react-slider';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as ResizablePrimitive from 'react-resizable-panels';
+
+declare const batteryStatuses: readonly ["empty", "critical", "low", "normal", "full"];
+type BatteryStatus = (typeof batteryStatuses)[number];
+declare const batterySizes: readonly ["xs", "sm", "md", "lg"];
+type BatterySize = (typeof batterySizes)[number];
+declare const batteryFillVariants: (props?: class_variance_authority_types.ClassProp) => string;
+type BatteryVariantProps = VariantProps<typeof batteryFillVariants>;
+
+type BatteryProps = Omit<React.ComponentPropsWithoutRef<"div">, "role"> & {
+    className?: string;
+    wrapperClassName?: string;
+    size?: BatterySize;
+    status?: BatteryStatus;
+    /** percent가 전달되면 status보다 우선하여 배터리 상태를 결정 */
+    percent?: number;
+    charging?: boolean;
+    /** 배터리 아이콘 자체 보더 컬러 */
+    borderColor?: React.CSSProperties["borderColor"];
+    showPercentLabel?: boolean;
+    percentLabelClassName?: string;
+};
+/** 배터리 상태와 충전 여부를 아이콘으로 표시하는 컴포넌트 */
+declare function RBBattery({ className, wrapperClassName, status, size, percent, charging, borderColor, showPercentLabel, percentLabelClassName, style, ...props }: BatteryProps): react_jsx_runtime.JSX.Element;
+
+interface RippleOption {
+    /**
+     * ripple 색상
+     *
+     * color로 전달된 색상값은 opacity가 0.3이 자동 적용됨
+     */
+    color?: string;
+    /**
+     * ripple이 작동하는 시간 (ms)
+     */
+    duration?: number;
+    /**
+     * ripple이 확장하는 max-width
+     */
+    maxSize?: number;
+    /**
+     * ripple 비활성화 여부
+     */
+    disabled?: boolean;
+}
+
+declare const labelButtonSizes: readonly ["3xs", "2xs", "xs", "xs2", "sm", "md"];
+type LabelButtonSizeType = (typeof labelButtonSizes)[number];
+declare const labelButtonVariants: (props?: {
+    size?: "3xs" | "2xs" | "xs" | "xs2" | "sm" | "md";
+    variant?: "transparent" | "outlined" | "soft" | "solid" | "inverse" | "inverseSoft" | "brand" | "brandSoft" | "danger" | "dangerSoft" | "success" | "successSoft";
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type LabelButtonVariantProps = VariantProps<typeof labelButtonVariants>;
+
+type LabelButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "color"> & LabelButtonVariantProps & {
+    className?: string;
+    size?: LabelButtonSizeType;
+    /** button 태그의 type */
+    type?: "button" | "submit";
+    /** button 요소 안에 랜더링될 내용 */
+    children: ReactNode | string;
+    /** 라벨 앞에 표시할 아이콘 */
+    leadingIcon?: React.ReactNode;
+    /** 라벨 뒤에 표시할 아이콘 */
+    trailingIcon?: React.ReactNode;
+    /**
+     * ripple 효과 option
+     *
+     * { color?: string; duration?: number; maxSize?: number; disabled?: boolean }
+     */
+    ripple?: RippleOption;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** 더블 클릭 방지 여부 */
+    detectDoubleClick?: boolean;
+    /**
+     * button을 loading 처리할지 여부
+     *
+     * `true`면 `Spinner` 컴포넌트 노출
+     */
+    loading?: boolean;
+    /** button 태그를 클릭했을때 호출되는 함수 */
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+};
+/** 텍스트 라벨과 아이콘 조합을 지원하는 버튼 컴포넌트 */
+declare const RBLabelButton: React$1.ForwardRefExoticComponent<Omit<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color"> & LabelButtonVariantProps & {
+    className?: string;
+    size?: LabelButtonSizeType;
+    /** button 태그의 type */
+    type?: "button" | "submit";
+    /** button 요소 안에 랜더링될 내용 */
+    children: ReactNode | string;
+    /** 라벨 앞에 표시할 아이콘 */
+    leadingIcon?: React.ReactNode;
+    /** 라벨 뒤에 표시할 아이콘 */
+    trailingIcon?: React.ReactNode;
+    /**
+     * ripple 효과 option
+     *
+     * { color?: string; duration?: number; maxSize?: number; disabled?: boolean }
+     */
+    ripple?: RippleOption;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** 더블 클릭 방지 여부 */
+    detectDoubleClick?: boolean;
+    /**
+     * button을 loading 처리할지 여부
+     *
+     * `true`면 `Spinner` 컴포넌트 노출
+     */
+    loading?: boolean;
+    /** button 태그를 클릭했을때 호출되는 함수 */
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const iconButtonSizes: readonly ["3xs", "2xs", "xs", "xs2", "sm", "md"];
+type IconButtonSizeType = (typeof iconButtonSizes)[number];
+declare const iconButtonVariants: (props?: {
+    size?: "3xs" | "2xs" | "xs" | "xs2" | "sm" | "md";
+    variant?: "circle" | "transparent" | "outlined" | "soft" | "solid" | "inverse" | "inverseSoft" | "brand";
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type IconButtonVariantProps = VariantProps<typeof iconButtonVariants>;
+
+type IconButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "color"> & IconButtonVariantProps & {
+    className?: string;
+    size?: IconButtonSizeType;
+    /** button 태그의 type */
+    type?: "button" | "submit";
+    icon?: React.ReactNode;
+    /**
+     * ripple 효과 option
+     *
+     * { color?: string; duration?: number; maxSize?: number; disabled?: boolean }
+     */
+    ripple?: RippleOption;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** 더블 클릭 방지 여부 */
+    detectDoubleClick?: boolean;
+    /**
+     * button을 loading 처리할지 여부
+     *
+     * `true`면 `Spinner` 컴포넌트 노출
+     */
+    loading?: boolean;
+    /** button 태그를 클릭했을때 호출되는 함수 */
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+};
+/**
+ * Button 컴포넌트는 다양한 버튼 관련 기능을 제공합니다. <br/>
+ */
+declare const RBIconButton: React$1.ForwardRefExoticComponent<Omit<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "color"> & IconButtonVariantProps & {
+    className?: string;
+    size?: IconButtonSizeType;
+    /** button 태그의 type */
+    type?: "button" | "submit";
+    icon?: React.ReactNode;
+    /**
+     * ripple 효과 option
+     *
+     * { color?: string; duration?: number; maxSize?: number; disabled?: boolean }
+     */
+    ripple?: RippleOption;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** 더블 클릭 방지 여부 */
+    detectDoubleClick?: boolean;
+    /**
+     * button을 loading 처리할지 여부
+     *
+     * `true`면 `Spinner` 컴포넌트 노출
+     */
+    loading?: boolean;
+    /** button 태그를 클릭했을때 호출되는 함수 */
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const checkBoxSizes: readonly ["xs", "xs2", "sm", "md"];
+type CheckBoxSize = (typeof checkBoxSizes)[number];
+declare const checkBoxRootVariants: (props?: {
+    size?: "xs" | "xs2" | "sm" | "md";
+    disabled?: boolean;
+    readOnly?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type CheckBoxVariantProps = VariantProps<typeof checkBoxRootVariants>;
+
+interface Props$h extends Pick<InputHTMLAttributes<HTMLInputElement>, "onChange" | "onBlur" | "onFocus"> {
+    className?: string;
+    name?: string;
+    /** 체크박스 UI의 크기  */
+    size?: CheckBoxSize;
+    /** 체크박스 UI 옆에 나올 텍스트 및 React 엘리먼트 */
+    children?: ReactNode | string;
+    /** input 태그가 갖는 value 값 */
+    checkValue?: string | number | boolean | (string | number)[];
+    /** 체크박스가 해제될 때 전달될 값
+     *
+     * (없다면 undefined로 전달이며 value 값이 배열이라면 무시)
+     */
+    unCheckValue?: string | number | boolean;
+    /** 바인딩할 데이터 값
+     *
+     * (동일한 name값을 갖는 CheckBox가 여러개 있다면 무조건 `(string | number)[]`로 받아야함)
+     */
+    value?: string | number | boolean | (string | number)[];
+    /** 체크박스가 비활성화 상태인지 여부 */
+    disabled?: boolean;
+    /** 체크박스가 읽기 전용 상태인지 여부 */
+    readOnly?: boolean;
+    /** 체크박스 전체 클릭 핸들러 */
+    onClick?: MouseEventHandler<HTMLLabelElement>;
+    /** 값이 변경될 때 호출될 함수
+     *
+     * (체크 상태에 따라 다른 값을 전달) */
+    handleChange?: (value: AllowAny, name: string) => void;
+}
+/**
+ * `CheckBox` 컴포넌트는 사용자로부터 체크박스 형태의 입력을 받기 위한 UI 컴포넌트입니다.
+ * 이 컴포넌트는 다양한 props를 통해 커스터마이징할 수 있으며, 단일 체크박스 또는 체크박스 그룹으로 사용될 수 있습니다. <br/>
+ * 파란색 점선 영역은 Interaction 범위입니다.
+ */
+declare const CheckBox: React$1.ForwardRefExoticComponent<Props$h & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const RBCheckLabelButton: React$1.ForwardRefExoticComponent<Props$h & {
+    rippleOption?: RippleOption;
+    icon?: ReactNode;
+} & React$1.RefAttributes<HTMLInputElement>>;
+
+type Props$g = Props$h & {
+    rippleOption?: RippleOption;
+    icon?: ReactNode;
+};
+declare const RBCheckIconButton: React$1.ForwardRefExoticComponent<Props$h & {
+    rippleOption?: RippleOption;
+    icon?: ReactNode;
+} & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const inlinelabelButtonSizes: readonly ["xs", "sm", "md"];
+type InlineLabelButtonSizeType = (typeof inlinelabelButtonSizes)[number];
+declare const inlineLabelButtonVariants: (props?: {
+    size?: "xs" | "sm" | "md";
+    variant?: "brand" | "default";
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type InlineLabelButtonVariantProps = VariantProps<typeof inlineLabelButtonVariants>;
+
+type InlineLabelButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "color"> & InlineLabelButtonVariantProps & {
+    className?: string;
+    size?: InlineLabelButtonSizeType;
+    /** button 태그의 type */
+    type?: "button" | "submit";
+    /** button 요소 안에 랜더링될 내용 */
+    children: ReactNode | string;
+    /** 라벨 앞에 표시할 아이콘 */
+    leadingIcon?: React.ReactNode;
+    /** 라벨 뒤에 표시할 아이콘 */
+    trailingIcon?: React.ReactNode;
+    /**
+     * ripple 효과 option
+     *
+     * { color?: string; duration?: number; maxSize?: number; disabled?: boolean }
+     */
+    ripple?: RippleOption;
+    /** 더블 클릭 방지 여부 */
+    detectDoubleClick?: boolean;
+    /** button 태그를 클릭했을때 호출되는 함수 */
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+};
+/** 텍스트 라벨과 아이콘 조합을 지원하는 버튼 컴포넌트 */
+declare function RBInlineLabelButton({ className, size, variant, type, leadingIcon, trailingIcon, ripple, detectDoubleClick, children, disabled, onClick, ...props }: InlineLabelButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const accordionTypes: readonly ["fill", "transparent"];
+type AccordionType = (typeof accordionTypes)[number];
+declare const accordionVariants: (props?: {
+    type?: "transparent" | "fill";
+} & class_variance_authority_types.ClassProp) => string;
+type AccordionVariantProps = VariantProps<typeof accordionVariants>;
+
+interface PropsType$r {
+    className?: string;
+    headerClassName?: string;
+    /**
+     * 다른 accordion이 열릴때 이외의 accordion이 닫히게 하고 싶을 경우 사용 가능
+     * 같은 값의 name을 제공하여 같은 종류의 아코디언임을 나타내어 toggle ui를 제공
+     */
+    name?: string;
+    /**
+     * accordion의 title
+     */
+    title: string | ReactElement;
+    /**
+     * accordion의 우측에 나오는 arrow icon
+     *
+     * ex) `icon={<MyChevronIcon />}`
+     */
+    icon?: string | ReactElement;
+    /**
+     * accordion의 Divider 색상
+     */
+    dividerColor?: string;
+    /**
+     * Accordion 내부 컨텐츠 영역에 랜더링될 내용
+     */
+    children: ReactNode;
+    /**
+     * ripple 옵션
+     *
+     * `{ color?: string; duration?: number; maxSize?: number; disabled?: boolean; }`
+     *
+     * `default: { disabled: true }`
+     */
+    ripple?: RippleOption;
+    /**
+     * accordion ui의 열리거나 닫힌 상태에 대한 상태값
+     *
+     * true: 열림, false: 닫힘
+     */
+    open?: boolean;
+    /**
+     * accordion의 ui가 처음 열림/닫힘에 대한 상태값
+     * 처음 상태만 지정하고 그 다음은 open 값으로 컨트롤이 가능하다
+     */
+    initialOpen?: boolean;
+    /** accordion이 비활성화 상태인지 여부 */
+    disabled?: boolean;
+    /** visual type */
+    type?: AccordionType;
+    /** accordion의 열림/닫힘 상태 값이 변경될 때 호출될 함수
+     *
+     * @param {boolean} status 변경된 열림/닫힘 상태
+     * @param {ChangeEvent<HTMLInputElement>} e accordion 상태가 변경될때 발생하는 ChangeEvent
+     */
+    handleOpenChange?: (status: boolean, e: ChangeEvent<HTMLInputElement>) => void;
+}
+/**
+ * Accordion 컴포넌트는 접고 펼칠 수 있는 UI를 제공합니다.
+ */
+declare const Accordion: ({ className, headerClassName, name, title, ripple, icon, dividerColor, open, initialOpen, children, disabled, type, handleOpenChange, }: PropsType$r) => react_jsx_runtime.JSX.Element;
+
+type Props$f = {
+    className?: string;
+    /** accordion 리스트 정보를 담은 배열 */
+    list: Omit<PropsType$r & {
+        key?: string | number;
+    }, "handleOpenChange">[];
+    icon?: string | ReactElement;
+    /** 공통 ripple 효과 옵션 */
+    ripple?: RippleOption;
+    /** 하나의 아코디언이 열렸을때 다른 아코디언이 닫히는 토글 모드 여부 */
+    isToggle?: boolean;
+    /**
+     * accordion을 눌렀을때 호출되는 함수이며 accordion의 열림 상태, accordion의 key값, ChangeEvent를 인자로 전달한다.
+     *
+     * @param {boolean} [params.status] -  accordion의 열림 상태
+     * @param {string | number} [params.key] -  accordion의 key값
+     * @param {ChangeEvent<HTMLInputElement>} [params.e] -  accordion의 ChangeEvent
+     */
+    handleClickAccordion?: (params: {
+        status: boolean;
+        key: string | number;
+        e: ChangeEvent<HTMLInputElement>;
+    }) => void;
+    initialOpen?: boolean;
+};
+/**
+ * `AccordionGroup` 컴포넌트는 여러개의 Accordion을 하나로 묶어놓은 형태의 UI를 제공합니다.
+ */
+declare const AccordionGroup: ({ className, list, ripple, icon, isToggle, initialOpen, handleClickAccordion, }: Props$f) => react_jsx_runtime.JSX.Element;
+
+declare const dividerThicknesses: readonly ["thin", "thick"];
+type DividerThickness = (typeof dividerThicknesses)[number];
+declare const dividerVariants: (props?: {
+    orientation?: "horizontal" | "vertical";
+    thickness?: "thin" | "thick";
+} & class_variance_authority_types.ClassProp) => string;
+type DividerVariantProps = VariantProps<typeof dividerVariants>;
+
+type Orientation = "horizontal" | "vertical";
+type LineVariant = "dashed" | "dotted" | "solid" | "soft";
+type SpaceDirection = "top" | "bottom" | "left" | "right" | "both";
+type BaseProps = {
+    /** 컴포넌트 클래스명 */
+    className?: string;
+    /** 타입 */
+    type?: Orientation;
+    /** 구분선 스타일 */
+    variant?: LineVariant;
+    /** 구분선 색상 */
+    color?: CSSProperties["backgroundColor"];
+    /** 구분선 두께(px), thickness보다 우선 */
+    size?: number;
+    /** 구분선 두께 프리셋 */
+    thickness?: DividerThickness;
+    /** 구분선 외부 여백 크기(px) */
+    spaceSize?: number;
+    /** 구분선 외부 여백 방향 */
+    spaceDirection?: SpaceDirection;
+    /** content 좌우 여백(px, horizontal only) */
+    contentSpace?: number;
+    /** content 정렬(horizontal only) */
+    contentAlign?: "left" | "right" | "center";
+    /** content 위치 오프셋(px, horizontal only) */
+    contentPosition?: number;
+    /** 추가 스타일 */
+    style?: CSSProperties;
+    /** 수평 Divider 중앙 content */
+    children?: ReactNode;
+};
+type HorizontalProps = BaseProps & {
+    type?: "horizontal";
+};
+type VerticalProps = BaseProps & {
+    type: "vertical";
+    children?: never;
+    contentAlign?: never;
+    contentPosition?: never;
+};
+type DividerProps = HorizontalProps | VerticalProps;
+/**
+ * `Divider`컴포넌트는 구분선을 표시하는 컴포넌트입니다.
+ */
+declare const RBDivider: React$1.ForwardRefExoticComponent<DividerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const textInputSizes: readonly ["xs2", "sm", "md", "lg"];
+type TextInputSize = (typeof textInputSizes)[number];
+declare const textInputVariantsList: readonly ["default", "success"];
+type TextInputVariant = (typeof textInputVariantsList)[number];
+declare const textInputVariants: (props?: {
+    size?: "xs2" | "sm" | "md" | "lg";
+    variant?: "success" | "default";
+    focus?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type TextInputVariantProps = VariantProps<typeof textInputVariants>;
+
+interface PropsType$q extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    className?: string;
+    /**
+     * TextInput 크기
+     */
+    size?: TextInputSize;
+    /**
+     * TextInput variant
+     */
+    variant?: TextInputVariant;
+    disabled?: boolean;
+    readonly?: boolean;
+    /** input의 type 속성 */
+    type?: "email" | "number" | "password" | "search" | "tel" | "text" | "url" | "program" | "nx-number";
+    /** input 태그가 갖는 value 값 */
+    value?: string | number;
+    /** 입력 필드에 에러 상태 표시 여부 */
+    error?: boolean;
+    /** 입력 칠드에 가이드 안내 상태 표시 여부 */
+    /**
+     * 검색 아이콘으로 사용될 ReactElement (default: `<SvgIcoSearchDefault />`)
+     *
+     * `ex) searchIcon={<SvgIcoSearch2 />}`
+     */
+    searchIcon?: ReactElement;
+    /**
+     * input 박스 내부 value 앞에 노출할 ReactElement
+     * type이 search일때는 나타나지 않음
+     *
+     * `ex) prefixIcon={<SvgIcoSearch2 />}`
+     */
+    prefixIcon?: ReactElement;
+    /**
+     * 리셋 아이콘으로 사용될 ReactElement  (default: `<SvgIcoClose />`)
+     *
+     * `ex) resetIcon={<SvgIcoClose2 />}`
+     */
+    resetIcon?: ReactElement;
+    /** 입력 값 검증을 위한 정규 표현식 또는 함수 */
+    validate?: RegExp | ((value: string) => string) | ((value: number) => number);
+    /** 리셋 버튼 숨김 처리 여부 */
+    hideBtnReset?: boolean;
+    /** 숫자 키패드에 `set` 버튼 사용 여부 */
+    useSetButton?: boolean;
+    /** 값이 변경될 때 호출될 함수 */
+    handleChange?: (value: AllowAny, name?: string) => void;
+    /** 엔터 키가 눌렸을 때 호출될 함수 */
+    handleEnter?: (value: AllowAny, name?: string) => void;
+    /** 리셋 버튼이 클릭됐을 때 호출될 함수 */
+    handleReset?: (value: AllowAny, name?: string, clickResetBtn?: boolean) => void;
+}
+/**
+ * `TextInput` 컴포넌트는 다양한 유형의 입력 필드를 생성하기 위한 컴포넌트입니다.
+ * 이 컴포넌트는 사용자 입력을 받고, 이를 검증하며, 입력 값이 변경될 때마다 지정된 함수를 호출할 수 있습니다.
+ */
+declare const RBTextInput: React$1.ForwardRefExoticComponent<PropsType$q & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const textAreaVariantsList: readonly ["default", "success"];
+type TextAreaVariant = (typeof textAreaVariantsList)[number];
+type TextAreaSize = (typeof textAreaSizes)[number];
+declare const textAreaSizes: readonly ["sm", "md", "lg"];
+declare const textAreaVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    variant?: "success" | "default";
+    focus?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type TextAreaVariantProps = VariantProps<typeof textAreaVariants>;
+
+interface Props$e extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    className?: string;
+    type?: "text" | "program";
+    size?: TextAreaSize;
+    variant?: TextAreaVariant;
+    disabled?: boolean;
+    readOnly?: boolean;
+    maxLength?: number;
+    error?: boolean;
+    handleChange?: (value: string, name?: string) => void;
+}
+/**
+ * 텍스트 입력 필드 컴포넌트
+ */
+declare const RBTextArea: React$1.ForwardRefExoticComponent<Props$e & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+declare const datePickerSizes: readonly ["xs2", "sm", "md", "lg"];
+type DatePickerSize = (typeof datePickerSizes)[number];
+declare const datePickerTypes: readonly ["basic", "range"];
+type DatePickerType = (typeof datePickerTypes)[number];
+declare const datePickerVariantsList: readonly ["default"];
+type DatePickerVariant = (typeof datePickerVariantsList)[number];
+
+type Props$d = {
+    className?: string;
+    /**
+     * 모달 또는 팝오버 표시 여부
+     */
+    showType?: "popover" | "modal";
+    /**
+     * 선택된 날짜 값
+     */
+    value?: number | [number | undefined, number | undefined];
+    /**
+     * 날짜 입력 필드의 이름
+     */
+    name?: string;
+    /**
+     * 비활성화 여부
+     */
+    disabled?: boolean;
+    /**
+     * 읽기 전용 여부
+     */
+    readOnly?: boolean;
+    size?: DatePickerSize;
+    variant?: DatePickerVariant;
+    error?: boolean;
+    /**
+     * 프리셋 영역 표시 여부
+     * @default true
+     */
+    showPresets?: boolean;
+    /**
+     * 시간 picker footer 영역 표시 여부
+     * @default true
+     */
+    showFooter?: boolean;
+    /**
+     * 날짜 입력 필드의 플레이스홀더
+     */
+    placeholder?: string;
+    /**
+     * 날짜 값 변경 함수
+     */
+    handleChange?: (startValue: number | undefined, endValue: number | undefined, name: string) => void;
+};
+/**
+ * 날짜 입력 컴포넌트 입니다.
+ */
+declare const DateInput: ({ className, showType, value, name, disabled, readOnly, size, variant, error, showPresets, showFooter, placeholder, handleChange, }: Props$d) => react_jsx_runtime.JSX.Element;
+
+type Props$c = {
+    className?: string;
+    calendarPanelClassName?: string;
+    /**
+     * 모달 또는 팝오버 표시 여부
+     */
+    showType?: "popover" | "modal";
+    /**
+     * 선택된 날짜 값
+     */
+    value?: [number | undefined, number | undefined];
+    /**
+     * 날짜 입력 필드의 이름
+     */
+    name?: string;
+    /**
+     * 최소 날짜 값
+     */
+    min?: number;
+    /**
+     * 최대 날짜 값
+     */
+    max?: number;
+    /**
+     * 날짜 입력 필드의 플레이스홀더
+     */
+    placeholder?: string | {
+        start: string;
+        end: string;
+    };
+    /**
+     * 비활성화 여부
+     */
+    disabled?: boolean;
+    /**
+     * 선택 불가능한 날짜 조건
+     */
+    disabledDates?: Matcher | Matcher[];
+    /**
+     * 읽기 전용 여부
+     */
+    readOnly?: boolean;
+    size?: DatePickerSize;
+    variant?: DatePickerVariant;
+    error?: boolean;
+    /**
+     * 프리셋 영역 표시 여부
+     * @default true
+     */
+    showPresets?: boolean;
+    /**
+     * 시간 picker footer 영역 표시 여부
+     * @default true
+     */
+    showFooter?: boolean;
+    /**
+     * 날짜 값 변경 함수
+     */
+    handleChange?: (startValue: number | undefined, endValue: number | undefined, name: string) => void;
+    /**
+     * 표시할 프리셋 키 목록. 미지정 시 전체 표시.
+     */
+    presets?: RangePresetKey[];
+};
+type RangePresetKey = "last-24-hours" | "last-3-days" | "last-week" | "last-month" | "last-3-month";
+/**
+ * 범위 날짜 입력 컴포넌트 입니다.
+ */
+declare const RangeDateInput: ({ className, calendarPanelClassName, showType, value, name, min, max, placeholder, disabled, disabledDates, readOnly, size, variant, error, showPresets, showFooter, handleChange, presets, }: Props$c) => react_jsx_runtime.JSX.Element;
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+
+interface ModalPropsType<T = AllowAny> {
+  children?: ReactNode;
+  className?: string;
+  open: boolean;
+  close: () => void | Promise<unknown>;
+  onOpenChange: (open: boolean) => void;
+  resolve: (value: T, useClose?: boolean) => void;
+  enableDimClose?: boolean;
+  hideCloseButton?: boolean;
+}
+
+interface Props$b extends ModalPropsType<boolean> {
+    className?: string;
+    /** alert 타이틀 */
+    title?: string | ReactElement;
+    /** alert 내용 */
+    content: ReactNode;
+    /** alert 본문 클래스 */
+    contentClassName?: string;
+    /** 버튼 텍스트 */
+    buttonText?: string;
+    /** 버튼 클래스 */
+    buttonClassName?: string;
+    /** 모달 dialog일때 컨테이너 id */
+    containerId?: string;
+    snapshotCnt?: number;
+    /** 확인 버튼 클릭 시 호출되는 함수 */
+    onConfirm?: () => void;
+}
+/**
+ * 알림 모달
+ *
+ * @param {string} props.className - 모달 컨테이너 클래스
+ * @param {boolean} props.open - 모달 오픈 여부
+ * @param {function} props.onOpenChange - 모달 오픈 상태 변경 함수
+ * @param {string} props.title - 알림 타이틀
+ * @param {ReactNode} props.content - 알림 내용
+ * @param {string} props.buttonText - 버튼 텍스트
+ * @param {function} props.onConfirm - 확인 버튼 클릭 시 호출되는 함수
+ * @param {string} props.buttonClassName - 버튼 클래스
+ */
+declare const RBAlert: ({ className, containerId, open, onOpenChange, title, content, contentClassName, buttonText, snapshotCnt, resolve, onConfirm, }: Props$b) => react_jsx_runtime.JSX.Element;
+
+interface Props$a extends ModalPropsType<boolean> {
+    className?: string;
+    /** confirm 타이틀 */
+    title?: string;
+    /** confirm 설명 */
+    description?: string | ReactElement;
+    /** confirm 내용 */
+    content: ReactNode;
+    /** confirm 본문 클래스 */
+    contentClassName?: string;
+    /** 버튼 텍스트 */
+    buttonText?: {
+        yes: string;
+        no: string;
+    };
+    /** 버튼 클래스 */
+    buttonClassName?: {
+        yes?: string;
+        no?: string;
+    };
+    /** 버튼 래퍼 클래스 */
+    buttonWrapperClassName?: string;
+    snapshotCnt?: number;
+    /** 모달 dialog일때 컨테이너 id */
+    containerId?: string;
+    /** 확인 버튼 클릭 시 실행할 함수 */
+    onConfirm?: () => void;
+    /** 취소 버튼 클릭 시 실행할 함수 */
+    onCancel?: () => void;
+}
+/**
+ * 컨펌 모달
+ *
+ * @param {string} props.className - 모달 컨테이너 클래스
+ * @param {boolean} props.open - 모달 오픈 여부
+ * @param {function} props.onOpenChange - 모달 오픈 상태 변경 함수
+ * @param {string} props.title - 컨펌 타이틀
+ * @param {ReactNode} props.content - 컨펌 내용
+ * @param {object} props.buttonText - 버튼 텍스트 (yes: 확인, no: 취소)
+ * @param {string} props.containerId - 모달 dialog일때 컨테이너 id
+ * @param {object} props.buttonClassName - 버튼 클래스 (yes: 확인, no: 취소)
+ * @param {string} props.buttonWrapperClassName - 버튼 래퍼 클래스
+ */
+declare const RBConfirm: ({ className, open, onOpenChange, title, description, content, contentClassName, buttonText, buttonClassName, buttonWrapperClassName, snapshotCnt, containerId, onConfirm, onCancel, resolve, }: Props$a) => react_jsx_runtime.JSX.Element;
+
+type HelperTone = "default" | "error" | "success";
+interface PropsType$p {
+    className?: string;
+    helperText?: React.ReactNode;
+    helperTone?: HelperTone;
+}
+/** 입력 필드 하단의 안내/오류 메시지를 표시하는 컴포넌트 */
+declare function RBTextHelperText({ className, helperText, helperTone, }: PropsType$p): react_jsx_runtime.JSX.Element;
+
+interface Props$9 extends ModalPropsType<string> {
+    className?: string;
+    /** prompt 타이틀 */
+    title?: string;
+    /** prompt 내용 (TextInput 위에 나오는 내용) */
+    content?: ReactNode;
+    /** prompt 내용 클래스 */
+    contentClassName?: string;
+    /** 입력 필드 placeholder */
+    placeholder?: string;
+    /** 입력 필드 타입 */
+    inputType?: "text" | "password" | "program";
+    /** 입력 필드 요소 */
+    inputElement?: ReactElement;
+    /** 입력 필드 레이블 */
+    label?: ReactNode;
+    /** 입력 필드 설명 */
+    description?: ReactNode;
+    /** 입력 필드 필수 여부 */
+    required?: boolean;
+    /** 입력 필드 헬퍼 텍스트 */
+    helperText?: ReactNode;
+    /** 입력 필드 헬퍼 텍스트 톤 */
+    helperTone?: HelperTone;
+    /** 입력 필드 자동 포커스 여부 */
+    autoFocus?: boolean;
+    /** 입력 필드 기본 값 */
+    value?: string;
+    /** 버튼 텍스트 */
+    buttonText?: {
+        yes: string;
+        no: string;
+    };
+    /** 버튼 클래스 */
+    buttonClassName?: {
+        yes?: string;
+        no?: string;
+    };
+    snapshotCnt?: number;
+    /** 모달 dialog일때 컨테이너 id */
+    containerId?: string;
+    /** 버튼 래퍼 클래스 */
+    buttonWrapperClassName?: string;
+}
+/**
+ * 프롬프트 모달
+ *
+ * @param {string} props.className - 모달 컨테이너 클래스
+ * @param {boolean} props.open - 모달 오픈 여부
+ * @param {function} props.onOpenChange - 모달 오픈 상태 변경 함수
+ * @param {string} props.title - 프롬프트 타이틀
+ * @param {ReactNode} props.content - 프롬프트 내용
+ * @param {string} props.placeholder - 입력 필드 placeholder
+ * @param {string} props.inputType - 입력 필드 타입
+ * @param {boolean} props.autoFocus - 입력 필드 자동 포커스 여부
+ * @param {string} props.value - 입력 필드 기본 값
+ * @param {object} props.buttonText - 버튼 텍스트 (yes: 확인, no: 취소)
+ * @param {function} props.resolve - 확인 버튼 클릭 시 호출 함수
+ * @param {function} props.close - 취소 버튼 클릭 시 호출 함수
+ */
+declare const RBPrompt: ({ className, open, onOpenChange, title, content, contentClassName, placeholder, inputType, inputElement, label, description, required, helperText, helperTone, autoFocus, value, buttonText, buttonClassName, buttonWrapperClassName, containerId, snapshotCnt, resolve, close, }: Props$9) => react_jsx_runtime.JSX.Element;
+
+interface PropsType$o extends React.ComponentPropsWithoutRef<"div"> {
+    className?: string;
+}
+declare function RBDim({ className, ...props }: PropsType$o): react_jsx_runtime.JSX.Element;
+
+type DialogSize = "sm" | "md" | "lg";
+type RBDialogContentProps = React.ComponentProps<typeof ShadDialogPrimitive.Content> & {
+    container?: HTMLElement;
+    showCloseButton?: boolean;
+    size?: DialogSize;
+};
+declare function RBDialog({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function RBDialogTrigger({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function RBDialogPortal({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function RBDialogClose({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Close>): react_jsx_runtime.JSX.Element;
+declare const RBDialogOverlay: React$1.ForwardRefExoticComponent<Omit<ShadDialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function RBDialogContent({ className, children, container, showCloseButton, size, ...props }: RBDialogContentProps): react_jsx_runtime.JSX.Element;
+declare function RBDialogHeader({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBDialogFooter({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare const RBDialogTitle: React$1.ForwardRefExoticComponent<Omit<ShadDialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const RBDialogDescription: React$1.ForwardRefExoticComponent<Omit<ShadDialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+type DrawerSide = "top" | "right" | "bottom" | "left";
+type RBDrawerProps = React.ComponentProps<typeof Drawer.Root> & {
+    side?: DrawerSide;
+};
+type RBDrawerContentProps = React.ComponentProps<typeof Drawer.Content> & {
+    side?: DrawerSide;
+    showHandle?: boolean;
+    showCloseButton?: boolean;
+};
+declare function RBDrawer({ side, ...props }: RBDrawerProps): react_jsx_runtime.JSX.Element;
+declare function RBDrawerTrigger({ ...props }: React.ComponentProps<typeof Drawer.Trigger>): react_jsx_runtime.JSX.Element;
+declare function RBDrawerClose({ ...props }: React.ComponentProps<typeof Drawer.Close>): react_jsx_runtime.JSX.Element;
+declare function RBDrawerPortal({ ...props }: React.ComponentProps<typeof Drawer.Portal>): react_jsx_runtime.JSX.Element;
+declare function RBDrawerOverlay({ className, ...props }: React.ComponentProps<typeof Drawer.Overlay>): react_jsx_runtime.JSX.Element;
+declare function RBDrawerContent({ className, children, side, showHandle, showCloseButton, ...props }: RBDrawerContentProps): react_jsx_runtime.JSX.Element;
+declare function RBDrawerHeader({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBDrawerBody({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBDrawerFooter({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBDrawerTitle({ className, ...props }: React.ComponentProps<typeof Drawer.Title>): react_jsx_runtime.JSX.Element;
+declare function RBDrawerDescription({ className, ...props }: React.ComponentProps<typeof Drawer.Description>): react_jsx_runtime.JSX.Element;
+
+type SheetSide = "top" | "right" | "bottom" | "left";
+type RBSheetContentProps = React.ComponentProps<typeof ShadDialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+    side?: SheetSide;
+};
+declare function RBSheet({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function RBSheetTrigger({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function RBSheetClose({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Close>): react_jsx_runtime.JSX.Element;
+declare function RBSheetPortal({ ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function RBSheetOverlay({ className, ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Overlay>): react_jsx_runtime.JSX.Element;
+declare function RBSheetContent({ className, children, side, showCloseButton, ...props }: RBSheetContentProps): react_jsx_runtime.JSX.Element;
+declare function RBSheetHeader({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBSheetFooter({ className, ...props }: React.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBSheetTitle({ className, ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Title>): react_jsx_runtime.JSX.Element;
+declare function RBSheetDescription({ className, ...props }: React.ComponentProps<typeof ShadDialogPrimitive.Description>): react_jsx_runtime.JSX.Element;
+
+type Props$8 = {
+    className?: string;
+    /** 모달 노출 방식 */
+    type?: "dialog" | "drawer" | "bottom-sheet" | "top-sheet" | "left-sheet" | "right-sheet";
     children?: ReactNode;
-    ref?: Ref<Element>;
-    slot?: string;
+    /** 모달 배경 클릭 시 닫힘 가능 여부 */
+    enableDimClose?: boolean;
+    /** 모달 노출 여부 */
+    open: boolean;
+    /** 모달 노출 여부 변경 함수 */
+    onOpenChange: (open: boolean) => void;
+    /**
+     * 모달 헤더 정보
+     *
+     * @param {ReactElement | string} title  모달 헤더 제목
+     * @param {ReactElement | string} description 모달 헤더 설명
+     */
+    header?: {
+        title?: ReactElement | string;
+        description?: ReactElement | string;
+    };
+    /** 모달 푸터 */
+    footer?: ReactElement | string;
+    /** 모달 닫기 버튼 숨김 여부 */
+    hideCloseButton?: boolean;
+    /** 모달 열릴 때 자동 포커스 비활성화 여부 */
+    disableAutoFocus?: boolean;
+    snapshotCnt?: number;
+    /** 모달 dialog일때 컨테이너 */
+    dialogContainer?: HTMLElement;
+    gamePadType?: "modal" | "dialog";
+    onOpenAutoFocus?: ComponentProps<typeof RBDialogContent>["onOpenAutoFocus"];
 };
-type RemoteElementComponent<Element, Props, EventProps = NoEventProps> = ComponentType<RemoteElementComponentProps<Element, Props, EventProps>>;
-export type RbSliderChangeEvent = {
-    detail: number;
+declare const RBModal: ({ className, open, type, dialogContainer, children, enableDimClose, header, hideCloseButton, footer, gamePadType, onOpenChange, disableAutoFocus, }: Props$8) => react_jsx_runtime.JSX.Element;
+
+declare const selectSizes: readonly ["xs2", "sm", "md", "lg"];
+type SelectSize = (typeof selectSizes)[number];
+declare const selectTriggerVariants: (props?: {
+    size?: "xs2" | "sm" | "md" | "lg";
+    variant?: "default";
+    focus?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type SelectTriggerVariantProps = VariantProps<typeof selectTriggerVariants>;
+
+type RBSelectBoxRef = HTMLInputElement & {
+    handleClickSelectBox?: () => void;
 };
-export type RbTextInputEvent = {
-    detail: string;
+interface PropsType$n extends Pick<InputHTMLAttributes<HTMLInputElement>, "name" | "defaultValue" | "placeholder" | "disabled" | "readOnly" | "onChange" | "onFocus" | "onBlur" | "onInput"> {
+    className?: string;
+    /**
+     * SelectBox의 크기
+     */
+    size?: SelectSize;
+    /**
+     * option list를 찾는 search 기능 활성화 여부
+     */
+    search?: boolean;
+    /** SelectBox가 갖는 value 값 */
+    value?: string | number;
+    /**
+     * Option 컴포넌트만 받는 children
+     *
+     * Option 컴포넌트가 아니면 미노출 (단 Option 컴포넌트의 children은 노출)
+     */
+    children: ReactNode | ReactNode[];
+    /**
+     * 모바일, 태블릿 일때 DropBox 상단에 노출될 제목(라벨)
+     */
+    mobileLabel?: string;
+    /**
+     * SelectBox 우측에 나올 arrow 아이콘
+     *
+     * `ex) selectArrow={<SvgIcoSelectboxArrow />}`
+     */
+    selectArrow?: ReactElement;
+    /**
+     * SelectDropBox에 전달할 className
+     */
+    dropBoxClassName?: string;
+    /**
+     * Modal 컴포넌트에 전달할 className
+     */
+    modalBoxClassName?: string;
+    /**
+     * Option을 선택해도 DropBox가 계속 닫히지 않고 열려있기를 원할때 사용
+     */
+    keepDropDown?: boolean;
+    /**
+     * DropBox 안에 option을 검색하는 input 태그에 들어갈 placeholder
+     */
+    searchPlaceholder?: string;
+    /**
+     * option list가 없거나 검색에 포함된 option이 아무것도 없을때 나타나는 `string | ReactElement` 형식의 메세지
+     */
+    noDataMsg?: string | ReactElement;
+    /**
+     * DropBox 상단에 close button을 노출할지 여부
+     */
+    showCloseBtn?: boolean;
+    /**
+     * 스크롤 시 DropBox가 닫히게 할지 여부
+     */
+    whenScrollCloseDropBox?: boolean;
+    /**
+     * 모달 형태로 랜더링 할지 여부
+     */
+    enableModal?: boolean;
+    /**
+     * error 상태
+     */
+    error?: boolean;
+    /**
+     * gamepad focus 기능 활성화 여부
+     */
+    enableGamepadFocus?: boolean;
+    /**
+     * SelectBox를 눌렀을때 DropBox가 열리는게 아니고 특정 로직이 실행되어야 한다면 onClick 함수 전달
+     */
+    onClick?: () => void;
+    /** 값이 변경될 때 호출될 함수 */
+    handleChange?: (value: AllowAny, name: string) => void;
+    onChange?: (e: ChangeEvent<HTMLInputElement> | {
+        target: HTMLInputElement;
+    }) => void;
+}
+type SelectData = {
+    label: ReactNode | string;
+    value: string | number | null;
 };
-export type RbSwitchChangeEvent = {
-    detail: boolean;
+/**
+ * `SelectBox` 컴포넌트는 사용자에게 드롭다운 형태의 선택 옵션들을 제공합니다.
+ * 이 컴포넌트는 HTML `<input>` 태그의 주요 속성들을 상속받으며, 추가적인 커스터마이징 옵션을 제공합니다.
+ */
+declare const RBSelectBox: React$1.ForwardRefExoticComponent<PropsType$n & React$1.RefAttributes<RBSelectBoxRef>>;
+
+interface PropsType$m {
+    className?: string;
+    /**
+     * SelectBox의 크기
+     */
+    size?: SelectSize;
+    /** searchText와 비교하여 검색에 활용할 값 */
+    text?: string;
+    /** option이 갖는 value 값 */
+    value?: string | number | null;
+    /**
+     * option이 선택되었을때 SelectBox에 보여줄 내용 (없다면 children)
+     */
+    label?: string | ReactElement;
+    children: React.ReactNode | string;
+    /** SelectBox에서 이미 선택된 option의 값 */
+    selectedValue?: string;
+    /** SelectBox에서 이미 선택된 option의 text */
+    searchText?: string;
+    /** option 아래에 표시할 부가 설명 */
+    description?: string;
+    /** 비활성화 상태인지 여부 */
+    disabled?: boolean;
+    /** gamepad focus 기능 활성화 여부 */
+    enableGamepadFocus?: boolean;
+    /** 값이 변경될 때 호출될 함수 */
+    handleChange?: (selectData: SelectData) => void;
+}
+/**
+ * `SelectBox` 내에서 사용될 `Option` 컴포넌트입니다.
+ * 사용자가 `SelectBox`에서 선택할 수 있는 각각의 옵션을 표현합니다.
+ *
+ * @param {string} [props.className=''] - 컴포넌트의 CSS 클래스 이름
+ * @param {string} [props.text] - `searchText`와 비교하여 검색에 활용될 값
+ * @param {string|number|null} [props.value] - `Option`이 갖는 value 값
+ * @param {string|React.ReactElement} [props.label] - `Option`이 선택되었을 때 `SelectBox`에 보여줄 내용 (없다면 children)
+ * @param {React.ReactNode|string} props.children - `Option` 내부에 표시될 자식 요소
+ * @param {string} [props.selectedValue=''] - `SelectBox`에서 이미 선택된 `Option`의 값
+ * @param {string} [props.searchText=''] - `SelectBox`에서 이미 선택된 `Option`의 text 값
+ * @param {boolean} [props.disabled] - 비활성화 상태 여부
+ * @param {Function} [props.handleChange] - 값이 변경될 때 호출될 함수
+ */
+declare const RBSelectOption: {
+    ({ className, size, text, value, label, children, description, selectedValue, searchText, enableGamepadFocus, disabled, handleChange, }: PropsType$m): react_jsx_runtime.JSX.Element;
+    displayName: string;
 };
-export type RbSelectChangeEvent = {
-    detail: string;
+
+interface PropsType$l {
+    className?: string;
+    theme?: string;
+    /**
+     * SelectBox의 크기
+     */
+    size?: SelectSize;
+    /**
+     * DropBox가 SelectBox의 위에 나오게 할지 아래에 나오게 할지에 대한 방향 값
+     */
+    direction?: "top" | "bottom";
+    children: ReactNode | ReactNode[];
+    /** 모바일, 태블릿 일때 DropBox 상단에 노출될 제목(라벨) */
+    label?: string;
+    /** DropBox가 갖는 최대 높이값 */
+    maxHeight?: number;
+    /** SelectBox 컴포넌트의 최상위 element */
+    parentEl: HTMLDivElement;
+    /** SelectBox안에 있는 input element */
+    inputEl: HTMLInputElement;
+    /** option list를 찾는 search 기능 활성화 여부  */
+    search?: boolean;
+    /** option list를 찾는 input태그의 value 값 */
+    searchText?: string;
+    /** option을 검색하는 input 태그에 들어갈 placeholder */
+    searchPlaceholder?: string;
+    /**
+     * option list가 없거나 검색에 포함된 option이 아무것도 없을때 나타나는 `string | ReactElement` 형식의 메세지
+     */
+    noDataMsg?: string | ReactElement;
+    /** 상단에 close button을 노출할지 여부 */
+    showCloseBtn?: boolean;
+    /** 스크롤 시 DropBox가 닫히게 할지 여부 */
+    whenScrollCloseDropBox?: boolean;
+    /** DropBox open 상태 state를 dispatch 할 수 있는 setState 함수 */
+    setOpen: Dispatch<SetStateAction<boolean>>;
+    /** option을 검색하는 input 태그의 값을 상위 컴포넌트에 전달하는 함수 */
+    handleSearchTextChange: (value: string) => void;
+    /** option을 검색하는 input 태그가 focus된 상태일때 키보드를 누르면 호출되는 함수 */
+    handleKeyPress: (e: React__default.KeyboardEvent) => void;
+}
+/**
+ * `SelectDropBox` 컴포넌트는 사용자가 선택을 위해 클릭한 `SelectBox`에 연결된 옵션 목록을 표시하는 드롭다운 박스입니다.
+ * 사용자는 이 드롭다운에서 옵션을 검색하고 선택할 수 있습니다.
+ *
+ * @component
+ * @param {Object} props - `SelectDropBox` 컴포넌트에 전달되는 프로퍼티들
+ * @param {string} [props.className] - `SelectDropBox` 컴포넌트에 적용될 추가 CSS 클래스명
+ * @param {string} [props.theme] - `SelectDropBox` 컴포넌트에 적용될 테마
+ * @param {'top'|'bottom'} [props.direction='bottom'] - 드롭다운 박스가 `SelectBox`의 위에 표시될지 아래에 표시될지 결정하는 방향 값
+ * @param {React.ReactNode} props.children - 드롭다운 내부에 렌더링될 자식 요소들. 주로 옵션 목록이 위치
+ * @param {string} [props.label] - 모바일, 태블릿 환경에서 드롭박스 상단에 표시될 라벨(제목)
+ * @param {number} [props.maxHeight] - 드롭박스가 갖는 최대 높이값. 이 값을 넘어서는 내용은 스크롤을 통해 볼 수 있음
+ * @param {HTMLDivElement} props.parentEl - `SelectBox` 컴포넌트의 최상위 요소
+ * @param {HTMLInputElement} props.inputEl - `SelectBox` 내부에 있는 입력 필드 요소
+ * @param {boolean} [props.search=false] - 옵션 리스트 내 검색 기능 활성화 여부
+ * @param {string} [props.searchText] - 옵션을 검색하는 입력 필드의 현재 값
+ * @param {string} [props.searchPlaceholder] - 검색 입력 필드에 표시될 플레이스홀더 텍스트
+ * @param {string | ReactElement} [props.noDataMsg] - option list가 없거나 검색에 포함된 option이 아무것도 없을때 나타나는 `string | ReactElement` 형식의 메세지
+ * @param {boolean} [props.showCloseBtn=false] - 드롭다운 박스 상단에 닫기 버튼 표시 여부
+ * @param {boolean} [props.whenScrollCloseDropBox=false] - 스크롤 시 드롭다운 박스를 자동으로 닫을지 여부
+ * @param {Dispatch<SetStateAction<boolean>>} props.setOpen - 드롭박스의 열림/닫힘 상태를 제어할 수 있는 상태 설정 함수
+ * @param {function} props.handleSearchTextChange - 옵션을 검색하는 입력 필드 값이 변경될 때 호출되는 함수. 변경된 값을 상위 컴포넌트에 전달
+ * @param {function} props.handleKeyPress - 옵션을 검색하는 입력 필드가 포커스된 상태에서 키보드 입력이 있을 때 호출되는 함수
+ */
+declare const RBSelectDropBox: React__default.ForwardRefExoticComponent<PropsType$l & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const noDataSizes: readonly ["sm", "md", "lg", "xl"];
+type noDataSize = (typeof noDataSizes)[number];
+
+interface PropsType$k {
+    /**
+     * 데이터가 없을때 노출시킬 메세지 내용
+     */
+    nullText?: ReactElement | string;
+    style?: CSSProperties;
+    className?: string;
+    /**
+     * 데이터가 없을때 노출시킬 아이콘 및 추가 내용
+     */
+    children?: ReactElement;
+    size?: noDataSize;
+}
+declare const RBNoData: ({ className, nullText, children, style, size, }: PropsType$k) => react_jsx_runtime.JSX.Element;
+
+type Props$7 = {
+    className?: string;
+    /**
+     * 현재 페이지
+     */
+    currPage: number;
+    /**
+     * 페이지 당 나오는 리스트 항목 수
+     */
+    listSize: number;
+    /**
+     * 페이지 당 항목 수
+     */
+    pageSize?: number;
+    /**
+     * 총 항목 수
+     */
+    totalCount: number;
+    /**
+     * 페이지 변경 함수
+     */
+    handlePageChange: (page: number) => void;
 };
-export interface RbSliderEventProps {
-    onChange?: (event: RbSliderChangeEvent) => void;
+declare const RBPagination: ({ className, currPage, listSize, pageSize, totalCount, handlePageChange, }: Props$7) => react_jsx_runtime.JSX.Element;
+
+declare const sideNumberInputSizes: readonly ["xs2", "sm", "md", "lg"];
+type SideNumberInputSize = (typeof sideNumberInputSizes)[number];
+declare const sideNumberInputVariantsList: readonly ["default", "success"];
+type SideNumberInputVariant = (typeof sideNumberInputVariantsList)[number];
+declare const sideNumberInputVariants: (props?: {
+    size?: "xs2" | "sm" | "md" | "lg";
+    variant?: "success" | "default";
+    focus?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    inputDisabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type SideNumberInputVariantProps = VariantProps<typeof sideNumberInputVariants>;
+
+interface Props$6 extends Pick<React.InputHTMLAttributes<HTMLInputElement>, "className" | "name" | "tabIndex" | "autoComplete" | "placeholder" | "disabled" | "readOnly" | "inputMode" | "onChange" | "onBlur" | "onFocus" | "onKeyDown" | "onPointerUp" | "onPointerDown" | "onPointerMove"> {
+    className?: string;
+    type?: "number" | "nx-number";
+    inputClassName?: string;
+    size?: SideNumberInputSize;
+    variant?: SideNumberInputVariant;
+    name?: string;
+    /** up, down 버튼을 눌렀을때 증가/감소되는 값 */
+    step?: number;
+    /** up 버튼을 눌렀을때 증가되는 값 */
+    increaseStep?: number;
+    /** down 버튼을 눌렀을때 감소되는 값 */
+    decreaseStep?: number;
+    /** 입력 필드의 현재 값 */
+    value?: string;
+    /** error 유무 */
+    error?: boolean;
+    /** 최소값 */
+    min?: string | number;
+    /** 최대값 */
+    max?: string | number;
+    /** 정수의 최대 길이 */
+    maxLength?: number | string;
+    /** 최대 소수점 자리 */
+    digit?: number;
+    /** 직접 입력 허용 여부 */
+    isDirect?: boolean;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** input만 비활성화 여부 */
+    inputDisabled?: boolean;
+    /** 더블 클릭 감지 여부 */
+    detectDobleClick?: boolean;
+    /** 읽기 전용 활성화 여부 */
+    readOnly?: boolean;
+    /** placeholder */
+    placeholder?: string;
+    /** 숫자 키패드에 `set` 버튼 사용 여부 */
+    useSetButton?: boolean;
+    /** 자동완성 기능 활성화 여부 */
+    autoComplete?: HTMLInputAutoCompleteAttribute;
+    /** up 버튼안에 노출할 icon 컴포넌트 */
+    increaseElement?: ReactElement;
+    /** down 버튼안에 노출할 icon 컴포넌트 */
+    decreaseElement?: ReactElement;
+    disableAutoAccel?: boolean;
+    disableLongPress?: boolean;
+    /** 소수점 자리수 고정 (trailing zero 유지, 예: 0.10 → "0.10") */
+    fixedDigit?: number;
+    /** 롱프레스 시작 딜레이 ms (기본 300) */
+    initialLongPressDelay?: number;
+    /** ArrowUp/Down 키로 값 조정 허용 여부 */
+    enableArrowKeys?: boolean;
+    /** 마우스 휠로 값 조정 허용 여부 */
+    enableWheel?: boolean;
+    /** ripple 옵션 */
+    notAllowedEmptyValue?: boolean;
+    onButtonPointerUp?: (type: "up" | "down", e?: MouseEvent<HTMLButtonElement>) => void;
+    onButtonPointerDown?: (type: "up" | "down", e?: MouseEvent<HTMLButtonElement>) => void;
+    /**
+     * 값이 변경될 때 호출될 함수
+     *
+     * @param {string} value - 변경된 값
+     * @param {string} name - 입력 필드(input) name 값
+     * @param {{ type: 'up' | 'down' }} option - up/down 버튼을 눌렀을 경우 전달
+     */
+    handleChange?: (value: string, name?: string, option?: {
+        type: "up" | "down";
+    }) => void;
+    /**
+     * 엔터 키가 눌렸을 때 호출될 함수
+     *
+     * @param {string} value - 변경된 값
+     * @param {string} name - 입력 필드(input) name 값
+     */
+    handleEnter?: (value: string, name?: string) => void;
+}
+declare const SideNumberInput: React$1.ForwardRefExoticComponent<Props$6 & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const radioSizes: readonly ["sm", "md"];
+type RadioSize = (typeof radioSizes)[number];
+declare const radioRootVariants: (props?: {
+    size?: "sm" | "md";
+    checked?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+type RadioVariantProps = VariantProps<typeof radioRootVariants>;
+
+interface PropsType$j extends Pick<InputHTMLAttributes<HTMLInputElement>, "name" | "onChange" | "onBlur" | "onFocus"> {
+    className?: string;
+    /** 라디오박스 UI 옆에 나올 텍스트 및 React 엘리먼트 */
+    children?: ReactNode | string;
+    /** input 태그가 갖는 checkValue 값 */
+    checkValue?: string | number;
+    /** 바인딩할 데이터 값
+     *
+     * (`string | number`로 받아야함)
+     */
+    value?: string | number;
+    size?: RadioSize;
+    /** 체크박스가 비활성화 상태인지 여부 */
+    disabled?: boolean;
+    /** 체크박스가 읽기 전용 상태인지 여부 */
+    readOnly?: boolean;
+    /** 값이 변경될 때 호출될 함수
+     *
+     * (체크 상태에 따라 다른 값을 전달) */
+    handleChange?: (value: AllowAny, name: string) => void;
 }
-export interface RbPressEventProps {
-    onPress?: () => void;
+/**
+ * RadioBox 컴포넌트는 라디오 버튼을 구현합니다. HTML `<input type="radio">` 요소의 특성을 확장하여
+ * React에서 사용하기 쉽도록 만든 컴포넌트입니다.
+ */
+declare const RBRadioBox: React$1.ForwardRefExoticComponent<PropsType$j & React$1.RefAttributes<HTMLInputElement>>;
+
+type Props$5 = PropsType$j & {
+    /**
+     * ripple UI 효과 옵션
+     *
+     * default: `{ disabled: true }`
+     */
+    rippleOption?: RippleOption;
+};
+declare const RBRadioButton: React$1.ForwardRefExoticComponent<PropsType$j & {
+    /**
+     * ripple UI 효과 옵션
+     *
+     * default: `{ disabled: true }`
+     */
+    rippleOption?: RippleOption;
+} & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const tabSizes: readonly ["sm", "md", "lg"];
+type TabSize = (typeof tabSizes)[number];
+declare const chipSizes: readonly ["sm", "md", "lg"];
+type ChipSize = (typeof chipSizes)[number];
+declare const chipsBoxSizes: readonly ["xs", "xs2"];
+type ChipBoxSize = (typeof chipsBoxSizes)[number];
+declare const tabRootVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & class_variance_authority_types.ClassProp) => string;
+declare const chipRootVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & class_variance_authority_types.ClassProp) => string;
+type TabVariantProps = VariantProps<typeof tabRootVariants>;
+type ChipVariantProps = VariantProps<typeof chipRootVariants>;
+
+type TabItem$2 = {
+    /** tab item의 고유키 */
+    key: string | number;
+    /** tab 버튼에 나오는 버튼 내용 */
+    label: ReactElement | string;
+    /** tab content영역에 나오는 내용 */
+    children?: ReactNode;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** tab 버튼과 컨텐츠를 숨길지 여부 */
+    isHide?: boolean;
+};
+interface PropsType$i {
+    className?: string;
+    size?: TabSize;
+    /**
+     * tab의 버튼 내용과 content영역에 나올 내용, 고유 key값, 비활성화 여부의 내용을 담고 있는 배열 요소
+     */
+    tabItems: TabItem$2[];
+    /**
+     * tabItems 배열 요소중 선택된 tab의 key값
+     */
+    activeKey?: string | number;
+    /**
+     * handleChange 두번째 인자에 전달될 name 값
+     */
+    name?: string;
+    /**
+     * 선택된 tab 버튼 밑에 나올 slider UI의 노출 여부
+     */
+    slider?: boolean;
+    /**
+     * tab의 전체적인 비활성화 여부
+     */
+    disabled?: boolean;
+    /**
+     * 선택되지 않은 tab의 children을 지울것인지에 대한 여부
+     */
+    destroyInactiveTabPanel?: boolean;
+    /**
+     * tab 버튼들의 좌우 스크롤을 담당하는 element ref 값이 있다면 전달
+     */
+    tabNavScrollRef?: RefObject<HTMLElement>;
+    /**
+     * content영역을 swipe UI로 노출 할것인지 여부
+     */
+    swipeContent?: boolean;
+    /**
+     * ripple 효과 옵션
+     *
+     * default: `{ disabled: false }`
+     */
+    rippleOption?: RippleOption;
+    /**
+     * tab 버튼에 적용할 클래스 이름
+     */
+    tabBtnClassName?: string;
+    /**
+     * CSS 스타일 속성
+     */
+    style?: CSSProperties;
+    /**
+     * 선택된 tab이 변경될때 상위 컴포넌트로 선택된 tab의 key값을 전달하는 함수
+     * @param key 선택된 tab의 key값
+     * @param name  props로 전달받은 name 값
+     */
+    handleChange?: (key: AllowAny, name: string) => void;
+    /**
+     * tab 버튼을 클릭할때 호출되는 함수
+     * @param key 선택된 tab의 key값
+     * @param e  MouseEvent<HTMLButtonElement>
+     */
+    onClick?: (key: AllowAny, e: MouseEvent<HTMLButtonElement>) => void;
+}
+/**
+ * `Tab` 컴포넌트는 탭 UI를 구성할 때 사용되며, swipe 형식의 UI를 제공할 수도 있습니다.
+ */
+declare const RBTab: {
+    ({ className, size, tabItems, activeKey, name, slider, swipeContent, disabled, rippleOption, tabNavScrollRef, destroyInactiveTabPanel, tabBtnClassName, style, onClick, handleChange, }: PropsType$i): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PropsType$h {
+    className?: string;
+    size?: TabSize;
+    slider?: boolean;
+    useDefaultStyle?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    role?: string;
+    "aria-selected"?: boolean;
+    children?: ReactNode;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+}
+declare const RBTabItem: React$1.ForwardRefExoticComponent<PropsType$h & React$1.RefAttributes<HTMLButtonElement>>;
+
+type TabItem$1 = {
+    /** tab item의 고유키 */
+    key: string | number;
+    /** tab 버튼에 나오는 버튼 내용 */
+    label: ReactElement | string;
+    /** tab content영역에 나오는 내용 */
+    children?: ReactNode;
+    /** 비활성화 여부 */
+    disabled?: boolean;
+    /** tab 버튼과 컨텐츠를 숨길지 여부 */
+    isHide?: boolean;
+};
+interface PropsType$g {
+    className?: string;
+    size?: ChipSize;
+    /**
+     * tab의 버튼 내용과 content영역에 나올 내용, 고유 key값, 비활성화 여부의 내용을 담고 있는 배열 요소
+     */
+    tabItems: TabItem$1[];
+    /**
+     * tabItems 배열 요소중 선택된 tab의 key값
+     */
+    activeKey?: string | number;
+    /**
+     * handleChange 두번째 인자에 전달될 name 값
+     */
+    name?: string;
+    /**
+     * 선택된 tab 버튼 밑에 나올 slider UI의 노출 여부
+     */
+    slider?: boolean;
+    /**
+     * tab의 전체적인 비활성화 여부
+     */
+    disabled?: boolean;
+    /**
+     * 선택되지 않은 tab의 children을 지울것인지에 대한 여부
+     */
+    destroyInactiveTabPanel?: boolean;
+    /**
+     * tab 버튼들의 좌우 스크롤을 담당하는 element ref 값이 있다면 전달
+     */
+    tabNavScrollRef?: RefObject<HTMLElement>;
+    /**
+     * content영역을 swipe UI로 노출 할것인지 여부
+     */
+    swipeContent?: boolean;
+    /**
+     * ripple 효과 옵션
+     *
+     * default: `{ disabled: false }`
+     */
+    rippleOption?: RippleOption;
+    /**
+     * tab 버튼에 적용할 클래스 이름
+     */
+    tabBtnClassName?: string;
+    /**
+     * CSS 스타일 속성
+     */
+    style?: CSSProperties;
+    /**
+     * 선택된 tab이 변경될때 상위 컴포넌트로 선택된 tab의 key값을 전달하는 함수
+     * @param key 선택된 tab의 key값
+     * @param name  props로 전달받은 name 값
+     */
+    handleChange?: (key: AllowAny, name: string) => void;
+    /**
+     * tab 버튼을 클릭할때 호출되는 함수
+     * @param key 선택된 tab의 key값
+     * @param e  MouseEvent<HTMLButtonElement>
+     */
+    onClick?: (key: AllowAny, e: MouseEvent<HTMLButtonElement>) => void;
+}
+/**
+ * `Tab` 컴포넌트는 탭 UI를 구성할 때 사용되며, swipe 형식의 UI를 제공할 수도 있습니다.
+ */
+declare const RBChipTab: {
+    ({ className, size, tabItems, activeKey, name, slider, swipeContent, disabled, rippleOption, tabNavScrollRef, destroyInactiveTabPanel, tabBtnClassName, style, onClick, handleChange, }: PropsType$g): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PropsType$f {
+    className?: string;
+    size?: ChipSize;
+    selected?: boolean;
+    disabled?: boolean;
+    role?: string;
+    "aria-selected"?: boolean;
+    children?: ReactNode;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+}
+declare const RBChipItem: React$1.ForwardRefExoticComponent<PropsType$f & React$1.RefAttributes<HTMLButtonElement>>;
+
+type TabItem = {
+    key: string | number;
+    label: ReactElement | string;
+    children?: ReactNode;
+    disabled?: boolean;
+    isHide?: boolean;
+};
+interface PropsType$e {
+    className?: string;
+    size?: ChipBoxSize;
+    tabItems: TabItem[];
+    activeKey?: string | number;
+    name?: string;
+    disabled?: boolean;
+    destroyInactiveTabPanel?: boolean;
+    rippleOption?: RippleOption;
+    tabBtnClassName?: string;
+    style?: CSSProperties;
+    enableOverflowExpand?: boolean;
+    rightIconButtonProps?: Partial<IconButtonProps>;
+    leftSlot?: ReactNode;
+    handleChange?: (key: AllowAny, name: string) => void;
+    onClick?: (key: AllowAny, e: MouseEvent<HTMLButtonElement>) => void;
+}
+declare const RBChipsBoxTab: {
+    ({ className, size, tabItems, activeKey, name, disabled, destroyInactiveTabPanel, rippleOption, tabBtnClassName, style, enableOverflowExpand, rightIconButtonProps, leftSlot, handleChange, onClick, }: PropsType$e): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PropsType$d extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    size?: ChipBoxSize;
+    selected?: boolean;
+    disabled?: boolean;
+    role?: string;
+    "aria-selected"?: boolean;
+    children?: ReactNode;
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+}
+declare const RBChipsBoxItem: React$1.ForwardRefExoticComponent<PropsType$d & React$1.RefAttributes<HTMLButtonElement>>;
+
+type TableData = Record<string, AllowAny>;
+type ChildrenFuncParamsType<T> = {
+    index: number;
+    item: T extends (infer R)[] ? R : never;
+};
+
+interface PropsType$c<T extends TableData[]> {
+    className?: string;
+    /**
+     * table에 랜더링될 list
+     *
+     * null일 경우 로딩중으로 간주
+     */
+    list: T | null;
+    /**
+     * list가 빈배열일때 노출될 no data 메세지
+     */
+    noDataMsg?: ReactElement | string;
+    /**
+     * 에러 발생시 랜더링할 요소 (ReactNode | ReactElement | string)
+     */
+    errorFallback?: ReactElement | ReactNode | string;
+    /**
+     * 리스트가 `null`일 때 로딩 중임을 표시할 요소
+     *
+     * 문자열 또는 React 컴포넌트 형태로 제공할 수 있으며, 데이터를 로딩 중임을 사용자에게 알리는 데 사용
+     */
+    loadingElement?: ReactElement;
+    /**
+     * thead를 숨김 처리할 것인지의 여부
+     */
+    hideThead?: boolean;
+    /**
+     * thead를 스크롤 상단에 고정할 것인지의 여부
+     */
+    stickyThead?: boolean;
+    /**
+     * 기본 헤더 행 위에 추가로 렌더링할 헤더 행
+     */
+    theadTopRows?: ReactNode;
+    /**
+     * 오름차순 소팅(asc)일 시 th안에 보여줄 아이콘 요소
+     */
+    sortUpElement?: ReactElement | string;
+    /**
+     * 내림차순 소팅(desc)일 시 th안에 보여줄 아이콘 요소
+     */
+    sortDownElement?: ReactElement | string;
+    /**
+     * 소팅 정보가 없을 때 th안에 보여줄 아이콘 요소
+     */
+    sortNormalElement?: ReactElement | string;
+    /**
+     * 로딩 상태를 강제로 지정하고 싶을 때 사용되는 프로퍼티
+     *
+     * `true`로 설정될 경우, `list`의 값과 관계없이 로딩 상태로 간주되며, `loadingElement`가 화면에 표시
+     */
+    loading?: boolean;
+    /**
+     * 자식 컴포넌트를 랜더링하는 함수
+     * 이 함수는 리스트의 각 항목을 받아 React 노드로 변환하는 데 사용
+     * 함수는 리스트의 각 항목(`item`)과 해당 항목의 인덱스(`index`)를 매개변수로 받음
+     */
+    children: (obj: ChildrenFuncParamsType<T>) => ReactNode;
+}
+/**
+ * 범용 테이블 컴포넌트.
+ *
+ * @component
+ *
+ * @template T - TableData를 확장한 배열 타입.
+ * @param {string} [props.className=''] - 컴포넌트에 적용될 CSS 클래스 이름.
+ * @param {T | null} props.list - 테이블에 렌더링될 데이터 목록. `null`일 경우 로딩 중으로 간주.
+ * @param {ReactElement | string} [props.noDataMsg] - 데이터 목록이 빈 배열일 때 표시될 메시지. 문자열 또는 React 요소 형태.
+ * @param {ReactElement | ReactNode | string} [props.errorFallback] - 에러 발생시 랜더링할 요소 (ReactNode | ReactElement | string)
+ * @param {ReactElement} [props.loadingElement=RBSpinner] - 데이터 로딩 중일 때 표시될 요소. 문자열 또는 React 요소 형태.
+ * @param {boolean} [props.hideThead=false] - `true`일 경우 테이블의 헤더(thead)를 숨김 처리.
+ * @param {ReactElement | string} [props.sortUpElement=SvgIcoSortUpElement] - 오름차순 정렬 시 헤더에 표시될 요소. 문자열 또는 React 요소 형태.
+ * @param {ReactElement | string} [props.sortDownElement=SvgIcoSortDownElement] - 내림차순 정렬 시 헤더에 표시될 요소. 문자열 또는 React 요소 형태.
+ * @param {ReactElement | string} [props.sortNormalElement=SvgIcoSortNormalElement] - 소팅 정보가 없을 때 헤더에 표시될 요소. 문자열 또는 React 요소 형태.
+ * @param {Function} props.children - 자식 컴포넌트를 렌더링하는 함수. 리스트의 각 항목(`item`)과 해당 항목의 인덱스(`index`)를 매개변수로 받아 React 노드로 변환하는 데 사용.
+ */
+declare const RBTable: <T extends TableData[]>({ className, list, children, loadingElement, errorFallback, noDataMsg, hideThead, stickyThead, theadTopRows, sortUpElement, sortDownElement, sortNormalElement, loading, }: PropsType$c<T>) => react_jsx_runtime.JSX.Element;
+
+type PropsType$b = {
+    className?: string;
+    /**
+     * 자식 컴포넌트
+     */
+    children: ReactNode | string;
+    /**
+     * 특정 행의 RBTdExpend 컴포넌트의 expend 상태를 지정하는 값
+     */
+    expendOpen?: boolean;
+    /**
+     * 특정 행의 RBTdExpend 컴포넌트의 expend 상태가 변경될때 호출되는 함수
+     * @param status 변경된 expend 상태
+     */
+    handleExpendChange?: (status: boolean) => void;
+    /**
+     * 특정 행의 RBTdExpend 컴포넌트의 expend 상태가 true가 되기 전에 호출되는 함수
+     */
+    beforeExpendOpen?: () => void | Promise<void>;
+    /**
+     * tr 태그를 클릭했을때 호출되는 함수
+     * @param e `MouseEvent<HTMLTableRowElement>`
+     */
+    onClick?: (e: MouseEvent<HTMLTableRowElement>) => void;
+};
+/**
+ * `TableRow` 컴포넌트는 테이블의 행을 나타내며, 다양한 props를 통해 커스터마이징이 가능
+ *
+ * @param {string} [props.className=''] - 컴포넌트에 적용할 CSS 클래스 이름
+ * @param {ReactNode|string} props.children - 행 내부에 렌더링할 자식 컴포넌트 혹은 문자열
+ * @param {boolean} [props.expendOpen=false] - 특정 행의 RBTdExpend 컴포넌트가 확장될 상태인지 지정
+ * @param {function} [props.handleExpendChange] - 특정 행의 RBTdExpend 컴포넌트의 expend 상태가 변경될 때 호출될 함수
+ * @param {function} [props.beforeExpendOpen] - 특정 행의 RBTdExpend 컴포넌트의 expend 상태가 true가 되기 전에 호출될 함수
+ * @param {function} [props.onClick] - tr 태그를 클릭했을 때 호출될 함수
+ */
+declare const RBTableRow: {
+    ({ className, children, expendOpen, handleExpendChange, beforeExpendOpen, onClick, }: PropsType$b): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PropsType$a {
+    className?: string;
+    /**
+     * th와 td의 align
+     */
+    align?: "left" | "center" | "right";
+    /**
+     * td, td가 갖는 고유 id로써 className에 반영
+     */
+    fieldId: string;
+    /**
+     * 랜더될 자식 컴포넌트
+     */
+    children: ReactNode;
+    /**
+     * th에 들어갈 내용
+     */
+    label?: ReactElement | string;
+    /**
+     * th와 td의 width 값
+     */
+    size?: number | string;
+    /**
+     * 소팅에 사용될 값
+     */
+    sortValue?: string | number;
+    /**
+     * th와 td에 반영될 rowSpan
+     */
+    rowSpan?: number;
+    /**
+     * th와 td에 반영될 colSpan
+     */
+    colSpan?: number;
+    /**
+     * th에 반영될 colSpan
+     */
+    thColSpan?: number;
+    /**
+     * th에 반영될 rowSpan
+     */
+    thRowSpan?: number;
+    /**
+     * TdExpend 컴포넌트의 expend 상태를 바꾸도록 하는 td로 정할지 여부
+     */
+    expend?: boolean;
+    /**
+     * 특정 행의 TdExpend 컴포넌트의 expend 상태 값
+     */
+    expendOpen?: boolean;
+    /**
+     * 특정 열의 소팅 순서
+     */
+    order?: "asc" | "desc" | "";
+    /**
+     * th를 눌러 소팅을 했을때 호출되는 함수
+     */
+    handleClickSort?: (params: {
+        index: number;
+        fieldId: string;
+        order: "desc" | "asc" | "";
+    }) => Promise<void> | void;
+    /**
+     * expend 상태를 toggle 하는 함수
+     */
+    handleExpendToggle?: (status: boolean) => void;
+    /**
+     * 특정 행의 TdExpend 컴포넌트의 expend 상태가 true가 되기 전에 호출되는 함수
+     */
+    beforeExpendOpen?: () => void;
+    /**
+     * td 태그를 클릭했을때 호출되는 함수
+     */
+    onClick?: (e: MouseEvent<HTMLTableCellElement>) => void;
+}
+/**
+ * `TdColumn` 컴포넌트는 테이블의 열을 구성하는데 사용되며, 다양한 설정을 통해 커스터마이징이 가능합니다.
+ *
+ * @component
+ * @param {Object} props 컴포넌트에 전달되는 속성들
+ * @param {string} [props.className] - 컴포넌트에 추가할 CSS 클래스 이름
+ * @param {string} props.fieldId - td와 th에 고유하게 적용될 id. 또한 className에도 반영됩니다.
+ * @param {ReactNode} props.children - 컴포넌트 내부에 렌더될 자식 요소들
+ * @param {ReactElement|string} [props.label] - th 태그 내에 표시될 내용
+ * @param {number|string} [props.size] - th와 td 태그의 너비 값
+ * @param {string|number} [props.sortValue] - 소팅 기능에 사용될 값
+ * @param {number} [props.rowSpan] - th와 td 태그에 적용될 rowSpan 값
+ * @param {number} [props.colSpan] - th와 td 태그에 적용될 colSpan 값
+ * @param {number} [props.thColSpan] - th 태그에만 적용될 colSpan 값
+ * @param {number} [props.thRowSpan] - th 태그에만 적용될 rowSpan 값
+ * @param {boolean} [props.expend] - TdExpend 컴포넌트의 확장 상태를 변경할 td로 설정할지 여부
+ * @param {boolean} [props.expendOpen] - 특정 행의 TdExpend 컴포넌트 확장 상태 값
+ * @param {'asc'|'desc'|''} [props.order] - 특정 열의 소팅 순서
+ * @param {Function} [props.handleClickSort] - th를 클릭하여 소팅을 실행했을 때 호출되는 함수.
+ * @param {Function} [props.handleExpendToggle] - expend 상태를 토글하는 함수
+ * @param {Function} [props.onClick] - td 태그를 클릭했을 때 호출되는 함수
+ */
+declare const RBTdColumn: {
+    ({ className, children, align, fieldId, size, colSpan, rowSpan, expend, expendOpen, handleExpendToggle, onClick, }: PropsType$a): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PropsType$9 {
+    /**
+     * 클래스 이름
+     */
+    className?: string;
+    /**
+     * 자식 요소
+     */
+    children: ReactElement | string;
+    /**
+     * 스타일
+     */
+    style?: CSSProperties;
+}
+/**
+ * `Table` 컴포넌트에서 아코디언 UI를 지원하는 컴포넌트
+ * @component
+ * @param {string} [props.className] - 클래스 이름
+ * @param {ReactElement | string} props.children - 자식 요소
+ */
+declare const RBTdExpend: {
+    ({ className, children, style }: PropsType$9): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const badgeTypes: readonly ["number", "capsule", "soft", "transparent"];
+type BadgeType = (typeof badgeTypes)[number];
+declare const badgeNumberVariants: readonly ["solid", "soft", "outlined", "ghost"];
+type BadgeNumberVariant = (typeof badgeNumberVariants)[number];
+declare const badgeColors: readonly ["red", "orange", "green", "blue", "purple", "gray", "gray-subtle"];
+type BadgeColor = (typeof badgeColors)[number];
+declare const badgeRootVariants: (props?: {
+    type?: "number" | "transparent" | "soft" | "capsule";
+} & class_variance_authority_types.ClassProp) => string;
+type BadgeVariantProps = VariantProps<typeof badgeRootVariants>;
+
+interface PropsType$8 {
+    className?: string;
+    /** badge 타입 */
+    type?: BadgeType;
+    /**
+     * number 타입의 스타일
+     * - `type="number"`일 때만 적용
+     */
+    numberVariant?: BadgeNumberVariant;
+    /**
+     * capsule, transparent 타입의 color
+     */
+    color?: BadgeColor;
+    /** transparent 타입에서 사용하는 leading icon */
+    leadingIcon?: ReactNode;
+    /** 표시할 내용 */
+    children?: ReactNode;
+}
+/**
+ * RBBadge는 Number / Tag 형태의 배지 UI를 제공합니다.
+ */
+declare function RBBadge({ className, type, numberVariant, color, leadingIcon, children, }: PropsType$8): react_jsx_runtime.JSX.Element;
+
+declare const emptyViewTypes: readonly ["button", "icon"];
+type EmptyViewType = (typeof emptyViewTypes)[number];
+declare const emptyViewRootVariants: (props?: class_variance_authority_types.ClassProp) => string;
+type EmptyViewVariantProps = VariantProps<typeof emptyViewRootVariants>;
+
+interface PropsType$7 {
+    className?: string;
+    /** EmptyView 타입 (button | icon) */
+    type?: EmptyViewType;
+    /** 안내 문구 */
+    message?: ReactNode;
+    /** 보조 설명 문구 */
+    description?: ReactNode;
+    /** button 타입일 때 표시할 버튼 라벨 */
+    buttonLabel?: ReactNode;
+    /** button 타입일 때 버튼 클릭 핸들러 */
+    onButtonClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+    /** icon 타입일 때 표시할 아이콘 */
+    icon?: ReactNode;
+}
+/**
+ * RBEmptyView는 데이터가 비어있는 상태에서 안내 문구와 액션을 표시하는 컴포넌트입니다.
+ */
+declare function RBEmptyView({ className, type, message, description, buttonLabel, onButtonClick, icon, }: PropsType$7): react_jsx_runtime.JSX.Element;
+
+interface PropsType$6 {
+    className?: string;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    required?: boolean;
+    children?: React.ReactNode;
+}
+/** 입력 필드의 라벨과 부가 설명을 표시하는 컴포넌트 */
+declare function RBTextLabel({ className, label, description, required, children, }: PropsType$6): react_jsx_runtime.JSX.Element;
+
+interface PropsType$5 {
+    className?: string;
+    labelClassName?: string;
+    helperClassName?: string;
+    label?: ReactNode;
+    description?: ReactNode;
+    required?: boolean;
+    helperText?: ReactNode;
+    helperTone?: HelperTone;
+    children?: ReactNode;
+}
+declare function RBTextField({ className, labelClassName, helperClassName, label, description, required, helperText, helperTone, children, }: PropsType$5): react_jsx_runtime.JSX.Element;
+
+type MultiRangeInputForwardRef = {
+    focus: (options?: FocusOptions) => void;
+};
+type Props$4 = {
+    className?: string;
+    /** 최소값 */
+    min: number;
+    /** 최대값 */
+    max: number;
+    /** 값 변경 크기 */
+    step?: number;
+    /** thumb 사이즈 */
+    thumbSize?: number;
+    /** slider 높이 */
+    sliderHeight?: number;
+    /** thumb 테두리 색상 */
+    thumbBorderColor?: CSSProperties["borderColor"];
+    /** thumb 색상 */
+    thumbColor?: CSSProperties["backgroundColor"];
+    /** track 색상 */
+    trackColor?: CSSProperties["backgroundColor"];
+    /** range 색상 */
+    rangeColor?: CSSProperties["backgroundColor"];
+    /** 텍스트 입력 영역 표시 여부 */
+    showTextInput?: boolean;
+    /**
+     * handleChange 두번째 인자로 전달될 name 값
+     */
+    name?: string;
+    /**
+     * 바인딩할 데이터 값
+     */
+    value?: number[];
+    /**
+     * disabled
+     */
+    disabled?: boolean;
+    /**
+     * 값이 변경될 때 호출될 함수 (첫번째 인자는 [0, 100]과 같이 배열로 전달)
+     */
+    handleChange?: (value: AllowAny, name: string) => void;
+    /** 값이 변경될 때 호출될 함수 (이벤트를 인자로 하여 호출) */
+    onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+/**
+ * `MultiRangeInput`은 최소값과 최대값을 지정할 수 있게 하는 컴포넌트 입니다.
+ */
+declare const MultiRangeInput: React$1.ForwardRefExoticComponent<Props$4 & React$1.RefAttributes<MultiRangeInputForwardRef>>;
+
+type RbJoyStickEventData = {
+    /** 조이스틱의 상태 */
+    type: "start" | "move" | "end" | "none";
+    /** 포인터 이벤트 */
+    event: PointerEvent | React.PointerEvent<HTMLDivElement>;
+    /** 조이스틱, 조이스틱 영역, 스틱 요소 */
+    targets: {
+        joystick: HTMLDivElement;
+        stickArea: HTMLDivElement;
+        stick: HTMLDivElement;
+    };
+    /** 스틱의 거리 (조이스틱 중심점에서 1px단위의 스틱의 이동거리) */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /**
+     * 스틱의 정규화된 이동 정도
+     * (조이스틱 중심점(0)에서 -1 ~ 1사이로 정규화된 스틱의 이동정도)
+     * */
+    normalizedDistance: {
+        x: number;
+        y: number;
+    };
+    /** 스틱의 회전 */
+    rotate: {
+        radian: number;
+        degree: number;
+    };
+    /** 스틱의 시작 위치 */
+    startPosition: {
+        x: number;
+        y: number;
+    };
+    /** 스틱의 방향 */
+    direction: {
+        x: "left" | "right" | "center";
+        y: "top" | "bottom" | "center";
+    };
+    time: number;
+};
+type Props$3 = {
+    className?: string;
+    /** 조이스틱의 컨트롤 타입 */
+    type?: "direction" | "curved";
+    /** 조이스틱의 크기 */
+    size?: number;
+    /** 스틱의 색상 */
+    stickColor?: string;
+    /** 조이스틱 영역의 색상 */
+    stickAreaColor?: string;
+    /**
+     * 스로틀 임계치
+     * (이동 비율 차이가 throttleThreshold 이상일 때 onMove 호출)
+     *
+     * range: 0 ~ 1 (ex. 0.05 = 5%)
+     * */
+    throttleThreshold?: number;
+    /**
+     * 스로틀 시간
+     */
+    throttleDuration?: number;
+    /** X축 이동 제한 */
+    xOnly?: boolean;
+    /** Y축 이동 제한 */
+    yOnly?: boolean;
+    /** 대각선 이동 비활성화 */
+    disableDiagonal?: boolean;
+    /** 비활성화 */
+    disabled?: boolean;
+    /** 마우스 move 이벤트 멈춰도 onMove 이벤트 호출 지속적으로 호출할 시간 */
+    keepMoveEventInterval?: number;
+    /** 조이스틱 영역 패딩 크기 */
+    paddingSize?: number;
+    /** 조이스틱 컨테이너 스타일 */
+    style?: CSSProperties;
+    /** 조이스틱 시작 시 호출 */
+    onStart?: (data: RbJoyStickEventData) => void;
+    /** 조이스틱 이동 시 호출 */
+    onMove?: (data: RbJoyStickEventData) => void;
+    /** 조이스틱 종료 시 호출 */
+    onEnd?: (data: RbJoyStickEventData) => void;
+};
+declare const RBJoyStick: ({ className, type, size, stickColor, stickAreaColor, throttleThreshold, throttleDuration, xOnly, yOnly, disableDiagonal, disabled, keepMoveEventInterval, paddingSize, style, onStart, onMove, onEnd, }: Props$3) => react_jsx_runtime.JSX.Element;
+
+type PlaceType = "top" | "right" | "bottom" | "left";
+interface PropsType$4 {
+    className?: string;
+    /**
+     * 툴팁 UI를 사용할 요소의 id값
+     */
+    anchorId: string;
+    /**
+     * 툴팁의 넓이
+     *
+     * `default: 200` — 숫자(px) 또는 `"max-content"` 같은 CSS 문자열 모두 가능
+     */
+    width?: number | string;
+    /**
+     * 툴팁 UI가 나올 위치
+     */
+    place?: PlaceType;
+    /**
+     * 툴팁 UI를 작동시킬 이벤트 종류
+     */
+    events?: ("hover" | "click")[];
+    /**
+     * 툴팁의 arrow 요소의 x 또는 y축 이동값
+     *
+     * `place`가 `top` | `bottom` 일 경우 x축, `left` | `right` 일 경우 y축
+     */
+    arrowPosition?: number;
+    /**
+     * 툴팁의 위치 조정 값
+     */
+    tooltipPosition?: {
+        top?: number;
+        left?: number;
+    };
+    /**
+     * 툴팁의 배경 색상
+     */
+    tooltipColor?: CSSProperties["color"];
+    /**
+     * 툴팁의 텍스트 색상
+     */
+    tooltipTextColor?: CSSProperties["color"];
+    /**
+     * 툴팁의 박스 스타일 (ex: '0 0 6px #ddd')
+     */
+    tooltipBoxShadow?: CSSProperties["boxShadow"];
+    /**
+     * 툴팁의 박스 border-radius
+     */
+    tooltipBorderRadius?: CSSProperties["borderRadius"];
+    /**
+     * arrow UI 숨김 처리 여부
+     */
+    hideArrow?: boolean;
+    /**
+     * 툴팁 UI를 사용할 요소와의 간격
+     */
+    space?: number;
+    /**
+     * 툴팁 UI를 노출 상태를 강제로 정하고 고정할 수 있는 값
+     */
+    open?: boolean;
+    /**
+     * 스크롤시 툴팁이 닫히게 할지 여부
+     */
+    whenWindowScrollClose?: boolean;
+    /**
+     * 툴팁 UI안에 랜더링 할 내용
+     */
+    children: ReactNode | string;
+}
+/**
+ * `Tooltip` 컴포넌트는 사용자 인터페이스에 추가 정보를 제공하는 데 사용됩니다.
+ * 해당 요소에 마우스를 올리거나 클릭할 때 툴팁 UI가 나타납니다.
+ */
+declare const RBTooltip: ({ className, anchorId, width, space, place, events, arrowPosition, hideArrow, tooltipPosition, tooltipColor, tooltipTextColor, tooltipBoxShadow, tooltipBorderRadius, open, whenWindowScrollClose, children, }: PropsType$4) => react_jsx_runtime.JSX.Element;
+
+declare const cardRootVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+declare const cardHeaderVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+declare const cardHeaderTextVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+declare const cardTitleVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+declare const cardContentVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+declare const cardFooterVariants: (props?: {
+    size?: "sm" | "md";
+} & class_variance_authority_types.ClassProp) => string;
+type CardVariantProps = VariantProps<typeof cardRootVariants>;
+type CardHeaderVariantProps = VariantProps<typeof cardHeaderVariants>;
+type CardHeaderTextVariantProps = VariantProps<typeof cardHeaderTextVariants>;
+type CardTitleVariantProps = VariantProps<typeof cardTitleVariants>;
+type CardContentVariantProps = VariantProps<typeof cardContentVariants>;
+type CardFooterVariantProps = VariantProps<typeof cardFooterVariants>;
+
+type RBCardProps = React$1.ComponentProps<"div"> & CardVariantProps;
+type RBCardPreviewSlotProps = React$1.ComponentProps<"div">;
+type RBCardHeaderProps = React$1.ComponentProps<"div"> & CardHeaderVariantProps;
+type RBCardHeaderTextProps = React$1.ComponentProps<"div"> & CardHeaderTextVariantProps;
+type RBCardTitleProps = React$1.ComponentProps<"div"> & CardTitleVariantProps;
+type RBCardContentProps = React$1.ComponentProps<"div"> & CardContentVariantProps;
+type RBCardFooterProps = React$1.ComponentProps<"div"> & CardFooterVariantProps;
+declare function RBCard({ className, size, ...props }: RBCardProps): react_jsx_runtime.JSX.Element;
+declare function RBCardHeader({ className, size, ...props }: RBCardHeaderProps): react_jsx_runtime.JSX.Element;
+declare function RBCardHeaderText({ className, size, ...props }: RBCardHeaderTextProps): react_jsx_runtime.JSX.Element;
+declare function RBCardTitle({ className, size, ...props }: RBCardTitleProps): react_jsx_runtime.JSX.Element;
+declare function RBCardDescription({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBCardAction({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function RBCardPreviewSlot({ className, ...props }: RBCardPreviewSlotProps): react_jsx_runtime.JSX.Element;
+declare function RBCardContent({ className, size, ...props }: RBCardContentProps): react_jsx_runtime.JSX.Element;
+declare function RBCardFooter({ className, size, ...props }: RBCardFooterProps): react_jsx_runtime.JSX.Element;
+
+declare function ShadDialog({ ...props }: React$1.ComponentProps<typeof ShadDialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
+
+declare function RBCommand({ className, ...props }: React.ComponentProps<typeof Command>): react_jsx_runtime.JSX.Element;
+declare function RBCommandDialog({ title, description, children, ...props }: React.ComponentProps<typeof ShadDialog> & {
+    title?: string;
+    description?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function RBCommandInput({ className, ...props }: React.ComponentProps<typeof Command.Input>): react_jsx_runtime.JSX.Element;
+declare function RBCommandList({ className, ...props }: React.ComponentProps<typeof Command.List>): react_jsx_runtime.JSX.Element;
+declare function RBCommandEmpty({ className, ...props }: React.ComponentProps<typeof Command.Empty>): react_jsx_runtime.JSX.Element;
+declare function RBCommandGroup({ className, ...props }: React.ComponentProps<typeof Command.Group>): react_jsx_runtime.JSX.Element;
+declare function RBCommandItem({ className, ...props }: React.ComponentProps<typeof Command.Item>): react_jsx_runtime.JSX.Element;
+declare function RBCommandSeparator({ className, ...props }: React.ComponentProps<typeof Command.Separator>): react_jsx_runtime.JSX.Element;
+declare function RBCommandShortcut({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function RBCommandSelected({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+
+declare const RBPopoverPlacements: readonly ["top-left", "top-center", "top-right", "right-top", "right-center", "right-bottom", "bottom-right", "bottom-center", "bottom-left", "left-bottom", "left-center", "left-top"];
+type RBPopoverPlacement = (typeof RBPopoverPlacements)[number];
+type RBPopoverContentProps = Omit<React.ComponentProps<typeof PopoverPrimitive.Content>, "side" | "align"> & {
+    place?: RBPopoverPlacement;
+    arrow?: boolean;
+};
+
+declare function RBPopover(props: React.ComponentProps<typeof PopoverPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function RBPopoverTrigger(props: React.ComponentProps<typeof PopoverPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function RBPopoverAnchor(props: React.ComponentProps<typeof PopoverPrimitive.Anchor>): react_jsx_runtime.JSX.Element;
+declare function RBPopoverContent({ className, place, sideOffset, collisionPadding, arrow, children, ...props }: RBPopoverContentProps): react_jsx_runtime.JSX.Element;
+
+declare function RBDropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function RBDropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function RBDropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function RBDropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
+declare const RBDropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const RBDropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type DropdownItemVariant = "default" | "destructive";
+declare const RBDropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    variant?: DropdownItemVariant;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBDropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function RBDropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+
+declare function RBMenubar({ className, ...props }: React.ComponentProps<typeof ShadMenubarPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare const RBMenubarMenu: {
+    (props: ShadMenubarPrimitive.MenubarMenuProps & {
+        __scopeMenubar?: _radix_ui_react_context.Scope;
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const RBMenubarGroup: React$1.ForwardRefExoticComponent<ShadMenubarPrimitive.MenubarGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarPortal: React$1.FC<ShadMenubarPrimitive.MenubarPortalProps>;
+declare const RBMenubarRadioGroup: React$1.ForwardRefExoticComponent<ShadMenubarPrimitive.MenubarRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarSub: React$1.FC<ShadMenubarPrimitive.MenubarSubProps>;
+declare const RBMenubarTrigger: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const RBMenubarContent: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type MenubarItemVariant = "default" | "destructive";
+declare const RBMenubarItem: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    variant?: MenubarItemVariant;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarCheckboxItem: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarRadioItem: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarLabel: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarSeparator: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarSubTrigger: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const RBMenubarSubContent: React$1.ForwardRefExoticComponent<Omit<ShadMenubarPrimitive.MenubarSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function RBMenubarShortcut({ className, ...props }: React.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+
+type RBSliderProps = React.ComponentProps<typeof ShadSliderPrimitive.Root> & {
+    trackClassName?: string;
+    rangeClassName?: string;
+    thumbClassName?: string;
+};
+declare function RBSlider({ className, defaultValue, value, min, max, disabled, trackClassName, rangeClassName, thumbClassName, ...props }: RBSliderProps): react_jsx_runtime.JSX.Element;
+
+type SwitchTone = "default" | "disabled" | "invalid";
+type SwitchSize = "default" | "sm";
+type RBSwitchProps = Omit<React.ComponentProps<typeof SwitchPrimitive.Root>, "type"> & {
+    invalid?: boolean;
+    size?: SwitchSize;
+};
+declare function RBSwitch({ className, disabled, invalid, size, ...props }: RBSwitchProps): react_jsx_runtime.JSX.Element;
+
+type SwitchType = "default" | "box";
+type SwitchControlPlacement = "start" | "end";
+interface PropsType$3 {
+    children: ReactElement<RBSwitchProps>;
+    className?: string;
+    controlPlacement?: SwitchControlPlacement;
+    description?: React.ReactNode;
+    descriptionClassName?: string;
+    invalid?: boolean;
+    label?: React.ReactNode;
+    labelClassName?: string;
+    size?: SwitchSize;
+    type?: SwitchType;
+}
+declare function RBSwitchField({ children, className, controlPlacement, description, descriptionClassName, invalid, label, labelClassName, size, type, }: PropsType$3): react_jsx_runtime.JSX.Element;
+
+declare const toggleRootVariants: (props?: {
+    size?: "sm" | "lg" | "default";
+    variant?: "default" | "outline";
+} & class_variance_authority_types.ClassProp) => string;
+type ToggleVariantProps = VariantProps<typeof toggleRootVariants>;
+
+type RBToggleProps = React.ComponentProps<typeof TogglePrimitive.Root> & ToggleVariantProps;
+declare function RBToggle({ className, size, variant, ...props }: RBToggleProps): react_jsx_runtime.JSX.Element;
+
+type ToggleGroupOrientation = "horizontal" | "vertical";
+type RBToggleGroupProps = ComponentProps<typeof ToggleGroupPrimitive.Root> & {
+    /** 그룹 방향 */
+    orientation?: ToggleGroupOrientation;
+    /** 아이템 간격 분리 여부 */
+    separated?: boolean;
+    /** 아이템 균등 너비 여부 */
+    stretched?: boolean;
+};
+type RBToggleGroupItemProps = ComponentProps<typeof ToggleGroupPrimitive.Item> & {
+    icon?: ReactNode;
+};
+declare function RBToggleGroup({ className, children, orientation, separated, stretched, ...props }: RBToggleGroupProps): react_jsx_runtime.JSX.Element;
+declare function RBToggleGroupItem({ className, children, icon, ...props }: RBToggleGroupItemProps): react_jsx_runtime.JSX.Element;
+
+type TabsSize = "xs" | "sm";
+type TabsVariant = "default" | "line";
+type RBTabsProps = ComponentProps<typeof TabsPrimitive.Root> & {
+    size?: TabsSize;
+    variant?: TabsVariant;
+};
+type RBTabsListProps = ComponentProps<typeof TabsPrimitive.List>;
+type RBTabsTriggerProps = ComponentProps<typeof TabsPrimitive.Trigger> & {
+    icon?: ReactNode;
+    badge?: ReactNode;
+};
+type RBTabsContentProps = ComponentProps<typeof TabsPrimitive.Content>;
+declare function RBTabs({ className, orientation, size, variant, ...props }: RBTabsProps): react_jsx_runtime.JSX.Element;
+declare function RBTabsList({ className, ...props }: RBTabsListProps): react_jsx_runtime.JSX.Element;
+declare function RBTabsTrigger({ className, disabled, children, icon, badge, ...props }: RBTabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare function RBTabsContent({ className, ...props }: RBTabsContentProps): react_jsx_runtime.JSX.Element;
+
+type RBResizableProps = ComponentProps<typeof ResizablePrimitive.PanelGroup>;
+type RBResizablePanelProps = ComponentProps<typeof ResizablePrimitive.Panel> & {
+    unstyled?: boolean;
+};
+type RBResizableHandleProps = ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    hideThumb?: boolean;
+};
+declare function RBResizable({ className, direction, ...props }: RBResizableProps): react_jsx_runtime.JSX.Element;
+declare function RBResizablePanel({ className, unstyled, ...props }: RBResizablePanelProps): react_jsx_runtime.JSX.Element;
+declare function RBResizableHandle({ className, hideThumb, onPointerDownCapture, onPointerUpCapture, onPointerCancelCapture, ...props }: RBResizableHandleProps): react_jsx_runtime.JSX.Element;
+
+declare function Calendar({ classNames, showOutsideDays, ...props }: React.ComponentProps<typeof DayPicker>): react_jsx_runtime.JSX.Element;
+
+interface PropsType$2 {
+    label: string;
+    onClick?: () => void;
+}
+declare function RBDatePickerPreset({ label, onClick }: PropsType$2): react_jsx_runtime.JSX.Element;
+
+interface DatePickerTimeValue {
+    hour: string;
+    minute: string;
+}
+interface PropsType$1 {
+    pickerType?: DatePickerType;
+    setTimeEnabled?: boolean;
+    startTime?: DatePickerTimeValue;
+    endTime?: DatePickerTimeValue;
+    onEndTimeChange?: (nextValue: DatePickerTimeValue) => void;
+    onSetTimeChange?: (checked: boolean) => void;
+    onStartTimeChange?: (nextValue: DatePickerTimeValue) => void;
+    selectedDate?: {
+        from: Date | undefined;
+        to: Date | undefined;
+    };
+    setSelectedDate?: (nextValue: {
+        from: Date | undefined;
+        to: Date | undefined;
+    }) => void;
+    enforceTimeOrder?: boolean;
+    min?: number;
+    max?: number;
+    labels?: {
+        from?: string;
+        to?: string;
+        setTime?: string;
+    };
+}
+declare function RBDatePickerFooterTime({ pickerType, setTimeEnabled, startTime, endTime, onEndTimeChange, onSetTimeChange, onStartTimeChange, selectedDate, setSelectedDate, enforceTimeOrder, labels, }: PropsType$1): react_jsx_runtime.JSX.Element;
+
+interface PropsType {
+    className?: string;
+    onCancel: () => void;
+    onConfirm: () => void;
+    onReset: () => void;
+    labels?: {
+        reset?: string;
+        cancel?: string;
+        confirm?: string;
+    };
+}
+declare function RBDatePickerFooterButton({ className, onCancel, onConfirm, onReset, labels, }: PropsType): react_jsx_runtime.JSX.Element;
+
+declare const checkLabelButtonVariants: (props?: {
+    size?: "xs" | "xs2" | "sm" | "md";
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+
+declare const checkIconButtonVariants: (props?: {
+    size?: "xs" | "xs2" | "sm" | "md";
+    disabled?: boolean;
+} & class_variance_authority_types.ClassProp) => string;
+
+declare const SvgAMR: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowArcLeftBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowArcRightBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowCounterClockwiseBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowDownBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowLeftBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowMove: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowRightBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowUpBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowsInSimpleBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowsLeftRightBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgArrowsOutSimpleBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgBackspace: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgBoardSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgBugBeetleSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgBulletSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCalendarBlankBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCameraBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCameraResetBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCaretDownSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCaretLeftSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCaretRightSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCaretUpDownSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCaretUpSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChargingBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChargingSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCheckCircle: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCheckedBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronDownBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronLeftBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronLeftEndBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronRightBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronRightEndBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgChevronUpBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCircleDashedBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCircleProgressBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCircleX: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCircleXSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgClipboardBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgClock: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCodeSimpleBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgComplete: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCopyBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgDangerSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgDesktopBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgDeviceMobileSlashBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgDotsSix: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgEraserBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgEyeSlashBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgEyeBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFileArrowDownBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFlagBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFlagSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFloppyDiskBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFloppyDiskRegular: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFlowArrow: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFolderOpenBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgFolderOpenRegular: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgGlobe: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgGpsFixBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgHighlighterBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgImportBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgImportPreviewBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgInfoSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgInformationRegular: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgJoystickBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgLightningSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgListChecksBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgLockOpenSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgLockSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgLogSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMagnifyingGlassMinusBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMagnifyingGlassPlusBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMapPinBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMapPinSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMapBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMapSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMapping: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMinusBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMonitorBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMoon: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgMoveSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgNavigationArrowBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgNavigationArrowSoild: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgNode: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgNotePencilBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPathBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPauseBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPauseSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPencilSimpleBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPlayBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPlaySolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPlusBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPointCloudSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPopupMoveJ: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgPopupMoveL: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgProgramSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgQrCodeRegular: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgRecording: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgReturn: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgRobotArmBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgRotateLeft: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgRotateRight: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgScissorsBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSearchBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSettingBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSettingSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgShapesSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSignIn: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSignOut: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSkipForwardBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgStateASC: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgStateDESC: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgStopBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgStopSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgSun: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgTopViewBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgTopologyBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgTrashBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgTurnLeft: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgUserBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgUserSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWarning: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWarningCircle: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWarningSolid: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWifi: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWifiNone: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgXBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgBot: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeBack: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeBottom: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeFront: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeLeft: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeRight: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgCubeTop: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgUsb: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWand: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWifiBold: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const SvgWifiCog: (props?: React__default.SVGAttributes<SVGSVGElement> & {
+    title?: string;
+    description?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const index_SvgAMR: typeof SvgAMR;
+declare const index_SvgArrowArcLeftBold: typeof SvgArrowArcLeftBold;
+declare const index_SvgArrowArcRightBold: typeof SvgArrowArcRightBold;
+declare const index_SvgArrowCounterClockwiseBold: typeof SvgArrowCounterClockwiseBold;
+declare const index_SvgArrowDownBold: typeof SvgArrowDownBold;
+declare const index_SvgArrowLeftBold: typeof SvgArrowLeftBold;
+declare const index_SvgArrowMove: typeof SvgArrowMove;
+declare const index_SvgArrowRightBold: typeof SvgArrowRightBold;
+declare const index_SvgArrowUpBold: typeof SvgArrowUpBold;
+declare const index_SvgArrowsInSimpleBold: typeof SvgArrowsInSimpleBold;
+declare const index_SvgArrowsLeftRightBold: typeof SvgArrowsLeftRightBold;
+declare const index_SvgArrowsOutSimpleBold: typeof SvgArrowsOutSimpleBold;
+declare const index_SvgBackspace: typeof SvgBackspace;
+declare const index_SvgBoardSolid: typeof SvgBoardSolid;
+declare const index_SvgBot: typeof SvgBot;
+declare const index_SvgBugBeetleSolid: typeof SvgBugBeetleSolid;
+declare const index_SvgBulletSolid: typeof SvgBulletSolid;
+declare const index_SvgCalendarBlankBold: typeof SvgCalendarBlankBold;
+declare const index_SvgCameraBold: typeof SvgCameraBold;
+declare const index_SvgCameraResetBold: typeof SvgCameraResetBold;
+declare const index_SvgCaretDownSolid: typeof SvgCaretDownSolid;
+declare const index_SvgCaretLeftSolid: typeof SvgCaretLeftSolid;
+declare const index_SvgCaretRightSolid: typeof SvgCaretRightSolid;
+declare const index_SvgCaretUpDownSolid: typeof SvgCaretUpDownSolid;
+declare const index_SvgCaretUpSolid: typeof SvgCaretUpSolid;
+declare const index_SvgChargingBold: typeof SvgChargingBold;
+declare const index_SvgChargingSolid: typeof SvgChargingSolid;
+declare const index_SvgCheckCircle: typeof SvgCheckCircle;
+declare const index_SvgCheckedBold: typeof SvgCheckedBold;
+declare const index_SvgChevronDownBold: typeof SvgChevronDownBold;
+declare const index_SvgChevronLeftBold: typeof SvgChevronLeftBold;
+declare const index_SvgChevronLeftEndBold: typeof SvgChevronLeftEndBold;
+declare const index_SvgChevronRightBold: typeof SvgChevronRightBold;
+declare const index_SvgChevronRightEndBold: typeof SvgChevronRightEndBold;
+declare const index_SvgChevronUpBold: typeof SvgChevronUpBold;
+declare const index_SvgCircleDashedBold: typeof SvgCircleDashedBold;
+declare const index_SvgCircleProgressBold: typeof SvgCircleProgressBold;
+declare const index_SvgCircleX: typeof SvgCircleX;
+declare const index_SvgCircleXSolid: typeof SvgCircleXSolid;
+declare const index_SvgClipboardBold: typeof SvgClipboardBold;
+declare const index_SvgClock: typeof SvgClock;
+declare const index_SvgCodeSimpleBold: typeof SvgCodeSimpleBold;
+declare const index_SvgComplete: typeof SvgComplete;
+declare const index_SvgCopyBold: typeof SvgCopyBold;
+declare const index_SvgCubeBack: typeof SvgCubeBack;
+declare const index_SvgCubeBottom: typeof SvgCubeBottom;
+declare const index_SvgCubeFront: typeof SvgCubeFront;
+declare const index_SvgCubeLeft: typeof SvgCubeLeft;
+declare const index_SvgCubeRight: typeof SvgCubeRight;
+declare const index_SvgCubeTop: typeof SvgCubeTop;
+declare const index_SvgDangerSolid: typeof SvgDangerSolid;
+declare const index_SvgDesktopBold: typeof SvgDesktopBold;
+declare const index_SvgDeviceMobileSlashBold: typeof SvgDeviceMobileSlashBold;
+declare const index_SvgDotsSix: typeof SvgDotsSix;
+declare const index_SvgEraserBold: typeof SvgEraserBold;
+declare const index_SvgEyeBold: typeof SvgEyeBold;
+declare const index_SvgEyeSlashBold: typeof SvgEyeSlashBold;
+declare const index_SvgFileArrowDownBold: typeof SvgFileArrowDownBold;
+declare const index_SvgFlagBold: typeof SvgFlagBold;
+declare const index_SvgFlagSolid: typeof SvgFlagSolid;
+declare const index_SvgFloppyDiskBold: typeof SvgFloppyDiskBold;
+declare const index_SvgFloppyDiskRegular: typeof SvgFloppyDiskRegular;
+declare const index_SvgFlowArrow: typeof SvgFlowArrow;
+declare const index_SvgFolderOpenBold: typeof SvgFolderOpenBold;
+declare const index_SvgFolderOpenRegular: typeof SvgFolderOpenRegular;
+declare const index_SvgGlobe: typeof SvgGlobe;
+declare const index_SvgGpsFixBold: typeof SvgGpsFixBold;
+declare const index_SvgHighlighterBold: typeof SvgHighlighterBold;
+declare const index_SvgImportBold: typeof SvgImportBold;
+declare const index_SvgImportPreviewBold: typeof SvgImportPreviewBold;
+declare const index_SvgInfoSolid: typeof SvgInfoSolid;
+declare const index_SvgInformationRegular: typeof SvgInformationRegular;
+declare const index_SvgJoystickBold: typeof SvgJoystickBold;
+declare const index_SvgLightningSolid: typeof SvgLightningSolid;
+declare const index_SvgListChecksBold: typeof SvgListChecksBold;
+declare const index_SvgLockOpenSolid: typeof SvgLockOpenSolid;
+declare const index_SvgLockSolid: typeof SvgLockSolid;
+declare const index_SvgLogSolid: typeof SvgLogSolid;
+declare const index_SvgMagnifyingGlassMinusBold: typeof SvgMagnifyingGlassMinusBold;
+declare const index_SvgMagnifyingGlassPlusBold: typeof SvgMagnifyingGlassPlusBold;
+declare const index_SvgMapBold: typeof SvgMapBold;
+declare const index_SvgMapPinBold: typeof SvgMapPinBold;
+declare const index_SvgMapPinSolid: typeof SvgMapPinSolid;
+declare const index_SvgMapSolid: typeof SvgMapSolid;
+declare const index_SvgMapping: typeof SvgMapping;
+declare const index_SvgMinusBold: typeof SvgMinusBold;
+declare const index_SvgMonitorBold: typeof SvgMonitorBold;
+declare const index_SvgMoon: typeof SvgMoon;
+declare const index_SvgMoveSolid: typeof SvgMoveSolid;
+declare const index_SvgNavigationArrowBold: typeof SvgNavigationArrowBold;
+declare const index_SvgNavigationArrowSoild: typeof SvgNavigationArrowSoild;
+declare const index_SvgNode: typeof SvgNode;
+declare const index_SvgNotePencilBold: typeof SvgNotePencilBold;
+declare const index_SvgPathBold: typeof SvgPathBold;
+declare const index_SvgPauseBold: typeof SvgPauseBold;
+declare const index_SvgPauseSolid: typeof SvgPauseSolid;
+declare const index_SvgPencilSimpleBold: typeof SvgPencilSimpleBold;
+declare const index_SvgPlayBold: typeof SvgPlayBold;
+declare const index_SvgPlaySolid: typeof SvgPlaySolid;
+declare const index_SvgPlusBold: typeof SvgPlusBold;
+declare const index_SvgPointCloudSolid: typeof SvgPointCloudSolid;
+declare const index_SvgPopupMoveJ: typeof SvgPopupMoveJ;
+declare const index_SvgPopupMoveL: typeof SvgPopupMoveL;
+declare const index_SvgProgramSolid: typeof SvgProgramSolid;
+declare const index_SvgQrCodeRegular: typeof SvgQrCodeRegular;
+declare const index_SvgRecording: typeof SvgRecording;
+declare const index_SvgReturn: typeof SvgReturn;
+declare const index_SvgRobotArmBold: typeof SvgRobotArmBold;
+declare const index_SvgRotateLeft: typeof SvgRotateLeft;
+declare const index_SvgRotateRight: typeof SvgRotateRight;
+declare const index_SvgScissorsBold: typeof SvgScissorsBold;
+declare const index_SvgSearchBold: typeof SvgSearchBold;
+declare const index_SvgSettingBold: typeof SvgSettingBold;
+declare const index_SvgSettingSolid: typeof SvgSettingSolid;
+declare const index_SvgShapesSolid: typeof SvgShapesSolid;
+declare const index_SvgSignIn: typeof SvgSignIn;
+declare const index_SvgSignOut: typeof SvgSignOut;
+declare const index_SvgSkipForwardBold: typeof SvgSkipForwardBold;
+declare const index_SvgStateASC: typeof SvgStateASC;
+declare const index_SvgStateDESC: typeof SvgStateDESC;
+declare const index_SvgStopBold: typeof SvgStopBold;
+declare const index_SvgStopSolid: typeof SvgStopSolid;
+declare const index_SvgSun: typeof SvgSun;
+declare const index_SvgTopViewBold: typeof SvgTopViewBold;
+declare const index_SvgTopologyBold: typeof SvgTopologyBold;
+declare const index_SvgTrashBold: typeof SvgTrashBold;
+declare const index_SvgTurnLeft: typeof SvgTurnLeft;
+declare const index_SvgUsb: typeof SvgUsb;
+declare const index_SvgUserBold: typeof SvgUserBold;
+declare const index_SvgUserSolid: typeof SvgUserSolid;
+declare const index_SvgWand: typeof SvgWand;
+declare const index_SvgWarning: typeof SvgWarning;
+declare const index_SvgWarningCircle: typeof SvgWarningCircle;
+declare const index_SvgWarningSolid: typeof SvgWarningSolid;
+declare const index_SvgWifi: typeof SvgWifi;
+declare const index_SvgWifiBold: typeof SvgWifiBold;
+declare const index_SvgWifiCog: typeof SvgWifiCog;
+declare const index_SvgWifiNone: typeof SvgWifiNone;
+declare const index_SvgXBold: typeof SvgXBold;
+declare namespace index {
+  export {
+    index_SvgAMR as SvgAMR,
+    index_SvgArrowArcLeftBold as SvgArrowArcLeftBold,
+    index_SvgArrowArcRightBold as SvgArrowArcRightBold,
+    index_SvgArrowCounterClockwiseBold as SvgArrowCounterClockwiseBold,
+    index_SvgArrowDownBold as SvgArrowDownBold,
+    index_SvgArrowLeftBold as SvgArrowLeftBold,
+    index_SvgArrowMove as SvgArrowMove,
+    index_SvgArrowRightBold as SvgArrowRightBold,
+    index_SvgArrowUpBold as SvgArrowUpBold,
+    index_SvgArrowsInSimpleBold as SvgArrowsInSimpleBold,
+    index_SvgArrowsLeftRightBold as SvgArrowsLeftRightBold,
+    index_SvgArrowsOutSimpleBold as SvgArrowsOutSimpleBold,
+    index_SvgBackspace as SvgBackspace,
+    index_SvgBoardSolid as SvgBoardSolid,
+    index_SvgBot as SvgBot,
+    index_SvgBugBeetleSolid as SvgBugBeetleSolid,
+    index_SvgBulletSolid as SvgBulletSolid,
+    index_SvgCalendarBlankBold as SvgCalendarBlankBold,
+    index_SvgCameraBold as SvgCameraBold,
+    index_SvgCameraResetBold as SvgCameraResetBold,
+    index_SvgCaretDownSolid as SvgCaretDownSolid,
+    index_SvgCaretLeftSolid as SvgCaretLeftSolid,
+    index_SvgCaretRightSolid as SvgCaretRightSolid,
+    index_SvgCaretUpDownSolid as SvgCaretUpDownSolid,
+    index_SvgCaretUpSolid as SvgCaretUpSolid,
+    index_SvgChargingBold as SvgChargingBold,
+    index_SvgChargingSolid as SvgChargingSolid,
+    index_SvgCheckCircle as SvgCheckCircle,
+    index_SvgCheckedBold as SvgCheckedBold,
+    index_SvgChevronDownBold as SvgChevronDownBold,
+    index_SvgChevronLeftBold as SvgChevronLeftBold,
+    index_SvgChevronLeftEndBold as SvgChevronLeftEndBold,
+    index_SvgChevronRightBold as SvgChevronRightBold,
+    index_SvgChevronRightEndBold as SvgChevronRightEndBold,
+    index_SvgChevronUpBold as SvgChevronUpBold,
+    index_SvgCircleDashedBold as SvgCircleDashedBold,
+    index_SvgCircleProgressBold as SvgCircleProgressBold,
+    index_SvgCircleX as SvgCircleX,
+    index_SvgCircleXSolid as SvgCircleXSolid,
+    index_SvgClipboardBold as SvgClipboardBold,
+    index_SvgClock as SvgClock,
+    index_SvgCodeSimpleBold as SvgCodeSimpleBold,
+    index_SvgComplete as SvgComplete,
+    index_SvgCopyBold as SvgCopyBold,
+    index_SvgCubeBack as SvgCubeBack,
+    index_SvgCubeBottom as SvgCubeBottom,
+    index_SvgCubeFront as SvgCubeFront,
+    index_SvgCubeLeft as SvgCubeLeft,
+    index_SvgCubeRight as SvgCubeRight,
+    index_SvgCubeTop as SvgCubeTop,
+    index_SvgDangerSolid as SvgDangerSolid,
+    index_SvgDesktopBold as SvgDesktopBold,
+    index_SvgDeviceMobileSlashBold as SvgDeviceMobileSlashBold,
+    index_SvgDotsSix as SvgDotsSix,
+    index_SvgEraserBold as SvgEraserBold,
+    index_SvgEyeBold as SvgEyeBold,
+    index_SvgEyeSlashBold as SvgEyeSlashBold,
+    index_SvgFileArrowDownBold as SvgFileArrowDownBold,
+    index_SvgFlagBold as SvgFlagBold,
+    index_SvgFlagSolid as SvgFlagSolid,
+    index_SvgFloppyDiskBold as SvgFloppyDiskBold,
+    index_SvgFloppyDiskRegular as SvgFloppyDiskRegular,
+    index_SvgFlowArrow as SvgFlowArrow,
+    index_SvgFolderOpenBold as SvgFolderOpenBold,
+    index_SvgFolderOpenRegular as SvgFolderOpenRegular,
+    index_SvgGlobe as SvgGlobe,
+    index_SvgGpsFixBold as SvgGpsFixBold,
+    index_SvgHighlighterBold as SvgHighlighterBold,
+    index_SvgImportBold as SvgImportBold,
+    index_SvgImportPreviewBold as SvgImportPreviewBold,
+    index_SvgInfoSolid as SvgInfoSolid,
+    index_SvgInformationRegular as SvgInformationRegular,
+    index_SvgJoystickBold as SvgJoystickBold,
+    index_SvgLightningSolid as SvgLightningSolid,
+    index_SvgListChecksBold as SvgListChecksBold,
+    index_SvgLockOpenSolid as SvgLockOpenSolid,
+    index_SvgLockSolid as SvgLockSolid,
+    index_SvgLogSolid as SvgLogSolid,
+    index_SvgMagnifyingGlassMinusBold as SvgMagnifyingGlassMinusBold,
+    index_SvgMagnifyingGlassPlusBold as SvgMagnifyingGlassPlusBold,
+    index_SvgMapBold as SvgMapBold,
+    index_SvgMapPinBold as SvgMapPinBold,
+    index_SvgMapPinSolid as SvgMapPinSolid,
+    index_SvgMapSolid as SvgMapSolid,
+    index_SvgMapping as SvgMapping,
+    index_SvgMinusBold as SvgMinusBold,
+    index_SvgMonitorBold as SvgMonitorBold,
+    index_SvgMoon as SvgMoon,
+    index_SvgMoveSolid as SvgMoveSolid,
+    index_SvgNavigationArrowBold as SvgNavigationArrowBold,
+    index_SvgNavigationArrowSoild as SvgNavigationArrowSoild,
+    index_SvgNode as SvgNode,
+    index_SvgNotePencilBold as SvgNotePencilBold,
+    index_SvgPathBold as SvgPathBold,
+    index_SvgPauseBold as SvgPauseBold,
+    index_SvgPauseSolid as SvgPauseSolid,
+    index_SvgPencilSimpleBold as SvgPencilSimpleBold,
+    index_SvgPlayBold as SvgPlayBold,
+    index_SvgPlaySolid as SvgPlaySolid,
+    index_SvgPlusBold as SvgPlusBold,
+    index_SvgPointCloudSolid as SvgPointCloudSolid,
+    index_SvgPopupMoveJ as SvgPopupMoveJ,
+    index_SvgPopupMoveL as SvgPopupMoveL,
+    index_SvgProgramSolid as SvgProgramSolid,
+    index_SvgQrCodeRegular as SvgQrCodeRegular,
+    index_SvgRecording as SvgRecording,
+    index_SvgReturn as SvgReturn,
+    index_SvgRobotArmBold as SvgRobotArmBold,
+    index_SvgRotateLeft as SvgRotateLeft,
+    index_SvgRotateRight as SvgRotateRight,
+    index_SvgScissorsBold as SvgScissorsBold,
+    index_SvgSearchBold as SvgSearchBold,
+    index_SvgSettingBold as SvgSettingBold,
+    index_SvgSettingSolid as SvgSettingSolid,
+    index_SvgShapesSolid as SvgShapesSolid,
+    index_SvgSignIn as SvgSignIn,
+    index_SvgSignOut as SvgSignOut,
+    index_SvgSkipForwardBold as SvgSkipForwardBold,
+    index_SvgStateASC as SvgStateASC,
+    index_SvgStateDESC as SvgStateDESC,
+    index_SvgStopBold as SvgStopBold,
+    index_SvgStopSolid as SvgStopSolid,
+    index_SvgSun as SvgSun,
+    index_SvgTopViewBold as SvgTopViewBold,
+    index_SvgTopologyBold as SvgTopologyBold,
+    index_SvgTrashBold as SvgTrashBold,
+    index_SvgTurnLeft as SvgTurnLeft,
+    index_SvgUsb as SvgUsb,
+    index_SvgUserBold as SvgUserBold,
+    index_SvgUserSolid as SvgUserSolid,
+    index_SvgWand as SvgWand,
+    index_SvgWarning as SvgWarning,
+    index_SvgWarningCircle as SvgWarningCircle,
+    index_SvgWarningSolid as SvgWarningSolid,
+    index_SvgWifi as SvgWifi,
+    index_SvgWifiBold as SvgWifiBold,
+    index_SvgWifiCog as SvgWifiCog,
+    index_SvgWifiNone as SvgWifiNone,
+    index_SvgXBold as SvgXBold,
+  };
+}
+
+declare const lightColors: readonly ["red", "gray", "blue", "green", "orange", "yellow"];
+type LightColor = (typeof lightColors)[number];
+declare const lightSizes: readonly ["sm", "md", "lg"];
+type LightSize = (typeof lightSizes)[number];
+declare const lightRootVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    color?: "blue" | "gray" | "green" | "orange" | "red" | "yellow";
+} & class_variance_authority_types.ClassProp) => string;
+type LightVariantProps = VariantProps<typeof lightRootVariants>;
+
+interface LightProps {
+    className?: string;
+    color?: LightColor;
+    size?: LightSize;
+}
+declare function RBLight({ className, color, size }: LightProps): react_jsx_runtime.JSX.Element;
+
+type Props$2 = {
+    className?: string;
+    borderClassName?: string;
+    pathClassName?: string;
+    /** Spinner 컴포넌트의 width, height 크기 */
+    size?: CSSProperties["width"] | CSSProperties["height"];
+    style?: CSSProperties;
+};
+/**
+ * `Spinner` 컴포넌트는 로딩 상태를 나타내는 indicator UI를 제공하는 컴포넌트 입니다.
+ * 색상은 text 색상을 설정하시면 자동으로 적용됩니다.
+ *
+ * 원하시는 사이즈가 있으신 경우 size 프로퍼티나 style, className 프로퍼티로 설정하시면 됩니다.
+ *
+ * @param {string} [props.className] 컴포넌트에 추가될 CSS 클래스명
+ * @param {number} [props.size] Spinner 컴포넌트의 width, height 크기
+ * @param {CSSProperties} [props.style] Spinner 컴포넌트의 style
+ * @returns
+ */
+declare const RBSpinner: ({ className, borderClassName, pathClassName, size, style, }: Props$2) => react_jsx_runtime.JSX.Element;
+
+declare const ToastPositions: readonly ["top-center", "top-left", "top-right", "bottom-center", "bottom-left", "bottom-right"];
+type ToastPosition = (typeof ToastPositions)[number];
+declare const ToastVariants: readonly ["default", "copy", "danger", "warning", "caution", "success"];
+type ToastVariant = (typeof ToastVariants)[number];
+declare const ToastTypes: readonly ["basic", "alert"];
+type ToastType = (typeof ToastTypes)[number];
+/**
+ * toast.openToast 에 전달되는 기본 토스트 데이터
+ */
+type ToastItem = {
+    /** 토스트 고유 id */
+    id: string;
+    /** 제목 영역 */
+    title?: string | ReactElement;
+    /** 본문 메시지 */
+    content?: string | ReactElement;
+    /** 비교용으로 쓸 본문 메세지 */
+    strContent?: string;
+    /** 제목/본문 앞에 노출할 아이콘 */
+    icon?: ReactElement;
+    /** 액션 버튼 라벨 */
+    actionLabel?: string | ReactElement;
+    /** 액션 버튼 클릭 시 실행할 함수 */
+    handleActionClick?: () => void;
+    /** 액션 버튼 클릭 뒤 토스트를 닫을지 여부 */
+    closeOnActionClick?: boolean;
+    /** 토스트 스타일 variant */
+    variant?: ToastVariant;
+    /** 토스트 타입 */
+    type?: ToastType;
+    /** 토스트 노출 위치 */
+    position?: ToastPosition;
+    /** 자동 닫힘 시간(ms) */
+    duration?: number;
+    /** 토스트 닫힘 시 실행할 함수 */
+    onClose?: (id: string) => void;
+};
+/**
+ * 실제 toast component 가 받는 내부 props
+ */
+interface ToastComponentProps extends ToastItem {
+    /** 열림/닫힘 상태 */
+    open: boolean;
+    /** 현재 위치 그룹에서의 순서 */
+    toastOrder?: number;
+    /** 현재 위치 그룹의 전체 토스트 개수 */
+    toastCount?: number;
+    /** 토스트 영역 hover 여부 */
+    isWrapperMouseOver?: boolean;
+    /** 현재 스택이 펼쳐진 상태인지 여부 */
+    isStackExpanded?: boolean;
+    /** 자동 닫힘 타이머 일시정지 */
+    pauseTimer?: () => void;
+    /** 자동 닫힘 타이머 재개 */
+    resumeTimer?: () => void;
+    /** 접힌 스택을 펼쳐 달라고 요청 */
+    requestStackExpand?: () => void;
+    /** 토스트 닫기 */
+    closeToast?: (force?: boolean) => void;
+}
+
+type Props$1 = ToastComponentProps & {
+    className?: string;
+};
+declare const RBSimpleToast: ({ className, open, type, variant, title, content, icon: customIcon, actionLabel, handleActionClick, closeOnActionClick, position, toastCount, isWrapperMouseOver, isStackExpanded, pauseTimer, resumeTimer, requestStackExpand, closeToast, }: Props$1) => react_jsx_runtime.JSX.Element;
+
+interface Props extends ModalPropsType<string> {
+    className?: string;
 }
-export interface RbTextInputEventProps {
-    onInput?: (event: RbTextInputEvent) => void;
+declare const RBQrBarCodeGuideModal: ({ className, open, resolve, onOpenChange, }: Props) => react_jsx_runtime.JSX.Element;
+
+interface PluginUIServices {
+    alert: (params: {
+        title?: string;
+        message: string;
+        buttonText?: string;
+    }) => Promise<void>;
+    confirm: (params: {
+        title?: string;
+        message: string;
+        buttonText?: {
+            yes: string;
+            no: string;
+        };
+    }) => Promise<boolean>;
+    prompt: (params: {
+        title?: string;
+        message: string;
+        value?: string;
+        placeholder?: string;
+        buttonText?: {
+            yes: string;
+            no: string;
+        };
+    }) => Promise<string | undefined>;
+    toast: (params: {
+        title?: string;
+        message: string | ReactElement;
+        type?: "info" | "danger" | "warning" | "caution" | "success";
+        actionLabel?: string;
+        handleActionClick?: () => void;
+        closeOnActionClick?: boolean;
+        duration?: number;
+        onClose?: () => void;
+    }) => void;
 }
-export interface RbSwitchEventProps {
-    onChange?: (event: RbSwitchChangeEvent) => void;
+
+interface WsHandle {
+    undeclare(): void;
 }
-export interface RbSelectEventProps {
-    onChange?: (event: RbSelectChangeEvent) => void;
+type WsSubscriber = WsHandle;
+type WsQueryable = WsHandle;
+
+interface RbSdk {
+    /**
+     * Publish JSON payload to a topic.
+     * "sensor/data" → {pluginId}/sensor/data
+     * "/broadcast/x" → broadcast/x  (absolute)
+     */
+    pub: <P = any>(topic: string, payload: P) => Promise<void>;
+    /** Subscribe to a topic. Returns a handle with undeclare(). */
+    sub: <P = any>(topic: string, handler: (payload: P) => void) => Promise<WsSubscriber>;
+    /**
+     * Send a request and await the first reply (Zenoh query).
+     * Use this to call a backend handler registered with rb.serve() / ZenohRouter.
+     */
+    action: <R = any, P = any>(topic: string, payload?: P) => Promise<R>;
+    /**
+     * Register a queryable — the frontend responds to backend queries.
+     * Mirror of rb.action() on the other side.
+     */
+    serve: <P = any, R = any>(topic: string, handler: (payload?: P) => R | Promise<R>) => Promise<WsQueryable>;
+    /** Show a transient notification through the host's toast system. */
+    toast: PluginUIServices["toast"];
+    /** Show a host alert dialog. */
+    alert: PluginUIServices["alert"];
+    /** Show a host confirm dialog. Resolves true/false. */
+    confirm: PluginUIServices["confirm"];
+    /** Show a host prompt dialog. Resolves the entered value, or undefined if cancelled. */
+    prompt: PluginUIServices["prompt"];
+    /**
+     * Host-provided initial data for this mount — e.g. the previously-saved
+     * values when the host re-opens a form. `undefined` for a fresh mount.
+     * Prefer the `useRbFormData()` hook over reading this directly.
+     */
+    data?: unknown;
+    /**
+     * Register a getter the host calls (synchronously) to collect this plugin's
+     * save payload — e.g. when the host's Save button is clicked. The returned
+     * value must be JSON-serialisable (the host persists it). Returns an
+     * unregister fn. Prefer the `useRbSave()` hook.
+     */
+    onSave: (getPayload: () => unknown) => () => void;
 }
-export declare const Slider: RemoteElementComponent<RbSliderElement, RbSliderProps, RbSliderEventProps>;
-export declare const Button: RemoteElementComponent<RbButtonElement, RbButtonProps, RbPressEventProps>;
-export declare const IconButton: RemoteElementComponent<RbIconButtonElement, RbIconButtonProps, RbPressEventProps>;
-export declare const Text: RemoteElementComponent<RbTextElement, RbTextProps>;
-export declare const TextInput: RemoteElementComponent<RbTextInputElement, RbTextInputProps, RbTextInputEventProps>;
-export declare const Switch: RemoteElementComponent<RbSwitchElement, RbSwitchProps, RbSwitchEventProps>;
-export declare const Select: RemoteElementComponent<RbSelectElement, RbSelectProps, RbSelectEventProps>;
-export { useRb } from "./sdk";
-export type { RbSdk, RbNotifyType } from "./sdk";
-export type { RbSelectOption } from "./elements";
-//# sourceMappingURL=react.d.ts.map
+/** Access the host SDK from within a plugin component. */
+declare function useRb(): RbSdk;
+/**
+ * Read the host-provided initial data for this mount (e.g. previously-saved
+ * form values). `undefined` for a fresh mount.
+ *
+ *   const saved = useRbFormData<MyArgs>();
+ *   const methods = useForm({ defaultValues: saved ?? DEFAULTS });
+ */
+declare function useRbFormData<T = unknown>(): T | undefined;
+/**
+ * Register a getter the host calls to collect this plugin's save payload when
+ * the host's Save is clicked. The latest `getPayload` is always used, so it can
+ * close over current state. The returned value must be JSON-serialisable.
+ *
+ *   useRbSave(() => ({ args: getValues(), summary: buildSummary() }));
+ */
+declare function useRbSave<T = unknown>(getPayload: () => T): void;
+
+export { RBSelectOption as Option, Accordion as RBAccordion, AccordionGroup as RBAccordionGroup, RBAlert, RBBadge, RBBattery, Calendar as RBCalendar, RBCard, RBCardAction, RBCardContent, RBCardDescription, RBCardFooter, RBCardHeader, RBCardHeaderText, RBCardPreviewSlot, RBCardTitle, CheckBox as RBCheckBox, RBCheckIconButton, RBCheckLabelButton, RBChipItem, RBChipTab, RBChipsBoxItem, RBChipsBoxTab, RBCommand, RBCommandDialog, RBCommandEmpty, RBCommandGroup, RBCommandInput, RBCommandItem, RBCommandList, RBCommandSelected, RBCommandSeparator, RBCommandShortcut, RBConfirm, DateInput as RBDateInput, RBDatePickerFooterButton, RBDatePickerFooterTime, RBDatePickerPreset, RBDialog, RBDialogClose, RBDialogContent, RBDialogDescription, RBDialogFooter, RBDialogHeader, RBDialogOverlay, RBDialogPortal, RBDialogTitle, RBDialogTrigger, RBDim, RBDivider, RBDrawer, RBDrawerBody, RBDrawerClose, RBDrawerContent, RBDrawerDescription, RBDrawerFooter, RBDrawerHeader, RBDrawerOverlay, RBDrawerPortal, RBDrawerTitle, RBDrawerTrigger, RBDropdownMenu, RBDropdownMenuCheckboxItem, RBDropdownMenuContent, RBDropdownMenuGroup, RBDropdownMenuItem, RBDropdownMenuLabel, RBDropdownMenuPortal, RBDropdownMenuRadioGroup, RBDropdownMenuRadioItem, RBDropdownMenuSeparator, RBDropdownMenuShortcut, RBDropdownMenuSub, RBDropdownMenuSubContent, RBDropdownMenuSubTrigger, RBDropdownMenuTrigger, RBEmptyView, RBIconButton, index as RBIcons, RBInlineLabelButton, RBJoyStick, RBLabelButton, RBLight, RBMenubar, RBMenubarCheckboxItem, RBMenubarContent, RBMenubarGroup, RBMenubarItem, RBMenubarLabel, RBMenubarMenu, RBMenubarPortal, RBMenubarRadioGroup, RBMenubarRadioItem, RBMenubarSeparator, RBMenubarShortcut, RBMenubarSub, RBMenubarSubContent, RBMenubarSubTrigger, RBMenubarTrigger, RBModal, MultiRangeInput as RBMultiRangeInput, RBNoData, RBPagination, RBPopover, RBPopoverAnchor, RBPopoverContent, RBPopoverPlacements, RBPopoverTrigger, RBPrompt, RBQrBarCodeGuideModal, RBRadioBox, RBRadioButton, RangeDateInput as RBRangeDateInput, RBResizable, RBResizableHandle, RBResizablePanel, RBResizable as RBResizablePanelGroup, RBSelectBox, RBSelectDropBox, RBSelectOption, RBSheet, RBSheetClose, RBSheetContent, RBSheetDescription, RBSheetFooter, RBSheetHeader, RBSheetOverlay, RBSheetPortal, RBSheetTitle, RBSheetTrigger, SideNumberInput as RBSideNumberInput, RBSimpleToast, RBSlider, RBSpinner, RBSwitch, RBSwitchField, RBTab, RBTabItem, RBTable, RBTableRow, RBTabs, RBTabsContent, RBTabsList, RBTabsTrigger, RBTdColumn, RBTdExpend, RBTextArea, RBTextField, RBTextHelperText, RBTextInput, RBTextLabel, RBToggle, RBToggleGroup, RBToggleGroupItem, RBTooltip, accordionVariants, badgeRootVariants, batteryFillVariants, cardRootVariants, checkBoxRootVariants, checkIconButtonVariants, checkLabelButtonVariants, chipRootVariants, dividerVariants, emptyViewRootVariants, iconButtonVariants, inlineLabelButtonVariants, labelButtonVariants, lightColors, lightSizes, radioRootVariants, selectTriggerVariants, sideNumberInputVariants, tabRootVariants, textAreaVariants, textInputVariants, useRb, useRbFormData, useRbSave };
+export type { PropsType$r as AccordionProps, AccordionVariantProps, PropsType$8 as BadgeProps, BadgeVariantProps, BatteryProps, BatteryVariantProps, CardVariantProps, Props$h as CheckBoxProps, CheckBoxVariantProps, Props$g as CheckIconButtonProps, PropsType$f as ChipItemProps, PropsType$g as ChipTabProps, ChipVariantProps, PropsType$d as ChipsBoxItemProps, PropsType$e as ChipsBoxTabProps, Props$d as DateInputProps, PropsType as DatePickerFooterButtonProps, PropsType$2 as DatePickerPresetProps, DatePickerTimeValue, PropsType$o as DimProps, DividerProps, DividerVariantProps, DrawerSide, DropdownItemVariant, PropsType$7 as EmptyViewProps, EmptyViewVariantProps, PropsType$9 as ExpendProps, HelperTone, IconButtonProps, IconButtonVariantProps, InlineLabelButtonProps, InlineLabelButtonVariantProps, Props$3 as JoyStickProps, LabelButtonProps, LabelButtonVariantProps, LightProps, LightVariantProps, MenubarItemVariant, Props$4 as MultiRangeInputProps, Props$7 as PaginationProps, Props$b as RBAlertProps, RBCardContentProps, RBCardFooterProps, RBCardHeaderProps, RBCardHeaderTextProps, RBCardPreviewSlotProps, RBCardProps, RBCardTitleProps, Props$a as RBConfirmProps, RBDialogContentProps, RBDrawerContentProps, RBDrawerProps, RBPopoverContentProps, RBPopoverPlacement, Props$9 as RBPromptProps, PropsType$j as RBRadioBoxProps, RBResizableHandleProps, RBResizablePanelProps, RBResizableProps, PropsType$n as RBSelectBoxProps, RBSelectBoxRef, RBSheetContentProps, Props$1 as RBSimpleToastProps, RBSliderProps, PropsType$3 as RBSwitchFieldProps, RBSwitchProps, RBTabsContentProps, RBTabsListProps, RBTabsProps, RBTabsTriggerProps, Props$e as RBTextAreaProps, RBToggleGroupItemProps, RBToggleGroupProps, RBToggleProps, Props$5 as RadioButtonProps, RadioVariantProps, Props$c as RangeDateInputProps, RbJoyStickEventData, RbSdk, PropsType$m as SelectOptionProps, SelectTriggerVariantProps, SheetSide, Props$6 as SideNumberInputProps, SideNumberInputVariantProps, SwitchControlPlacement, SwitchSize, SwitchTone, SwitchType, PropsType$h as TabItemProps, PropsType$i as TabProps, TabVariantProps, PropsType$c as TableProps, PropsType$b as TableRowProps, TabsSize, TabsVariant, PropsType$a as TdColumnProps, TextAreaVariantProps, PropsType$5 as TextFieldProps, PropsType$p as TextHelperTextProps, PropsType$q as TextInputProps, TextInputVariantProps, PropsType$6 as TextLabelProps, ToggleGroupOrientation, ToggleVariantProps, PropsType$4 as TooltipProps };