@996-design/996-ui 0.1.0

package/dist/types/components/DataEntryPrimitives.d.ts

@@ -0,0 +1,454 @@
+import type { DefaultOptionType as RcCascaderDefaultOptionType, CascaderProps as RcCascaderProps } from "@rc-component/cascader";
+import type { PanelProps as RcCascaderPanelProps } from "@rc-component/cascader/es/Panel";
+import type { MentionsProps as RcMentionsProps } from "@rc-component/mentions";
+import type { PickerRef, PickerProps as RcPickerProps, RangePickerProps as RcRangePickerProps } from "@rc-component/picker";
+import type { GenerateConfig } from "@rc-component/picker/generate";
+import type { PickerMode, RangePickerRef, Locale as RcPickerLocale } from "@rc-component/picker/interface";
+import type { BaseOptionType as RcSelectBaseOptionType, SelectProps as RcSelectProps } from "@rc-component/select";
+import type { TreeSelectProps as RcTreeSelectProps } from "@rc-component/tree-select";
+import RcUpload from "@rc-component/upload";
+import type { RcFile, UploadProps as RcUploadProps } from "@rc-component/upload";
+import { type Dayjs } from "dayjs";
+import type { CSSProperties, ComponentRef, DragEvent, HTMLAttributes, ReactElement, ReactNode, RefAttributes } from "react";
+import { type InputSize, type InputStatus, type InputVariant } from "./Input";
+export interface SelectOption extends RcSelectBaseOptionType {
+    readonly disabled?: boolean;
+    readonly label: ReactNode;
+    readonly value: string | number;
+}
+type SelectVisualProps = {
+    readonly rootClassName?: string;
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly variant?: InputVariant;
+};
+export interface SelectProps<ValueType = unknown, OptionType extends RcSelectBaseOptionType = SelectOption> extends Omit<RcSelectProps<ValueType, OptionType>, "onPopupVisibleChange" | "options" | "prefixCls">, SelectVisualProps {
+    /** @deprecated Use onOpenChange instead. */
+    readonly onDropdownVisibleChange?: (open: boolean) => void;
+    readonly onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use onOpenChange instead. */
+    readonly onPopupVisibleChange?: (open: boolean) => void;
+    readonly options?: readonly OptionType[];
+}
+declare function InternalSelect<ValueType = unknown, OptionType extends RcSelectBaseOptionType = SelectOption>({ className, disabled, getPopupContainer, onDropdownVisibleChange, onOpenChange, onPopupVisibleChange, options, rootClassName, size, status, suffix, suffixIcon, variant, ...props }: SelectProps<ValueType, OptionType>): import("react").JSX.Element;
+export declare const Select: typeof InternalSelect & {
+    OptGroup: import("@rc-component/select/lib/OptGroup").OptionGroupFC;
+    Option: import("@rc-component/select/lib/Option").OptionFC;
+};
+export interface AutoCompleteOption extends SelectOption {
+    readonly description?: ReactNode;
+}
+export interface AutoCompleteProps<ValueType = string, OptionType extends RcSelectBaseOptionType = AutoCompleteOption> extends Omit<SelectProps<ValueType, OptionType>, "labelInValue" | "loading" | "mode" | "optionLabelProp" | "options" | "showSearch"> {
+    readonly options?: readonly OptionType[];
+    readonly showSearch?: RcSelectProps<ValueType, OptionType>["showSearch"];
+}
+declare function InternalAutoComplete<ValueType = string, OptionType extends RcSelectBaseOptionType = AutoCompleteOption>({ defaultOpen, defaultValue, className, disabled, filterOption, getPopupContainer, onChange, onDropdownVisibleChange, onOpenChange, onPopupVisibleChange, onSelect, open, optionRender, options, rootClassName, showSearch, size, status, suffix, suffixIcon, value, variant, ...props }: AutoCompleteProps<ValueType, OptionType>): import("react").JSX.Element;
+export declare const AutoComplete: typeof InternalAutoComplete & {
+    Option: import("@rc-component/select/lib/Option").OptionFC;
+};
+export interface CascaderOption extends RcCascaderDefaultOptionType {
+    children?: CascaderOption[];
+    readonly disabled?: boolean;
+    readonly label: ReactNode;
+    readonly value: string | number;
+}
+export interface CascaderProps<OptionType extends RcCascaderDefaultOptionType = CascaderOption, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean = false> extends Omit<RcCascaderProps<OptionType, ValueField, Multiple>, "checkable" | "onPopupVisibleChange" | "options" | "prefixCls">, SelectVisualProps {
+    readonly multiple?: Multiple;
+    /** @deprecated Use onOpenChange instead. */
+    readonly onDropdownVisibleChange?: (open: boolean) => void;
+    readonly onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use onOpenChange instead. */
+    readonly onPopupVisibleChange?: (open: boolean) => void;
+    readonly options?: readonly OptionType[];
+}
+declare function InternalCascader<OptionType extends RcCascaderDefaultOptionType = CascaderOption, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean = false>({ className, disabled, getPopupContainer, multiple, onDropdownVisibleChange, onOpenChange, onPopupVisibleChange, options, rootClassName, size, status, suffix, suffixIcon, variant, ...props }: CascaderProps<OptionType, ValueField, Multiple>): import("react").JSX.Element;
+export type CascaderPanelProps<OptionType extends RcCascaderDefaultOptionType = CascaderOption, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean = false> = Omit<RcCascaderPanelProps<OptionType, ValueField, Multiple>, "checkable" | "prefixCls"> & {
+    readonly multiple?: Multiple;
+    readonly rootClassName?: string;
+};
+declare function CascaderPanel<OptionType extends RcCascaderDefaultOptionType = CascaderOption, ValueField extends keyof OptionType = keyof OptionType, Multiple extends boolean = false>({ className, direction, disabled, multiple, notFoundContent, rootClassName, ...props }: CascaderPanelProps<OptionType, ValueField, Multiple>): import("react").JSX.Element;
+export declare const Cascader: typeof InternalCascader & {
+    readonly Panel: typeof CascaderPanel;
+    readonly SHOW_CHILD: "SHOW_CHILD";
+    readonly SHOW_PARENT: "SHOW_PARENT";
+};
+export type PickerValue = Dayjs | Date | string;
+type PickerInputValue<ValueType, Multiple extends boolean> = Multiple extends true ? readonly ValueType[] : ValueType;
+type PickerOutputValue<Multiple extends boolean> = Multiple extends true ? Dayjs[] : Dayjs;
+type PickerStringValue<Multiple extends boolean> = Multiple extends true ? string[] : string;
+export type DatePickerProps<ValueType extends PickerValue = PickerValue, Multiple extends boolean = false> = Omit<RcPickerProps<Dayjs>, "defaultValue" | "generateConfig" | "locale" | "multiple" | "onChange" | "prefixCls" | "rootClassName" | "value"> & SelectVisualProps & {
+    readonly defaultValue?: PickerInputValue<ValueType, Multiple> | null;
+    readonly locale?: RcPickerLocale;
+    readonly multiple?: Multiple;
+    readonly onChange?: (value: PickerOutputValue<Multiple> | null, dateString: PickerStringValue<Multiple>) => void;
+    readonly value?: PickerInputValue<ValueType, Multiple> | null;
+};
+export type PickerRangeValue = readonly [
+    PickerValue | null | undefined,
+    PickerValue | null | undefined
+];
+export interface RangePickerProps extends Omit<RcRangePickerProps<Dayjs>, "defaultValue" | "generateConfig" | "locale" | "onChange" | "prefixCls" | "rootClassName" | "value">, SelectVisualProps {
+    readonly defaultValue?: PickerRangeValue;
+    readonly locale?: RcPickerLocale;
+    readonly onChange?: (value: [Dayjs | null, Dayjs | null] | null, dateString: [string, string]) => void;
+    readonly value?: PickerRangeValue | null;
+}
+type DayjsPickerComponent = <ValueType extends PickerValue = PickerValue, Multiple extends boolean = false>(props: DatePickerProps<ValueType, Multiple> & RefAttributes<PickerRef>) => ReactElement;
+export type GeneratedDatePickerProps<DateType extends object> = Omit<RcPickerProps<DateType>, "generateConfig" | "locale" | "prefixCls" | "rootClassName"> & SelectVisualProps & {
+    readonly locale?: RcPickerLocale;
+};
+export type GeneratedRangePickerProps<DateType extends object> = Omit<RcRangePickerProps<DateType>, "generateConfig" | "locale" | "prefixCls" | "rootClassName"> & SelectVisualProps & {
+    readonly locale?: RcPickerLocale;
+};
+export declare function generatePicker<DateType extends object>(generateConfig: GenerateConfig<DateType>): import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+    readonly locale?: RcPickerLocale;
+} & RefAttributes<PickerRef>> & {
+    MonthPicker: import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<PickerRef>>;
+    QuarterPicker: import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<PickerRef>>;
+    RangePicker: import("react").ForwardRefExoticComponent<Omit<RcRangePickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<RangePickerRef>>;
+    TimePicker: import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<PickerRef>>;
+    WeekPicker: import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<PickerRef>>;
+    YearPicker: import("react").ForwardRefExoticComponent<Omit<RcPickerProps<DateType>, "locale" | "prefixCls" | "rootClassName" | "generateConfig"> & SelectVisualProps & {
+        readonly locale?: RcPickerLocale;
+    } & RefAttributes<PickerRef>>;
+};
+export type TimePickerProps<ValueType extends PickerValue = PickerValue, Multiple extends boolean = false> = Omit<DatePickerProps<ValueType, Multiple>, "picker" | "showTime"> & {
+    /** @deprecated Use renderExtraFooter instead. */
+    readonly addon?: () => ReactNode;
+    /** @deprecated Use onCalendarChange instead. */
+    readonly onSelect?: (value: Dayjs) => void;
+};
+type TimePickerComponent = <ValueType extends PickerValue = PickerValue, Multiple extends boolean = false>(props: TimePickerProps<ValueType, Multiple> & RefAttributes<PickerRef>) => ReactElement;
+export type TimeRangePickerProps = Omit<RangePickerProps, "picker" | "showTime">;
+export declare const DatePicker: DayjsPickerComponent & {
+    MonthPicker: DayjsPickerComponent;
+    QuarterPicker: DayjsPickerComponent;
+    RangePicker: import("react").ForwardRefExoticComponent<RangePickerProps & {
+        readonly fixedPicker?: PickerMode;
+    } & RefAttributes<RangePickerRef>>;
+    TimePicker: TimePickerComponent;
+    WeekPicker: DayjsPickerComponent;
+    YearPicker: DayjsPickerComponent;
+    generatePicker: typeof generatePicker;
+};
+export declare const TimePicker: TimePickerComponent & {
+    RangePicker: import("react").ForwardRefExoticComponent<TimeRangePickerProps & RefAttributes<RangePickerRef>>;
+};
+type RcMentionsOption = NonNullable<RcMentionsProps["options"]>[number];
+export interface MentionsOption extends RcMentionsOption {
+    readonly disabled?: boolean;
+    readonly label?: ReactNode;
+    readonly value: string;
+}
+export interface MentionsProps extends Omit<RcMentionsProps, "options" | "prefixCls">, SelectVisualProps {
+    readonly options?: readonly MentionsOption[];
+}
+export interface MentionsConfig {
+    readonly prefix?: string | readonly string[];
+    readonly split?: string;
+}
+export interface MentionsEntity {
+    readonly prefix: string;
+    readonly value: string;
+}
+declare function getMentions(value?: string, config?: MentionsConfig): MentionsEntity[];
+declare function InternalMentions({ className, disabled, getPopupContainer, options, rootClassName, size, status, variant, ...props }: MentionsProps): import("react").JSX.Element;
+export declare const Mentions: typeof InternalMentions & {
+    getMentions: typeof getMentions;
+    Option: import("react").FC<import("@rc-component/mentions/lib/Option").OptionProps>;
+};
+export type TransferDirection = "left" | "right";
+export type TransferKey = React.Key;
+export interface TransferItem {
+    description?: ReactNode;
+    disabled?: boolean;
+    key?: TransferKey;
+    title?: ReactNode;
+    [name: string]: unknown;
+}
+export interface TransferRenderResultObject {
+    readonly label: ReactNode;
+    readonly value: string;
+}
+export type TransferRenderResult = ReactNode | TransferRenderResultObject;
+export interface TransferSearchOption {
+    readonly defaultValue?: string;
+    readonly placeholder?: string;
+}
+export interface TransferPaginationConfig {
+    readonly pageSize?: number;
+    readonly showLessItems?: boolean;
+    readonly showSizeChanger?: boolean;
+    readonly simple?: boolean;
+}
+export type TransferPagination = boolean | TransferPaginationConfig;
+export type TransferSelectAllLabel = ReactNode | ((info: {
+    readonly selectedCount: number;
+    readonly totalCount: number;
+}) => ReactNode);
+type TransferSemanticSlot = "root" | "section" | "header" | "title" | "body" | "list" | "item" | "itemIcon" | "itemContent" | "footer" | "actions";
+type TransferSectionSemanticSlot = Exclude<TransferSemanticSlot, "root" | "actions">;
+export type TransferClassNames = Partial<Record<TransferSemanticSlot, string>> & {
+    readonly source?: Partial<Record<TransferSectionSemanticSlot, string>>;
+    readonly target?: Partial<Record<TransferSectionSemanticSlot, string>>;
+};
+export type TransferStyles = Partial<Record<TransferSemanticSlot, CSSProperties>> & {
+    readonly source?: Partial<Record<TransferSectionSemanticSlot, CSSProperties>>;
+    readonly target?: Partial<Record<TransferSectionSemanticSlot, CSSProperties>>;
+};
+export interface TransferLocale {
+    readonly deselectAll?: string;
+    readonly itemUnit?: string;
+    readonly itemsUnit?: string;
+    readonly notFoundContent?: ReactNode | readonly ReactNode[];
+    readonly remove?: string;
+    readonly removeAll?: string;
+    readonly removeCurrent?: string;
+    readonly searchPlaceholder?: string;
+    readonly selectAll?: string;
+    readonly selectCurrent?: string;
+    readonly selectInvert?: string;
+    readonly titles?: readonly ReactNode[];
+}
+type KeyWise<RecordType> = RecordType & {
+    key: TransferKey;
+};
+export interface TransferCustomListBodyProps<RecordType extends TransferItem = TransferItem> {
+    readonly direction: TransferDirection;
+    readonly disabled?: boolean;
+    readonly filteredItems: KeyWise<RecordType>[];
+    readonly onItemRemove?: (keys: TransferKey[]) => void;
+    readonly onItemSelect: (key: TransferKey, checked: boolean, event?: React.MouseEvent<Element>) => void;
+    readonly onItemSelectAll: (keys: TransferKey[], checked: boolean | "replace") => void;
+    readonly selectedKeys: TransferKey[];
+}
+export interface TransferProps<RecordType extends TransferItem = TransferItem> extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "onScroll"> {
+    readonly actions?: readonly ReactNode[];
+    readonly children?: (props: TransferCustomListBodyProps<RecordType>) => ReactNode;
+    readonly classNames?: TransferClassNames;
+    readonly dataSource?: readonly RecordType[];
+    readonly defaultSelectedKeys?: readonly TransferKey[];
+    readonly defaultTargetKeys?: readonly TransferKey[];
+    readonly disabled?: boolean;
+    readonly filterOption?: (inputValue: string, item: RecordType, direction: TransferDirection) => boolean;
+    readonly footer?: (props: TransferListProps<RecordType>, info?: {
+        readonly direction: TransferDirection;
+    }) => ReactNode;
+    readonly listStyle?: CSSProperties | ((info: {
+        readonly direction: TransferDirection;
+    }) => CSSProperties);
+    readonly locale?: TransferLocale;
+    readonly notFoundContent?: ReactNode | readonly ReactNode[];
+    readonly onChange?: (targetKeys: TransferKey[], direction: TransferDirection, moveKeys: TransferKey[]) => void;
+    readonly onScroll?: (direction: TransferDirection, event: React.SyntheticEvent<HTMLUListElement>) => void;
+    readonly onSearch?: (direction: TransferDirection, value: string) => void;
+    readonly onSelectChange?: (sourceSelectedKeys: TransferKey[], targetSelectedKeys: TransferKey[]) => void;
+    readonly oneWay?: boolean;
+    readonly operations?: readonly string[];
+    readonly operationStyle?: CSSProperties;
+    readonly pagination?: TransferPagination;
+    readonly render?: (item: RecordType) => TransferRenderResult;
+    readonly rowKey?: (record: RecordType) => TransferKey;
+    readonly rootClassName?: string;
+    readonly selectedKeys?: readonly TransferKey[];
+    readonly selectAllLabels?: readonly TransferSelectAllLabel[];
+    readonly selectionsIcon?: ReactNode;
+    readonly showSearch?: boolean | TransferSearchOption;
+    readonly showSelectAll?: boolean;
+    readonly status?: InputStatus;
+    readonly styles?: TransferStyles;
+    readonly targetKeys?: readonly TransferKey[];
+    readonly titles?: readonly ReactNode[];
+}
+export interface TransferSearchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value"> {
+    readonly onChange?: (value: string) => void;
+    readonly onClear?: () => void;
+    readonly value?: string;
+}
+declare function TransferSearch({ disabled, onChange, onClear, placeholder, value, ...props }: TransferSearchProps): import("react").JSX.Element;
+export interface TransferOperationProps {
+    readonly actions?: readonly ReactNode[];
+    readonly disabled?: boolean;
+    readonly leftActive?: boolean;
+    readonly moveToLeft?: () => void;
+    readonly moveToRight?: () => void;
+    readonly oneWay?: boolean;
+    readonly rightActive?: boolean;
+    readonly style?: CSSProperties;
+}
+declare function TransferOperation({ actions, disabled, leftActive, moveToLeft, moveToRight, oneWay, rightActive, style, }: TransferOperationProps): import("react").JSX.Element;
+export interface TransferListProps<RecordType extends TransferItem = TransferItem> {
+    readonly checkedKeys: TransferKey[];
+    readonly classNames?: TransferClassNames;
+    readonly dataSource?: readonly KeyWise<RecordType>[];
+    readonly direction: TransferDirection;
+    readonly disabled?: boolean;
+    readonly filterOption?: TransferProps<RecordType>["filterOption"];
+    readonly footer?: TransferProps<RecordType>["footer"];
+    readonly listStyle?: CSSProperties;
+    readonly locale: Required<TransferLocale>;
+    readonly onItemRemove?: (keys: TransferKey[]) => void;
+    readonly onItemSelect: TransferCustomListBodyProps<RecordType>["onItemSelect"];
+    readonly onItemSelectAll: TransferCustomListBodyProps<RecordType>["onItemSelectAll"];
+    readonly onScroll?: (event: React.SyntheticEvent<HTMLUListElement>) => void;
+    readonly onSearch?: (value: string) => void;
+    readonly pagination?: TransferPagination;
+    readonly render?: TransferProps<RecordType>["render"];
+    readonly renderList?: (props: TransferCustomListBodyProps<RecordType>) => ReactNode;
+    readonly selectAllLabel?: TransferSelectAllLabel;
+    readonly selectionsIcon?: ReactNode;
+    readonly showRemove?: boolean;
+    readonly showSearch?: boolean | TransferSearchOption;
+    readonly showSelectAll?: boolean;
+    readonly styles?: TransferStyles;
+    readonly title?: ReactNode;
+}
+declare function TransferSection<RecordType extends TransferItem>(props: TransferListProps<RecordType>): import("react").JSX.Element;
+declare function InternalTransfer<RecordType extends TransferItem = TransferItem>({ actions, children, className, classNames, dataSource, defaultSelectedKeys, defaultTargetKeys, disabled, filterOption, footer, listStyle, locale, notFoundContent, onChange, onScroll, onSearch, onSelectChange, oneWay, operations, operationStyle, pagination, render, rowKey, rootClassName, selectedKeys, selectAllLabels, selectionsIcon, showSearch, showSelectAll, status, style, styles, targetKeys, titles, ...props }: TransferProps<RecordType>): import("react").JSX.Element;
+export declare const Transfer: typeof InternalTransfer & {
+    List: typeof TransferSection;
+    Operation: typeof TransferOperation;
+    Search: typeof TransferSearch;
+};
+export interface TreeSelectNode extends Record<string, unknown> {
+    children?: TreeSelectNode[];
+    readonly disabled?: boolean;
+    readonly disableCheckbox?: boolean;
+    readonly key?: string | number;
+    readonly label?: ReactNode;
+    readonly title?: ReactNode;
+    readonly value?: string | number;
+}
+export interface TreeSelectProps<ValueType = unknown, OptionType extends TreeSelectNode = TreeSelectNode> extends Omit<RcTreeSelectProps<ValueType, OptionType>, "onPopupVisibleChange" | "prefixCls" | "treeData">, SelectVisualProps {
+    /** @deprecated Use onOpenChange instead. */
+    readonly onDropdownVisibleChange?: (open: boolean) => void;
+    readonly onOpenChange?: (open: boolean) => void;
+    /** @deprecated Use onOpenChange instead. */
+    readonly onPopupVisibleChange?: (open: boolean) => void;
+    readonly treeData?: readonly OptionType[];
+}
+declare function InternalTreeSelect<ValueType = unknown, OptionType extends TreeSelectNode = TreeSelectNode>({ className, disabled, getPopupContainer, onDropdownVisibleChange, onOpenChange, onPopupVisibleChange, rootClassName, size, status, suffix, suffixIcon, treeData, variant, ...props }: TreeSelectProps<ValueType, OptionType>): import("react").JSX.Element;
+export declare const TreeSelect: typeof InternalTreeSelect & {
+    readonly SHOW_ALL: "SHOW_ALL";
+    readonly SHOW_CHILD: "SHOW_CHILD";
+    readonly SHOW_PARENT: "SHOW_PARENT";
+    readonly TreeNode: import("react").FC<import("@rc-component/tree-select/lib/TreeNode").TreeNodeProps>;
+};
+export declare const LIST_IGNORE: string;
+export type UploadFileStatus = "ready" | "uploading" | "done" | "error" | "removed";
+export type UploadListType = "text" | "picture" | "picture-card" | "picture-circle";
+export type UploadType = "drag" | "select";
+export interface UploadFile<ResponseType = unknown> {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    crossOrigin?: "anonymous" | "use-credentials" | "";
+    error?: unknown;
+    fileName?: string;
+    lastModified?: number;
+    lastModifiedDate?: Date;
+    linkProps?: Record<string, string>;
+    name: string;
+    originFileObj?: RcFile;
+    percent?: number;
+    preview?: string;
+    response?: ResponseType;
+    size?: number;
+    status?: UploadFileStatus;
+    thumbUrl?: string;
+    type?: string;
+    uid: string;
+    url?: string;
+    xhr?: XMLHttpRequest;
+}
+export interface UploadChangeParam<ResponseType = unknown> {
+    readonly event?: {
+        readonly percent: number;
+    };
+    readonly file: UploadFile<ResponseType>;
+    readonly fileList: UploadFile<ResponseType>[];
+}
+export interface ShowUploadListInterface<ResponseType = unknown> {
+    readonly downloadIcon?: ReactNode | ((file: UploadFile<ResponseType>) => ReactNode);
+    readonly extra?: ReactNode | ((file: UploadFile<ResponseType>) => ReactNode);
+    readonly previewIcon?: ReactNode | ((file: UploadFile<ResponseType>) => ReactNode);
+    readonly removeIcon?: ReactNode | ((file: UploadFile<ResponseType>) => ReactNode);
+    readonly showDownloadIcon?: boolean | ((file: UploadFile<ResponseType>) => boolean);
+    readonly showPreviewIcon?: boolean | ((file: UploadFile<ResponseType>) => boolean);
+    readonly showRemoveIcon?: boolean | ((file: UploadFile<ResponseType>) => boolean);
+}
+export interface UploadLocale {
+    readonly downloadFile?: string;
+    readonly previewFile?: string;
+    readonly removeFile?: string;
+    readonly uploadError?: string;
+    readonly uploading?: string;
+}
+export interface UploadListProgressProps {
+    readonly showInfo?: boolean;
+    readonly strokeWidth?: number;
+}
+export interface UploadActions {
+    readonly download: () => void;
+    readonly preview: () => void;
+    readonly remove: () => void;
+}
+export type UploadItemRender<ResponseType = unknown> = (originNode: ReactElement, file: UploadFile<ResponseType>, fileList: UploadFile<ResponseType>[], actions: UploadActions) => ReactNode;
+export interface UploadSemanticProps {
+    readonly classNames?: Partial<Record<"root" | "list" | "item" | "trigger", string>>;
+    readonly styles?: Partial<Record<"root" | "list" | "item" | "trigger", CSSProperties>>;
+}
+type UploadBeforeValue = boolean | undefined | string | Blob | File;
+export interface UploadProps<ResponseType = unknown> extends Omit<RcUploadProps, "beforeUpload" | "children" | "classNames" | "onBatchStart" | "onChange" | "onDrop" | "onError" | "onProgress" | "onStart" | "onSuccess" | "prefixCls" | "style" | "styles">, UploadSemanticProps {
+    readonly beforeUpload?: (file: RcFile, fileList: RcFile[]) => UploadBeforeValue | Promise<UploadBeforeValue>;
+    readonly children?: ReactNode;
+    readonly defaultFileList?: UploadFile<ResponseType>[];
+    readonly fileList?: UploadFile<ResponseType>[];
+    readonly iconRender?: (file: UploadFile<ResponseType>, listType?: UploadListType) => ReactNode;
+    readonly isImageUrl?: (file: UploadFile<ResponseType>) => boolean;
+    readonly itemRender?: UploadItemRender<ResponseType>;
+    readonly listType?: UploadListType;
+    readonly locale?: UploadLocale;
+    readonly maxCount?: number;
+    readonly onChange?: (info: UploadChangeParam<ResponseType>) => void;
+    readonly onDownload?: (file: UploadFile<ResponseType>) => void;
+    readonly onDrop?: (event: DragEvent<HTMLDivElement>) => void;
+    readonly onPreview?: (file: UploadFile<ResponseType>) => void;
+    readonly onRemove?: (file: UploadFile<ResponseType>) => boolean | void | Promise<boolean | void>;
+    readonly previewFile?: (file: File | Blob) => PromiseLike<string>;
+    readonly progress?: UploadListProgressProps;
+    readonly rootClassName?: string;
+    readonly showUploadList?: boolean | ShowUploadListInterface<ResponseType>;
+    readonly style?: CSSProperties;
+    readonly type?: UploadType;
+}
+export interface UploadRef<ResponseType = unknown> {
+    readonly fileList: UploadFile<ResponseType>[];
+    readonly nativeElement: HTMLSpanElement | null;
+    readonly onBatchStart: NonNullable<RcUploadProps["onBatchStart"]>;
+    readonly onError: NonNullable<RcUploadProps["onError"]>;
+    readonly onProgress: NonNullable<RcUploadProps["onProgress"]>;
+    readonly onSuccess: NonNullable<RcUploadProps["onSuccess"]>;
+    readonly upload: ComponentRef<typeof RcUpload> | null;
+}
+export interface DraggerProps<ResponseType = unknown> extends UploadProps<ResponseType> {
+    readonly height?: CSSProperties["height"];
+}
+declare const UploadDragger: import("react").ForwardRefExoticComponent<DraggerProps<unknown> & RefAttributes<UploadRef<unknown>>>;
+export declare const Upload: (<ResponseType = unknown>(props: UploadProps<ResponseType> & RefAttributes<UploadRef<ResponseType>>) => ReactElement | null) & {
+    Dragger: typeof UploadDragger;
+    LIST_IGNORE: string;
+} & {
+    Dragger: import("react").ForwardRefExoticComponent<DraggerProps<unknown> & RefAttributes<UploadRef<unknown>>>;
+    LIST_IGNORE: string;
+};
+export {};

package/dist/types/components/Divider.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export type DividerOrientation = "horizontal" | "vertical";
+export type DividerTitlePlacement = "left" | "right" | "center" | "start" | "end";
+export type DividerVariant = "dashed" | "dotted" | "solid";
+export type DividerSize = "small" | "medium" | "middle" | "large" | "default";
+export interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    readonly children?: ReactNode;
+    readonly dashed?: boolean;
+    /**
+     * AntD 6 orientation. The legacy title-placement values remain accepted for compatibility.
+     */
+    readonly orientation?: DividerOrientation | "left" | "right" | "center";
+    /** @deprecated Use `styles.content.margin` in AntD-compatible code. */
+    readonly orientationMargin?: number | string;
+    readonly plain?: boolean;
+    readonly rootClassName?: string;
+    readonly size?: DividerSize;
+    readonly titlePlacement?: DividerTitlePlacement;
+    /** @deprecated Use `orientation` instead. */
+    readonly type?: DividerOrientation;
+    readonly variant?: DividerVariant;
+    readonly vertical?: boolean;
+}
+export declare function Divider({ children, className, dashed, orientation, orientationMargin, plain, rootClassName, size, style, titlePlacement, type, variant, vertical, ...props }: DividerProps): import("react").JSX.Element;

package/dist/types/components/Drawer.d.ts

@@ -0,0 +1,68 @@
+import type { CSSProperties, KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, ReactNode, Ref } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type DrawerPlacement = "top" | "right" | "bottom" | "left";
+export type DrawerSize = "default" | "large" | number | string;
+export type DrawerPush = boolean | {
+    readonly distance?: number | string;
+};
+export type DrawerResizable = boolean | {
+    readonly onResize?: (size: number) => void;
+    readonly onResizeEnd?: () => void;
+    readonly onResizeStart?: () => void;
+};
+export type DrawerClosable = boolean | {
+    readonly closeIcon?: ReactNode;
+    readonly disabled?: boolean;
+    readonly placement?: "start" | "end";
+};
+export type DrawerMask = boolean | {
+    readonly blur?: boolean;
+    readonly closable?: boolean;
+};
+type DrawerSlot = "root" | "mask" | "wrapper" | "panel" | "dragger" | "header" | "title" | "extra" | "close" | "body" | "footer";
+export interface DrawerProps {
+    readonly afterOpenChange?: (open: boolean) => void;
+    readonly autoFocus?: boolean;
+    readonly children?: ReactNode;
+    readonly bodyStyle?: CSSProperties;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<DrawerSlot>;
+    readonly closeIcon?: ReactNode;
+    readonly closable?: DrawerClosable;
+    readonly contentWrapperStyle?: CSSProperties;
+    readonly defaultSize?: number | string;
+    readonly destroyOnClose?: boolean;
+    readonly destroyOnHidden?: boolean;
+    readonly drawerRender?: (node: ReactNode) => ReactNode;
+    readonly drawerStyle?: CSSProperties;
+    readonly extra?: ReactNode;
+    readonly focusTriggerAfterClose?: boolean;
+    readonly forceRender?: boolean;
+    readonly footer?: ReactNode;
+    readonly footerStyle?: CSSProperties;
+    readonly getContainer?: false | HTMLElement | (() => HTMLElement);
+    readonly height?: number | string;
+    readonly headerStyle?: CSSProperties;
+    readonly keyboard?: boolean;
+    readonly loading?: boolean;
+    readonly mask?: DrawerMask;
+    readonly maskClosable?: boolean;
+    readonly maskStyle?: CSSProperties;
+    readonly maxSize?: number;
+    readonly open?: boolean;
+    readonly panelRef?: Ref<HTMLDivElement>;
+    readonly placement?: DrawerPlacement;
+    readonly push?: DrawerPush;
+    readonly resizable?: DrawerResizable;
+    readonly rootClassName?: string;
+    readonly rootStyle?: CSSProperties;
+    readonly size?: DrawerSize;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<DrawerSlot>;
+    readonly title?: ReactNode;
+    readonly width?: number | string;
+    readonly zIndex?: number;
+    readonly onClose?: (event?: ReactMouseEvent<HTMLButtonElement> | ReactMouseEvent | ReactKeyboardEvent | KeyboardEvent) => void;
+}
+export declare function Drawer({ afterOpenChange, autoFocus, bodyStyle, children, className, classNames, closeIcon, closable, contentWrapperStyle, defaultSize, destroyOnClose, destroyOnHidden, drawerRender, drawerStyle, extra, focusTriggerAfterClose, forceRender, footer, footerStyle, getContainer, height, headerStyle, keyboard, loading, mask, maskClosable, maskStyle, maxSize, onClose, open, panelRef, placement, push, resizable, rootClassName, rootStyle, size, style, styles, title, width, zIndex, }: DrawerProps): import("react").JSX.Element;
+export {};

package/dist/types/components/Dropdown.d.ts

@@ -0,0 +1,41 @@
+import type { DropdownProps as RcDropdownProps } from "@rc-component/dropdown";
+import type { CSSProperties, ReactNode } from "react";
+import { type MenuItem, type MenuProps } from "./NavigationPrimitives";
+export type DropdownPlacement = "bottom" | "bottomLeft" | "bottomRight" | "top" | "topLeft" | "topRight" | "left" | "leftTop" | "leftBottom" | "right" | "rightTop" | "rightBottom";
+export type DropdownTrigger = "click" | "hover" | "contextMenu";
+export interface DropdownArrowOptions {
+    readonly pointAtCenter?: boolean;
+}
+export interface DropdownMenuItem extends MenuItem {
+    readonly id?: string;
+}
+export interface DropdownMenu extends Omit<MenuProps, "items"> {
+    readonly activeKey?: string;
+    readonly items?: readonly (DropdownMenuItem | null)[];
+}
+type DropdownSlot = "root";
+export interface DropdownProps extends Omit<RcDropdownProps, "arrow" | "children" | "onVisibleChange" | "overlay" | "placement" | "trigger" | "visible"> {
+    readonly arrow?: boolean | DropdownArrowOptions;
+    readonly children: ReactNode;
+    readonly className?: string;
+    readonly classNames?: Partial<Record<DropdownSlot, string>>;
+    readonly defaultOpen?: boolean;
+    readonly disabled?: boolean;
+    readonly destroyOnHidden?: boolean;
+    readonly destroyPopupOnHide?: boolean;
+    readonly dropdownRender?: (originNode: ReactNode) => ReactNode;
+    readonly forceRender?: boolean;
+    readonly menu?: DropdownMenu;
+    readonly open?: boolean;
+    readonly overlay?: ReactNode;
+    readonly placement?: DropdownPlacement;
+    readonly popupRender?: (originNode: ReactNode) => ReactNode;
+    readonly rootClassName?: string;
+    readonly styles?: Partial<Record<DropdownSlot, CSSProperties>>;
+    readonly trigger?: readonly DropdownTrigger[];
+    readonly onOpenChange?: (open: boolean, info: {
+        source: "trigger" | "menu";
+    }) => void;
+}
+export declare const Dropdown: import("react").ForwardRefExoticComponent<DropdownProps & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/types/components/Empty.d.ts

@@ -0,0 +1,14 @@
+import type { CSSProperties, HTMLAttributes, ReactNode } from "react";
+export interface EmptyProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    readonly description?: ReactNode;
+    readonly image?: ReactNode;
+    /** @deprecated Use `styles.image` in AntD-compatible code. */
+    readonly imageStyle?: CSSProperties;
+    readonly rootClassName?: string;
+}
+declare function EmptyRoot({ children, className, description, image, imageStyle, rootClassName, ...props }: EmptyProps): import("react").JSX.Element;
+export declare const Empty: typeof EmptyRoot & {
+    PRESENTED_IMAGE_DEFAULT: import("react").JSX.Element;
+    PRESENTED_IMAGE_SIMPLE: import("react").JSX.Element;
+};
+export {};

package/dist/types/components/EmptyState.d.ts

@@ -0,0 +1,6 @@
+interface EmptyStateProps {
+    readonly description?: string;
+    readonly title: string;
+}
+export declare function EmptyState({ description, title }: EmptyStateProps): import("react").JSX.Element;
+export {};