@996-design/996-ui 0.1.0

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

@@ -0,0 +1,24 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export interface MenuListItem {
+    readonly id: string;
+    readonly label: ReactNode;
+    readonly description?: ReactNode;
+    readonly avatar?: ReactNode;
+    readonly suffix?: ReactNode;
+    readonly disabled?: boolean;
+}
+type MenuListSlot = "root" | "item" | "avatar" | "content" | "label" | "description" | "suffix";
+export interface MenuListProps {
+    readonly activeId?: string;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<MenuListSlot>;
+    readonly disabled?: boolean;
+    readonly items: readonly MenuListItem[];
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<MenuListSlot>;
+    readonly variant?: "menu" | "user" | "dropdown";
+    readonly onSelect?: (id: string) => void;
+}
+export declare function MenuList({ activeId, className, classNames, disabled, items, onSelect, style, styles, variant, }: MenuListProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,58 @@
+import type { CSSProperties, Key, ReactElement, ReactNode } from "react";
+import { type MessageNoticeType, type MessageType } from "./MessageToast";
+export type { MessageType } from "./MessageToast";
+export type NoticeType = MessageNoticeType;
+type MessageSemanticSlot = "list" | "listContent" | "root" | "wrapper" | "icon" | "title";
+export type MessageClassNames = Partial<Record<MessageSemanticSlot, string>>;
+export type MessageStyles = Partial<Record<MessageSemanticSlot, CSSProperties>>;
+type SemanticValue<Value, Props> = Value | ((info: {
+    readonly props: Props;
+}) => Value);
+export interface ConfigOptions {
+    readonly classNames?: SemanticValue<MessageClassNames, ArgsProps>;
+    readonly duration?: number;
+    readonly getContainer?: () => HTMLElement;
+    readonly maxCount?: number;
+    readonly pauseOnHover?: boolean;
+    readonly prefixCls?: string;
+    readonly rtl?: boolean;
+    readonly stack?: boolean | {
+        readonly threshold?: number;
+    };
+    readonly styles?: SemanticValue<MessageStyles, ArgsProps>;
+    readonly top?: number | string;
+    readonly transitionName?: string;
+}
+export interface ArgsProps {
+    readonly className?: string;
+    readonly classNames?: SemanticValue<MessageClassNames, ArgsProps>;
+    readonly content: ReactNode;
+    readonly duration?: number;
+    readonly icon?: ReactNode;
+    readonly key?: Key;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    readonly onClose?: () => void;
+    readonly pauseOnHover?: boolean;
+    readonly style?: CSSProperties;
+    readonly styles?: SemanticValue<MessageStyles, ArgsProps>;
+    readonly type?: NoticeType;
+}
+export type MessageArgs = ArgsProps;
+export type JointContent = ReactNode | ArgsProps;
+export type TypeOpen = (content: JointContent, duration?: number | VoidFunction, onClose?: VoidFunction) => MessageType;
+export type MessageOpen = TypeOpen;
+export interface MessageInstance {
+    readonly destroy: (key?: Key) => void;
+    readonly error: TypeOpen;
+    readonly info: TypeOpen;
+    readonly loading: TypeOpen;
+    readonly open: (args: ArgsProps) => MessageType;
+    readonly success: TypeOpen;
+    readonly warning: TypeOpen;
+}
+export declare function useMessage(messageConfig?: ConfigOptions): readonly [MessageInstance, ReactElement];
+export interface MessageMethods extends MessageInstance {
+    readonly config: (config: ConfigOptions) => void;
+    readonly useMessage: typeof useMessage;
+}
+export declare const message: MessageMethods;

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

@@ -0,0 +1,27 @@
+import type { NotificationProps as RcNotificationProps } from "@rc-component/notification";
+import type { ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type MessageNoticeType = "success" | "warning" | "error" | "info" | "loading";
+export interface MessageType extends PromiseLike<boolean> {
+    (): void;
+}
+type MessageToastRole = NonNullable<RcNotificationProps["role"]> & ("alert" | "status");
+type MessageToastSlot = "root" | "icon" | "content" | "action" | "close";
+export interface MessageToastProps {
+    readonly action?: ReactNode;
+    readonly children: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<MessageToastSlot>;
+    readonly closable?: boolean;
+    readonly closeIcon?: ReactNode;
+    readonly icon?: ReactNode;
+    readonly onClose?: () => void;
+    readonly open?: boolean;
+    readonly role?: MessageToastRole;
+    readonly showIcon?: boolean;
+    readonly styles?: SlotStyles<MessageToastSlot>;
+    readonly type?: MessageNoticeType;
+    readonly variant?: "dark" | "light";
+}
+export declare function MessageToast({ action, children, className, classNames, closable, closeIcon, icon, onClose, open, role, showIcon, styles, type, variant, }: MessageToastProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,123 @@
+import type { CSSProperties, ReactElement, MouseEvent as ReactMouseEvent, ReactNode, SyntheticEvent } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+import { type ButtonProps } from "./Button";
+type ModalSlot = "root" | "mask" | "wrapper" | "panel" | "header" | "title" | "close" | "body" | "footer";
+export type ModalFooterRender = (originNode: ReactNode, extra: {
+    readonly OkBtn: () => ReactNode;
+    readonly CancelBtn: () => ReactNode;
+}) => ReactNode;
+export type MousePosition = {
+    readonly x: number;
+    readonly y: number;
+} | null;
+declare global {
+    interface Window {
+        __huaijiuModalClickPositionListener?: (event: globalThis.MouseEvent) => void;
+        __huaijiuModalClickPosition?: MousePosition;
+        __huaijiuModalClickPositionTimer?: number;
+    }
+}
+export interface ModalProps {
+    readonly afterClose?: () => void;
+    readonly afterOpenChange?: (open: boolean) => void;
+    readonly backIcon?: ReactNode;
+    readonly bodyStyle?: CSSProperties;
+    readonly cancelButtonProps?: Partial<Omit<ButtonProps, "children">>;
+    readonly cancelText?: ReactNode;
+    readonly centered?: boolean;
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<ModalSlot>;
+    readonly closeIcon?: ReactNode;
+    readonly closable?: boolean;
+    readonly confirmLoading?: boolean;
+    readonly destroyOnClose?: boolean;
+    readonly destroyOnHidden?: boolean;
+    readonly focusTrap?: boolean;
+    readonly focusTriggerAfterClose?: boolean;
+    readonly forceRender?: boolean;
+    readonly footer?: ReactNode | ModalFooterRender;
+    readonly getContainer?: false | HTMLElement | (() => HTMLElement);
+    readonly keyboard?: boolean;
+    readonly loading?: boolean;
+    readonly mask?: boolean;
+    readonly maskClosable?: boolean;
+    readonly maskStyle?: CSSProperties;
+    readonly maskTransitionName?: string;
+    readonly modalRender?: (node: ReactNode) => ReactNode;
+    readonly mousePosition?: MousePosition;
+    readonly okButtonProps?: Partial<Omit<ButtonProps, "children">>;
+    readonly okText?: ReactNode;
+    readonly open?: boolean;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly rootStyle?: CSSProperties;
+    readonly scrollLock?: boolean;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<ModalSlot>;
+    readonly title?: ReactNode;
+    readonly titleAlign?: "start" | "center";
+    readonly titleIcon?: ReactNode;
+    readonly transitionName?: string;
+    readonly width?: number | string;
+    readonly wrapClassName?: string;
+    readonly zIndex?: number;
+    readonly onBack?: () => void;
+    readonly onCancel?: (event?: ReactMouseEvent<HTMLButtonElement> | SyntheticEvent | KeyboardEvent) => void;
+    readonly onClose?: () => void;
+    readonly onOk?: (event?: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+export type ModalStaticAction = (close: VoidFunction) => unknown;
+export interface ModalFuncProps extends Omit<ModalProps, "children" | "onCancel" | "onOk" | "open" | "width"> {
+    readonly autoFocusButton?: null | "ok" | "cancel";
+    readonly content?: ReactNode;
+    readonly focusable?: {
+        readonly autoFocusButton?: null | "ok" | "cancel";
+        readonly focusTriggerAfterClose?: boolean;
+        readonly trap?: boolean;
+    };
+    readonly icon?: ReactNode;
+    readonly okCancel?: boolean;
+    readonly open?: boolean;
+    readonly title?: ReactNode;
+    readonly type?: "confirm" | "info" | "success" | "warn" | "warning" | "error";
+    readonly width?: number | string;
+    readonly onCancel?: ModalStaticAction;
+    readonly onOk?: ModalStaticAction;
+}
+export type ModalConfigUpdate = Partial<ModalFuncProps> | ((previous: ModalFuncProps) => ModalFuncProps);
+export interface ModalFuncReturn {
+    readonly destroy: () => void;
+    readonly update: (nextProps: ModalConfigUpdate) => void;
+}
+export interface HookModalFuncReturn extends ModalFuncReturn, PromiseLike<boolean> {
+}
+export type ModalFunc = (props: ModalFuncProps) => ModalFuncReturn;
+export type HookModalFunc = (props: ModalFuncProps) => HookModalFuncReturn;
+export interface HookModalApi {
+    readonly confirm: HookModalFunc;
+    readonly error: HookModalFunc;
+    readonly info: HookModalFunc;
+    readonly success: HookModalFunc;
+    readonly warning: HookModalFunc;
+}
+export interface ModalGlobalConfig {
+    readonly rootPrefixCls?: string;
+}
+declare function ModalRoot({ afterClose, afterOpenChange, backIcon, bodyStyle, cancelButtonProps, cancelText, centered, children, className, classNames, closeIcon, closable, confirmLoading, destroyOnClose, destroyOnHidden, focusTrap, focusTriggerAfterClose, forceRender, footer, getContainer, keyboard, loading, mask, maskClosable, maskStyle, maskTransitionName, modalRender, mousePosition, okButtonProps, okText, onBack, onCancel, onClose, onOk, open, prefixCls, rootClassName, rootStyle, scrollLock, style, styles, title, titleAlign, titleIcon, transitionName, width, wrapClassName, zIndex, }: ModalProps): import("react").JSX.Element;
+export declare function useModal(): readonly [HookModalApi, ReactElement];
+export interface ModalStaticFunctions {
+    readonly confirm: ModalFunc;
+    readonly error: ModalFunc;
+    readonly info: ModalFunc;
+    readonly success: ModalFunc;
+    readonly warn: ModalFunc;
+    readonly warning: ModalFunc;
+}
+export type ModalComponent = typeof ModalRoot & ModalStaticFunctions & {
+    readonly config: (config: ModalGlobalConfig) => void;
+    readonly destroyAll: VoidFunction;
+    readonly useModal: typeof useModal;
+};
+export declare const Modal: ModalComponent;
+export {};

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

@@ -0,0 +1,73 @@
+import type { MenuRef, MenuProps as RcMenuProps } from "@rc-component/menu";
+import type { MenuInfo, MenuMode as RcMenuMode, SelectInfo } from "@rc-component/menu/es/interface";
+import type { HTMLAttributes, Key, MouseEvent, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+import type { AffixProps } from "./OtherPrimitives";
+export interface AnchorItem {
+    readonly children?: readonly AnchorItem[];
+    readonly href: string;
+    readonly key?: string;
+    readonly target?: string;
+    readonly targetOffset?: number;
+    readonly title: ReactNode;
+}
+type AnchorSlot = "root" | "item" | "itemTitle" | "indicator";
+export interface AnchorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "onClick"> {
+    readonly affix?: boolean | Omit<AffixProps, "children" | "offsetTop" | "target">;
+    readonly bounds?: number;
+    readonly classNames?: SlotClassNames<AnchorSlot>;
+    readonly direction?: "vertical" | "horizontal";
+    readonly getContainer?: () => HTMLElement | Window;
+    readonly getCurrentAnchor?: (activeLink: string) => string;
+    readonly items?: readonly AnchorItem[];
+    readonly offsetTop?: number;
+    readonly replace?: boolean;
+    readonly rootClassName?: string;
+    readonly showInkInFixed?: boolean;
+    readonly styles?: SlotStyles<AnchorSlot>;
+    readonly targetOffset?: number;
+    readonly onClick?: (event: MouseEvent<HTMLAnchorElement>, link: AnchorItem) => void;
+    readonly onChange?: (currentActiveLink: string) => void;
+}
+export interface AnchorLinkProps {
+    readonly children?: ReactNode;
+    readonly href: string;
+    readonly target?: string;
+    readonly targetOffset?: number;
+    readonly title: ReactNode;
+}
+declare function AnchorLink(_props: AnchorLinkProps): null;
+declare function InternalAnchor({ affix, bounds, children, className, classNames, direction, getContainer, getCurrentAnchor, items, offsetTop, onChange, onClick, replace, rootClassName, showInkInFixed, style, styles, targetOffset, ...props }: AnchorProps): import("react").JSX.Element;
+export declare const Anchor: typeof InternalAnchor & {
+    Link: typeof AnchorLink;
+};
+export type MenuMode = RcMenuMode;
+export interface MenuItem {
+    readonly children?: readonly MenuItem[];
+    readonly className?: string;
+    readonly danger?: boolean;
+    readonly disabled?: boolean;
+    readonly extra?: ReactNode;
+    readonly icon?: ReactNode;
+    readonly itemIcon?: ReactNode;
+    readonly key?: Key;
+    readonly label?: ReactNode;
+    readonly style?: React.CSSProperties;
+    readonly type?: "item" | "submenu" | "group" | "divider";
+}
+export interface MenuProps extends Omit<RcMenuProps, "defaultOpenKeys" | "defaultSelectedKeys" | "items" | "onClick" | "onSelect" | "openKeys" | "prefixCls" | "selectedKeys"> {
+    readonly defaultOpenKeys?: readonly string[];
+    readonly defaultSelectedKeys?: readonly string[];
+    readonly items?: readonly (MenuItem | null)[];
+    readonly openKeys?: readonly string[];
+    readonly selectedKeys?: readonly string[];
+    readonly onClick?: (info: MenuInfo) => void;
+    readonly onSelect?: (info: SelectInfo) => void;
+}
+export declare const Menu: import("react").ForwardRefExoticComponent<MenuProps & import("react").RefAttributes<MenuRef>> & {
+    Divider: typeof import("@rc-component/menu").Divider;
+    Item: import("react").ForwardRefExoticComponent<import("@rc-component/menu").MenuItemProps & import("react").RefAttributes<HTMLElement>>;
+    ItemGroup: import("react").ForwardRefExoticComponent<Omit<import("@rc-component/menu").MenuItemGroupProps, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    SubMenu: import("react").ForwardRefExoticComponent<Omit<import("@rc-component/menu").SubMenuProps, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import { composeRefs, useControllableValue, useLatest, warning } from "@996-design/996-utils";
+import type { HTMLAttributes, ReactNode } from "react";
+declare function throttleByAnimationFrame<Args extends unknown[]>(callback: (...args: Args) => void): {
+    (...args: Args): void;
+    cancel(): void;
+};
+export interface AffixProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    readonly children: ReactNode;
+    readonly offsetBottom?: number;
+    readonly offsetTop?: number;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly target?: () => Window | HTMLElement | null;
+    readonly onChange?: (affixed?: boolean) => void;
+    /** Test hook called after an update request has been measured. */
+    readonly onTestUpdate?: () => void;
+    /** @internal AntD-compatible test hook. */
+    readonly onTestUpdatePosition?: () => void;
+}
+export interface AffixRef {
+    readonly nativeElement: HTMLDivElement;
+    readonly updatePosition: ReturnType<typeof throttleByAnimationFrame>;
+}
+export declare const Affix: import("react").ForwardRefExoticComponent<AffixProps & import("react").RefAttributes<AffixRef>>;
+export interface BorderBeamProps extends HTMLAttributes<HTMLDivElement> {
+    readonly children?: ReactNode;
+    readonly duration?: number;
+}
+export declare function BorderBeam({ children, className, duration, style, ...props }: BorderBeamProps): import("react").JSX.Element;
+export declare const Util: {
+    composeRefs: typeof composeRefs;
+    useControllableValue: typeof useControllableValue;
+    useLatest: typeof useLatest;
+    warning: typeof warning;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import type { PaginationLocale, PaginationProps as RcPaginationProps } from "@rc-component/pagination";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+import { type SelectOption, type SelectProps } from "./DataEntryPrimitives";
+import { type InputSize } from "./Input";
+export type { PaginationLocale };
+export type PaginationSize = InputSize;
+export type PaginationSizeChangerProps = SelectProps<number, SelectOption>;
+type PaginationSlot = "root" | "item";
+export interface PaginationProps extends Omit<RcPaginationProps, "classNames" | "pageSizeOptions" | "prefixCls" | "showSizeChanger" | "styles"> {
+    readonly classNames?: SlotClassNames<PaginationSlot>;
+    readonly pageSizeOptions?: readonly (number | string)[];
+    readonly responsive?: boolean;
+    readonly rootClassName?: string;
+    readonly showSizeChanger?: boolean | PaginationSizeChangerProps;
+    readonly size?: PaginationSize;
+    readonly styles?: SlotStyles<PaginationSlot>;
+}
+export declare function Pagination({ className, classNames, disabled, jumpNextIcon, jumpPrevIcon, locale, nextIcon, pageSizeOptions, prevIcon, responsive, rootClassName, showSizeChanger, size, sizeChangerRender, style, styles, ...paginationProps }: PaginationProps): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { HTMLAttributes, ReactNode } from "react";
+interface PanelProps extends HTMLAttributes<HTMLElement> {
+    readonly as?: "article" | "section" | "div";
+    readonly children: ReactNode;
+    readonly radius?: "sm" | "md";
+}
+export declare function Panel({ as: Component, children, className, radius, ...props }: PanelProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import type { MouseEvent as ReactMouseEvent, ReactNode } from "react";
+import { type ButtonProps } from "./Button";
+import { type PopoverProps } from "./Popover";
+export interface PopconfirmProps extends Omit<PopoverProps, "content" | "title"> {
+    readonly cancelButtonProps?: Partial<Omit<ButtonProps, "children" | "onClick">>;
+    readonly cancelText?: ReactNode;
+    readonly description?: ReactNode;
+    readonly icon?: ReactNode;
+    readonly okButtonProps?: Partial<Omit<ButtonProps, "children" | "onClick">>;
+    readonly okText?: ReactNode;
+    readonly okType?: ButtonProps["type"];
+    readonly showCancel?: boolean;
+    readonly title: ReactNode;
+    readonly onCancel?: (event?: ReactMouseEvent<HTMLButtonElement>) => void;
+    readonly onConfirm?: (event?: ReactMouseEvent<HTMLButtonElement>) => void | PromiseLike<void>;
+    readonly onPopupClick?: (event: ReactMouseEvent<HTMLElement>) => void;
+}
+export declare const Popconfirm: import("react").ForwardRefExoticComponent<PopconfirmProps & import("react").RefAttributes<import("@rc-component/tooltip").TooltipRef>>;

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

@@ -0,0 +1,10 @@
+import type { CSSProperties, ReactNode } from "react";
+import { type TooltipProps } from "./Tooltip";
+type PopoverContent = ReactNode | (() => ReactNode);
+export interface PopoverProps extends Omit<TooltipProps, "maxWidth" | "title" | "variant"> {
+    readonly content?: PopoverContent;
+    readonly overlayStyle?: CSSProperties;
+    readonly title?: PopoverContent;
+}
+export declare const Popover: import("react").ForwardRefExoticComponent<PopoverProps & import("react").RefAttributes<import("@rc-component/tooltip").TooltipRef>>;
+export {};

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

@@ -0,0 +1,9 @@
+interface PriceTextProps {
+    readonly className?: string;
+    readonly freeLabel?: string;
+    readonly freeClassName?: string;
+    readonly originalPrice?: string | null;
+    readonly price: string;
+}
+export declare function PriceText({ className, freeClassName, freeLabel, originalPrice, price, }: PriceTextProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,57 @@
+import type { ProgressProps as RcProgressProps } from "@rc-component/progress";
+import type { AriaAttributes, CSSProperties, HTMLAttributes, ReactNode } from "react";
+export type ProgressStatus = "normal" | "success" | "exception" | "active";
+export type ProgressType = "line" | "circle" | "dashboard";
+export type ProgressSize = "small" | "medium" | "middle" | "default";
+export type ProgressStrokeLinecap = NonNullable<RcProgressProps["strokeLinecap"]>;
+export type ProgressGapPlacement = "top" | "bottom" | "start" | "end";
+export type ProgressGapPosition = "top" | "bottom" | "left" | "right";
+export type ProgressGradient = {
+    readonly direction?: string;
+} & Record<string, string | undefined>;
+export interface ProgressSuccessProps {
+    readonly percent?: number;
+    readonly strokeColor?: string;
+}
+export interface ProgressPercentPosition {
+    readonly align?: "start" | "center" | "end";
+    readonly type?: "inner" | "outer";
+}
+export type ProgressSemanticSlot = "root" | "body" | "rail" | "track" | "indicator";
+export interface ProgressProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "className" | "style">, Pick<AriaAttributes, "aria-label" | "aria-labelledby"> {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: Partial<Record<ProgressSemanticSlot, string>>;
+    readonly format?: (percent?: number, successPercent?: number) => ReactNode;
+    readonly gapDegree?: number;
+    readonly gapPlacement?: ProgressGapPlacement;
+    /** @deprecated Use `gapPlacement` instead. */
+    readonly gapPosition?: ProgressGapPosition;
+    readonly percent?: number;
+    readonly percentPosition?: ProgressPercentPosition;
+    readonly railColor?: string;
+    readonly rootClassName?: string;
+    readonly rounding?: (step: number) => number;
+    readonly showInfo?: boolean;
+    readonly size?: number | [number | string, number] | ProgressSize | {
+        readonly width?: number;
+        readonly height?: number;
+    };
+    readonly status?: ProgressStatus;
+    readonly steps?: number | {
+        readonly count: number;
+        readonly gap: number;
+    };
+    readonly strokeColor?: string | readonly string[] | ProgressGradient;
+    readonly strokeLinecap?: ProgressStrokeLinecap;
+    readonly strokeWidth?: number;
+    readonly style?: CSSProperties;
+    readonly styles?: Partial<Record<ProgressSemanticSlot, CSSProperties>>;
+    readonly success?: ProgressSuccessProps;
+    /** @deprecated Use `railColor` instead. */
+    readonly trailColor?: string;
+    readonly type?: ProgressType;
+    /** @deprecated Use `size` instead. */
+    readonly width?: number;
+}
+export declare const Progress: import("react").ForwardRefExoticComponent<ProgressProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,8 @@
+interface ProgressBarProps {
+    readonly className?: string;
+    readonly max?: number;
+    readonly tone?: "primary" | "success" | "achievement";
+    readonly value: number;
+}
+export declare function ProgressBar({ className, max, tone, value, }: ProgressBarProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { type ButtonProps, type ButtonTone } from "./Button";
+interface ProgressButtonProps extends Omit<ButtonProps, "children" | "value"> {
+    readonly label: string;
+    readonly max?: number;
+    readonly tone?: ButtonTone;
+    readonly value: number | null;
+}
+export declare function ProgressButton({ className, disabled, label, max, tone, value, ...props }: ProgressButtonProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,67 @@
+import type { CheckboxRef } from "@rc-component/checkbox";
+import type { CSSProperties, HTMLAttributes, InputHTMLAttributes, MouseEventHandler, ReactElement, ReactNode, RefAttributes } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+type RadioSlot = "root" | "icon" | "label";
+export type RadioValue = string | number;
+export type RadioGroupButtonStyle = "outline" | "solid";
+export type RadioGroupOptionType = "default" | "button";
+export type RadioSize = "small" | "medium" | "middle" | "large";
+export type RadioRef = CheckboxRef;
+export interface RadioProps<ValueType = RadioValue> extends Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "onChange" | "onMouseEnter" | "onMouseLeave" | "type" | "value"> {
+    readonly children?: ReactNode;
+    readonly classNames?: SlotClassNames<RadioSlot>;
+    readonly optionType?: RadioGroupOptionType;
+    readonly rootClassName?: string;
+    readonly skipGroup?: boolean;
+    readonly styles?: SlotStyles<RadioSlot>;
+    readonly value?: ValueType;
+    readonly onChange?: (event: RadioChangeEvent<ValueType>) => void;
+    readonly onMouseEnter?: MouseEventHandler<HTMLElement>;
+    readonly onMouseLeave?: MouseEventHandler<HTMLElement>;
+}
+export interface RadioChangeEventTarget<ValueType = RadioValue> extends RadioProps<ValueType> {
+    readonly checked: boolean;
+}
+export interface RadioChangeEvent<ValueType = RadioValue> {
+    readonly nativeEvent: MouseEvent;
+    readonly target: RadioChangeEventTarget<ValueType>;
+    readonly preventDefault: () => void;
+    readonly stopPropagation: () => void;
+}
+export interface RadioOptionType<ValueType = RadioValue> {
+    readonly className?: string;
+    readonly disabled?: boolean;
+    readonly id?: string;
+    readonly label: ReactNode;
+    readonly required?: boolean;
+    readonly style?: CSSProperties;
+    readonly title?: string;
+    readonly value: ValueType;
+    readonly onChange?: (event: RadioChangeEvent<ValueType>) => void;
+}
+export interface RadioGroupProps<ValueType = RadioValue> extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    readonly block?: boolean;
+    readonly buttonStyle?: RadioGroupButtonStyle;
+    readonly children?: ReactNode;
+    readonly defaultValue?: ValueType;
+    readonly disabled?: boolean;
+    readonly name?: string;
+    readonly optionType?: RadioGroupOptionType;
+    readonly options?: readonly (RadioOptionType<ValueType> | string | number)[];
+    readonly orientation?: "horizontal" | "vertical";
+    readonly rootClassName?: string;
+    readonly size?: RadioSize;
+    readonly value?: ValueType;
+    readonly vertical?: boolean;
+    readonly onChange?: (event: RadioChangeEvent<ValueType>) => void;
+    readonly onValueChange?: (value: ValueType, event: RadioChangeEvent<ValueType>) => void;
+}
+type RadioStandaloneComponent = <ValueType = RadioValue>(props: RadioProps<ValueType> & RefAttributes<CheckboxRef>) => ReactElement;
+type RadioGroupComponent = <ValueType = RadioValue>(props: RadioGroupProps<ValueType> & RefAttributes<HTMLDivElement>) => ReactElement;
+type RadioCompoundComponent = RadioStandaloneComponent & {
+    readonly Button: RadioStandaloneComponent;
+    readonly Group: RadioGroupComponent;
+    readonly __ANT_RADIO: boolean;
+};
+export declare const Radio: RadioCompoundComponent;
+export {};

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

@@ -0,0 +1,17 @@
+import RcRate from "@rc-component/rate";
+import type { ComponentPropsWithoutRef, ComponentRef, ReactElement, Ref } from "react";
+import { type InputSize } from "./Input";
+import { type TooltipProps } from "./Tooltip";
+type RcRateProps = ComponentPropsWithoutRef<typeof RcRate>;
+export type RateRef = ComponentRef<typeof RcRate>;
+export type RateSize = InputSize;
+export type RateTooltip = string | Omit<TooltipProps, "children">;
+export interface RateProps extends RcRateProps {
+    readonly rootClassName?: string;
+    readonly size?: RateSize;
+    readonly tooltips?: readonly RateTooltip[];
+}
+export declare const Rate: (props: RateProps & {
+    readonly ref?: Ref<RateRef>;
+}) => ReactElement;
+export {};

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

@@ -0,0 +1,11 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export type ResultStatus = "success" | "error" | "info" | "warning" | 403 | 404 | 500 | "403" | "404" | "500";
+export interface ResultProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    readonly extra?: ReactNode;
+    readonly icon?: ReactNode;
+    readonly rootClassName?: string;
+    readonly status?: ResultStatus;
+    readonly subTitle?: ReactNode;
+    readonly title?: ReactNode;
+}
+export declare function Result({ children, className, extra, icon, rootClassName, status, subTitle, title, ...props }: ResultProps): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+interface SectionHeaderProps {
+    readonly action?: ReactNode;
+    readonly className?: string;
+    readonly meta?: ReactNode;
+    readonly middle?: ReactNode;
+    readonly onAction?: () => void;
+    readonly title: ReactNode;
+}
+export declare function SectionHeader({ action, className, meta, middle, onAction, title, }: SectionHeaderProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,41 @@
+import type { SegmentedLabeledOption as RcSegmentedLabeledOption, SegmentedProps as RcSegmentedProps, SegmentedRawOption, SegmentedValue } from "@rc-component/segmented";
+import type { CSSProperties, ReactNode, RefAttributes } from "react";
+import type { TooltipProps } from "./Tooltip";
+export type { SegmentedValue } from "@rc-component/segmented";
+export type SegmentedSize = "small" | "medium" | "middle" | "large" | "xs" | "sm" | "md" | "lg";
+export type SegmentedSemanticSlot = "root" | "item" | "icon" | "label";
+export type SegmentedClassNames<ValueType = SegmentedValue> = Partial<Record<SegmentedSemanticSlot, string>> | ((info: {
+    props: SegmentedProps<ValueType>;
+}) => Partial<Record<SegmentedSemanticSlot, string>>);
+export type SegmentedStyles<ValueType = SegmentedValue> = Partial<Record<SegmentedSemanticSlot, CSSProperties>> | ((info: {
+    props: SegmentedProps<ValueType>;
+}) => Partial<Record<SegmentedSemanticSlot, CSSProperties>>);
+export interface SegmentedLabeledOption<ValueType = SegmentedValue> extends Omit<RcSegmentedLabeledOption<ValueType>, "label"> {
+    readonly icon?: ReactNode;
+    readonly label?: ReactNode;
+    readonly tooltip?: string | Omit<TooltipProps, "children">;
+}
+export type SegmentedOption<ValueType = SegmentedRawOption> = ValueType | SegmentedLabeledOption<ValueType>;
+export interface SegmentedLegacyItem<ValueType = SegmentedValue> {
+    readonly disabled?: boolean;
+    readonly icon?: ReactNode;
+    readonly id: ValueType;
+    readonly label: ReactNode;
+    readonly title?: string;
+}
+export interface SegmentedProps<ValueType = SegmentedValue> extends Omit<RcSegmentedProps<ValueType>, "classNames" | "disabled" | "itemRender" | "options" | "prefixCls" | "size" | "styles"> {
+    readonly block?: boolean;
+    readonly classNames?: SegmentedClassNames<ValueType>;
+    readonly disabled?: boolean;
+    readonly items?: readonly SegmentedLegacyItem<ValueType>[];
+    readonly options?: readonly SegmentedOption<ValueType>[];
+    readonly orientation?: "horizontal" | "vertical";
+    readonly rootClassName?: string;
+    readonly shape?: "default" | "round";
+    readonly size?: SegmentedSize;
+    readonly styles?: SegmentedStyles<ValueType>;
+}
+declare const InternalSegmented: import("react").ForwardRefExoticComponent<Omit<SegmentedProps<SegmentedValue>, "ref"> & RefAttributes<HTMLDivElement>>;
+export declare const Segmented: (<ValueType>(props: SegmentedProps<ValueType> & RefAttributes<HTMLDivElement>) => ReturnType<typeof InternalSegmented>) & {
+    displayName?: string;
+};