@996-design/996-ui 0.1.0

package/dist/types/ConfigProvider.d.ts

@@ -0,0 +1,195 @@
+import type { CSSProperties, FC, ReactNode } from "react";
+export type UiSurface = "web" | "admin";
+export type AntdSize = "small" | "medium" | "middle" | "large";
+export type UiSize = AntdSize | "xs" | "sm" | "md" | "lg";
+export type UiVisualSize = "sm" | "md" | "lg";
+export type UiMotionConfig = boolean | {
+    readonly disabled?: boolean;
+};
+export type DirectionType = "ltr" | "rtl";
+export declare const Variants: readonly ["outlined", "borderless", "filled", "underlined"];
+export type Variant = (typeof Variants)[number];
+export declare const defaultPrefixCls = "hj";
+export declare const defaultIconPrefixCls = "hjicon";
+export type PopupContainer = HTMLElement;
+export type TargetContainer = HTMLElement | Window | ShadowRoot;
+export type GetPrefixCls = (suffixCls?: string, customizePrefixCls?: string) => string;
+export type GetPopupContainer = (triggerNode?: HTMLElement) => PopupContainer;
+export type GetTargetContainer = () => TargetContainer;
+export type RenderEmptyHandler = (componentName?: string) => ReactNode;
+export type Locale = Readonly<Record<string, unknown>>;
+export interface ThemeCssVarConfig {
+    readonly key?: string;
+    readonly prefix?: string;
+}
+export type ThemeToken = Readonly<Record<string, unknown>>;
+export type ThemeComponentTokens = Readonly<Record<string, ThemeToken>>;
+export interface ThemeConfig {
+    readonly algorithm?: unknown;
+    readonly components?: ThemeComponentTokens;
+    readonly cssVar?: boolean | ThemeCssVarConfig;
+    readonly hashed?: boolean;
+    readonly inherit?: boolean;
+    readonly token?: ThemeToken;
+    readonly zeroRuntime?: boolean;
+}
+export interface ComponentDefaults {
+    readonly [componentName: string]: object | undefined;
+    readonly Button?: {
+        readonly size?: UiSize;
+        readonly disabled?: boolean;
+        readonly motion?: UiMotionConfig;
+    };
+    readonly Input?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly SelectInput?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+        readonly popupOffset?: number;
+    };
+    readonly Select?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly AutoComplete?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly Cascader?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly TreeSelect?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly Mentions?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+    };
+    readonly MenuList?: {
+        readonly disabled?: boolean;
+        readonly variant?: "menu" | "user" | "dropdown";
+    };
+    readonly SegmentedTabs?: {
+        readonly size?: UiSize;
+        readonly disabled?: boolean;
+        readonly motion?: UiMotionConfig;
+    };
+    readonly Segmented?: {
+        readonly size?: UiSize;
+        readonly disabled?: boolean;
+    };
+    readonly Modal?: {
+        readonly motion?: UiMotionConfig;
+        readonly width?: number | string;
+    };
+    readonly Tooltip?: {
+        readonly arrow?: boolean;
+        readonly disabled?: boolean;
+        readonly placement?: "topLeft" | "top" | "topRight" | "bottomLeft" | "bottom" | "bottomRight" | "leftTop" | "left" | "leftBottom" | "rightTop" | "right" | "rightBottom";
+        readonly trigger?: "hover" | "focus" | "click" | readonly ("hover" | "focus" | "click")[];
+        readonly variant?: "dark" | "light";
+    };
+    readonly MessageToast?: {
+        readonly showIcon?: boolean;
+        readonly variant?: "dark" | "light";
+    };
+    readonly Checkbox?: {
+        readonly disabled?: boolean;
+    };
+    readonly Switch?: {
+        readonly disabled?: boolean;
+    };
+    readonly AdminButton?: {
+        readonly size?: Exclude<UiSize, "xs">;
+        readonly disabled?: boolean;
+        readonly motion?: UiMotionConfig;
+    };
+    readonly AdminInput?: {
+        readonly disabled?: boolean;
+    };
+    readonly DataTable?: {
+        readonly pageSize?: number;
+    };
+}
+export interface UiConfig {
+    readonly componentDisabled: boolean;
+    readonly componentSize: AntdSize;
+    readonly components: ComponentDefaults;
+    readonly direction?: DirectionType;
+    readonly disabled: boolean;
+    readonly getPopupContainer?: GetPopupContainer;
+    readonly getPrefixCls: GetPrefixCls;
+    readonly getTargetContainer?: GetTargetContainer;
+    readonly iconPrefixCls: string;
+    readonly locale?: Locale;
+    readonly motion: UiMotionConfig;
+    readonly popupMatchSelectWidth?: boolean | number;
+    readonly prefixCls: string;
+    readonly renderEmpty?: RenderEmptyHandler;
+    readonly rootPrefixCls: string;
+    readonly size: UiVisualSize;
+    readonly surface: UiSurface;
+    readonly theme?: ThemeConfig;
+    readonly variant?: Variant;
+    readonly virtual?: boolean;
+}
+export type ConfigConsumerProps = UiConfig;
+export interface ConfigProviderProps {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly componentDisabled?: boolean;
+    readonly componentSize?: AntdSize;
+    readonly components?: ComponentDefaults;
+    readonly direction?: DirectionType;
+    readonly disabled?: boolean;
+    /** @deprecated Use `popupMatchSelectWidth`. */
+    readonly dropdownMatchSelectWidth?: boolean | number;
+    readonly getPopupContainer?: GetPopupContainer;
+    readonly getTargetContainer?: GetTargetContainer;
+    readonly iconPrefixCls?: string;
+    readonly locale?: Locale;
+    readonly motion?: UiMotionConfig;
+    readonly popupMatchSelectWidth?: boolean | number;
+    readonly prefixCls?: string;
+    readonly renderEmpty?: RenderEmptyHandler;
+    readonly size?: Exclude<UiSize, "xs">;
+    readonly style?: CSSProperties;
+    readonly surface?: UiSurface;
+    readonly theme?: ThemeConfig;
+    readonly variant?: Variant;
+    readonly virtual?: boolean;
+}
+export type HolderRender = (children: ReactNode) => ReactNode;
+export interface GlobalConfigProps {
+    readonly holderRender?: HolderRender;
+    readonly iconPrefixCls?: string;
+    readonly prefixCls?: string;
+    readonly theme?: ThemeConfig;
+}
+export interface GlobalConfig {
+    readonly getIconPrefixCls: () => string;
+    readonly getPrefixCls: GetPrefixCls;
+    readonly getRootPrefixCls: () => string;
+    readonly getTheme: () => ThemeConfig | undefined;
+    readonly holderRender?: HolderRender;
+}
+export declare const defaultConfig: UiConfig;
+export declare const ConfigContext: import("react").Context<UiConfig>;
+export declare const ConfigConsumer: import("react").Consumer<UiConfig>;
+declare function setGlobalConfig(props: GlobalConfigProps): void;
+export declare function globalConfig(): GlobalConfig;
+export declare function isMotionDisabled(motion: UiMotionConfig | undefined): boolean;
+export declare function normalizeUiSize(size: Exclude<UiSize, "xs"> | undefined, fallback?: UiVisualSize): UiVisualSize;
+export declare function useConfig(): UiConfig;
+export interface ConfigProviderType extends FC<ConfigProviderProps> {
+    readonly ConfigConsumer: typeof ConfigConsumer;
+    readonly ConfigContext: typeof ConfigContext;
+    readonly config: typeof setGlobalConfig;
+    readonly useConfig: typeof useConfig;
+}
+export declare const ConfigProvider: ConfigProviderType;
+export default ConfigProvider;

package/dist/types/antd-theme.d.ts

@@ -0,0 +1,12 @@
+import { type ThemeConfig } from "@996-design/996-antd";
+export type Antd996ColorScheme = "dark" | "light";
+/**
+ * 996UX changes AntD's visual tokens only. Component state machines, event
+ * ordering, keyboard behavior and imperative refs remain owned by the exact
+ * AntD 6.5.1 source mirror.
+ */
+export declare const antd996DarkTheme: ThemeConfig;
+export declare const antd996LightTheme: ThemeConfig;
+export declare function getAntd996Theme(colorScheme: Antd996ColorScheme): ThemeConfig;
+/** @deprecated Use `antd996DarkTheme` when the color scheme should be explicit. */
+export declare const antd996Theme: ThemeConfig;

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

@@ -0,0 +1,51 @@
+import type { AriaAttributes, ErrorInfo, HTMLAttributes, MouseEventHandler, ReactNode } from "react";
+import { PureComponent } from "react";
+export type AlertType = "success" | "info" | "warning" | "error";
+export type AlertVariant = "outlined" | "filled";
+export interface AlertClosableConfig extends AriaAttributes {
+    readonly afterClose?: () => void;
+    readonly closeIcon?: ReactNode;
+    readonly disabled?: boolean;
+    readonly onClose?: MouseEventHandler<HTMLButtonElement>;
+}
+export interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, "onClose" | "title"> {
+    readonly action?: ReactNode;
+    readonly afterClose?: () => void;
+    readonly banner?: boolean;
+    readonly closable?: boolean | AlertClosableConfig;
+    readonly closeIcon?: ReactNode;
+    readonly closeText?: ReactNode;
+    readonly description?: ReactNode;
+    readonly icon?: ReactNode;
+    /** @deprecated Use `title` instead. */
+    readonly message?: ReactNode;
+    readonly rootClassName?: string;
+    readonly showIcon?: boolean;
+    readonly title?: ReactNode;
+    readonly type?: AlertType;
+    readonly variant?: AlertVariant;
+    /** @deprecated Use `closable.onClose` instead. */
+    readonly onClose?: MouseEventHandler<HTMLButtonElement>;
+}
+export interface AlertErrorBoundaryProps {
+    readonly children?: ReactNode;
+    readonly description?: ReactNode;
+    readonly id?: string;
+    /** @deprecated Use `title` instead. */
+    readonly message?: ReactNode;
+    readonly title?: ReactNode;
+}
+interface AlertErrorBoundaryState {
+    readonly error?: Error;
+    readonly info?: ErrorInfo;
+}
+declare function AlertRoot({ action, afterClose, banner, className, closable, closeIcon, closeText, description, icon, message, onClose, rootClassName, showIcon, style, title, type: customType, variant, ...props }: AlertProps): import("react").JSX.Element;
+declare class AlertErrorBoundary extends PureComponent<AlertErrorBoundaryProps, AlertErrorBoundaryState> {
+    state: AlertErrorBoundaryState;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export declare const Alert: typeof AlertRoot & {
+    ErrorBoundary: typeof AlertErrorBoundary;
+};
+export {};

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

@@ -0,0 +1,44 @@
+import type { CSSProperties, HTMLAttributes, ReactNode } from "react";
+import { type PopoverProps } from "./Popover";
+export type AvatarShape = "circle" | "square";
+export type AvatarNamedSize = "small" | "medium" | "middle" | "default" | "large";
+export type AvatarResponsiveSize = Partial<Record<"xs" | "sm" | "md" | "lg" | "xl" | "xxl", number>>;
+export type AvatarSize = AvatarNamedSize | AvatarResponsiveSize | number;
+export interface AvatarProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onError"> {
+    readonly alt?: string;
+    readonly crossOrigin?: "" | "anonymous" | "use-credentials";
+    readonly draggable?: boolean | "true" | "false";
+    readonly gap?: number;
+    readonly icon?: ReactNode;
+    readonly rootClassName?: string;
+    readonly shape?: AvatarShape;
+    readonly size?: AvatarSize;
+    readonly src?: ReactNode;
+    readonly srcSet?: string;
+    readonly onError?: () => boolean | undefined;
+}
+export interface AvatarGroupMaxConfig {
+    readonly count?: number;
+    readonly popover?: Omit<PopoverProps, "children" | "content">;
+    readonly style?: CSSProperties;
+}
+export interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    readonly max?: AvatarGroupMaxConfig;
+    /** @deprecated Use `max.count` instead. */
+    readonly maxCount?: number;
+    /** @deprecated Use `max.popover.placement` instead. */
+    readonly maxPopoverPlacement?: PopoverProps["placement"];
+    /** @deprecated Use `max.popover.trigger` instead. */
+    readonly maxPopoverTrigger?: PopoverProps["trigger"];
+    /** @deprecated Use `max.style` instead. */
+    readonly maxStyle?: CSSProperties;
+    readonly rootClassName?: string;
+    readonly shape?: AvatarShape;
+    readonly size?: AvatarSize;
+}
+declare function AvatarRoot({ alt, children, className, crossOrigin, draggable, gap, icon, onError, rootClassName, shape, size, src, srcSet, style, ...props }: AvatarProps): import("react").JSX.Element;
+declare function AvatarGroup({ children, className, max, maxCount, maxPopoverPlacement, maxPopoverTrigger, maxStyle, rootClassName, shape, size, ...props }: AvatarGroupProps): import("react").JSX.Element;
+export declare const Avatar: typeof AvatarRoot & {
+    Group: typeof AvatarGroup;
+};
+export {};

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

@@ -0,0 +1,31 @@
+import type { CSSProperties, HTMLAttributes, ReactNode } from "react";
+export type BadgeStatus = "success" | "processing" | "default" | "error" | "warning";
+export type BadgeSize = "small" | "medium" | "middle" | "default";
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, "title"> {
+    readonly color?: string;
+    readonly count?: ReactNode;
+    readonly dot?: boolean;
+    readonly offset?: readonly [number | string, number | string];
+    readonly overflowCount?: number;
+    readonly rootClassName?: string;
+    readonly showZero?: boolean;
+    readonly size?: BadgeSize;
+    readonly status?: BadgeStatus;
+    readonly text?: ReactNode;
+    readonly title?: string | null | false;
+}
+export interface BadgeRibbonProps {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly color?: string;
+    readonly placement?: "start" | "end";
+    readonly rootClassName?: string;
+    readonly style?: CSSProperties;
+    readonly text?: ReactNode;
+}
+declare function BadgeRoot({ children, className, color, count, dot, offset, overflowCount, rootClassName, showZero, size, status, text, title, style, ...props }: BadgeProps): import("react").JSX.Element;
+declare function Ribbon({ children, className, color, placement, rootClassName, style, text, }: BadgeRibbonProps): import("react").JSX.Element;
+export declare const Badge: typeof BadgeRoot & {
+    Ribbon: typeof Ribbon;
+};
+export {};

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

@@ -0,0 +1,45 @@
+import type { AriaAttributes, CSSProperties, HTMLAttributes, MouseEventHandler, ReactNode } from "react";
+import { type DropdownProps } from "./Dropdown";
+export interface BreadcrumbItem extends AriaAttributes {
+    readonly breadcrumbName?: string;
+    readonly className?: string;
+    readonly dropdownProps?: Omit<DropdownProps, "children" | "menu">;
+    readonly href?: string;
+    readonly key?: string | number;
+    readonly menu?: DropdownProps["menu"];
+    readonly path?: string;
+    readonly separator?: ReactNode;
+    readonly style?: CSSProperties;
+    readonly title?: ReactNode;
+    readonly type?: "separator";
+    readonly onClick?: MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
+}
+export interface BreadcrumbProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    readonly children?: ReactNode;
+    readonly dropdownIcon?: ReactNode;
+    readonly itemRender?: (route: BreadcrumbItem, params: T, routes: readonly BreadcrumbItem[], paths: string[]) => ReactNode;
+    readonly items?: readonly BreadcrumbItem[];
+    readonly params?: T;
+    readonly rootClassName?: string;
+    /** @deprecated Use `items` instead. */
+    readonly routes?: readonly BreadcrumbItem[];
+    readonly separator?: ReactNode;
+}
+export interface BreadcrumbItemProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    readonly dropdownIcon?: ReactNode;
+    readonly dropdownProps?: Omit<DropdownProps, "children" | "menu">;
+    readonly href?: string;
+    readonly menu?: DropdownProps["menu"];
+    readonly separator?: ReactNode;
+}
+export interface BreadcrumbSeparatorProps extends HTMLAttributes<HTMLLIElement> {
+    readonly children?: ReactNode;
+}
+declare function BreadcrumbSeparator({ children, className, ...props }: BreadcrumbSeparatorProps): import("react").JSX.Element;
+declare function BreadcrumbItemComponent({ children, className, dropdownIcon, dropdownProps, href, menu, onClick, separator: _separator, style, ...props }: BreadcrumbItemProps): import("react").JSX.Element;
+declare function BreadcrumbRoot<T extends Record<string, unknown> = Record<string, unknown>>({ children, className, dropdownIcon, itemRender, items, params, rootClassName, routes, separator, ...props }: BreadcrumbProps<T>): import("react").JSX.Element;
+export declare const Breadcrumb: typeof BreadcrumbRoot & {
+    Item: typeof BreadcrumbItemComponent;
+    Separator: typeof BreadcrumbSeparator;
+};
+export {};

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

@@ -0,0 +1,42 @@
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, HTMLAttributes, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type ButtonType = "default" | "primary" | "dashed" | "link" | "text";
+export type ButtonColor = "default" | "primary" | "danger" | "blue" | "purple" | "cyan" | "green" | "magenta" | "pink" | "red" | "orange" | "yellow" | "volcano" | "geekblue" | "lime" | "gold" | "success" | "info" | "purchase" | "download";
+export type ButtonShape = "default" | "circle" | "round" | "square";
+export type ButtonTone = "primary" | "default" | "secondary" | "ghost" | "danger" | "success" | "info" | "light" | "purchase" | "download";
+export type AntdButtonVariant = "outlined" | "dashed" | "solid" | "filled" | "text" | "link";
+export type ButtonVariant = AntdButtonVariant | "secondary" | "translucent" | "toggle" | "icon";
+export type AntdButtonSize = "small" | "medium" | "middle" | "large";
+export type ButtonSize = AntdButtonSize | "xs" | "sm" | "md" | "lg";
+export type ButtonStatus = "default" | "hover" | "active";
+export type ButtonWidth = "default" | "narrow" | "auto";
+type ButtonSlot = "root" | "icon" | "content" | "loadingIcon";
+type MergedButtonHtmlAttributes = Omit<HTMLAttributes<HTMLElement> & ButtonHTMLAttributes<HTMLElement> & AnchorHTMLAttributes<HTMLElement>, "color" | "type">;
+export interface ButtonProps extends MergedButtonHtmlAttributes {
+    readonly autoInsertSpace?: boolean;
+    readonly block?: boolean;
+    readonly classNames?: SlotClassNames<ButtonSlot>;
+    readonly color?: ButtonColor;
+    readonly danger?: boolean;
+    readonly ghost?: boolean;
+    readonly href?: string;
+    readonly htmlType?: ButtonHTMLAttributes<HTMLButtonElement>["type"];
+    readonly icon?: ReactNode;
+    readonly iconPosition?: "start" | "end";
+    readonly iconPlacement?: "start" | "end";
+    readonly loading?: boolean | {
+        readonly delay?: number;
+        readonly icon?: ReactNode;
+    };
+    readonly rootClassName?: string;
+    readonly shape?: ButtonShape;
+    readonly styles?: SlotStyles<ButtonSlot>;
+    readonly status?: ButtonStatus;
+    readonly tone?: ButtonTone;
+    readonly size?: ButtonSize;
+    readonly type?: ButtonType;
+    readonly variant?: ButtonVariant;
+    readonly width?: ButtonWidth;
+}
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+export {};

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

@@ -0,0 +1,13 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+type ButtonGroupSlot = "root";
+export interface ButtonGroupProps extends HTMLAttributes<HTMLDivElement> {
+    readonly attached?: boolean;
+    readonly block?: boolean;
+    readonly children: ReactNode;
+    readonly classNames?: SlotClassNames<ButtonGroupSlot>;
+    readonly separated?: boolean;
+    readonly styles?: SlotStyles<ButtonGroupSlot>;
+}
+export declare function ButtonGroup({ attached, block, children, className, classNames, separated, style, styles, ...props }: ButtonGroupProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,55 @@
+import type { CSSProperties, HTMLAttributes, ReactElement, ReactNode } from "react";
+import { type TabsProps } from "./Tabs";
+export type CardSize = "small" | "medium" | "middle" | "default";
+export type CardVariant = "borderless" | "outlined";
+export interface CardTabListType {
+    readonly disabled?: boolean;
+    readonly key: string;
+    readonly label?: ReactNode;
+    /** @deprecated Use `label` instead. */
+    readonly tab?: ReactNode;
+}
+export interface CardProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    readonly actions?: readonly ReactNode[];
+    readonly activeTabKey?: string;
+    readonly as?: "article" | "section" | "div" | "button";
+    /** @deprecated Use `styles.body` instead. */
+    readonly bodyStyle?: CSSProperties;
+    /** @deprecated Use `variant` instead. */
+    readonly bordered?: boolean;
+    readonly cover?: ReactNode;
+    readonly defaultActiveTabKey?: string;
+    readonly extra?: ReactNode;
+    /** @deprecated Use `styles.header` instead. */
+    readonly headStyle?: CSSProperties;
+    readonly hoverable?: boolean;
+    readonly interactive?: boolean;
+    readonly loading?: boolean;
+    readonly rootClassName?: string;
+    readonly selected?: boolean;
+    readonly size?: CardSize;
+    readonly styles?: Partial<Record<"actions" | "body" | "cover" | "extra" | "header" | "root" | "title", CSSProperties>>;
+    readonly tabBarExtraContent?: ReactNode;
+    readonly tabList?: readonly CardTabListType[];
+    readonly tabProps?: Omit<TabsProps, "items">;
+    readonly title?: ReactNode;
+    readonly type?: "inner" | "button";
+    readonly variant?: CardVariant;
+    readonly onTabChange?: (key: string) => void;
+}
+export interface CardMetaProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    readonly avatar?: ReactNode;
+    readonly description?: ReactNode;
+    readonly title?: ReactNode;
+}
+export interface CardGridProps extends HTMLAttributes<HTMLDivElement> {
+    readonly hoverable?: boolean;
+}
+declare function CardMeta({ avatar, children, className, description, title, ...props }: CardMetaProps): import("react").JSX.Element;
+declare function CardGrid({ children, className, hoverable, ...props }: CardGridProps): import("react").JSX.Element;
+declare function CardRoot({ actions, activeTabKey, as: Component, bodyStyle, bordered, children, className, cover, defaultActiveTabKey, extra, headStyle, hoverable, interactive, loading, onTabChange, rootClassName, selected, size, style, styles, tabBarExtraContent, tabList, tabProps, title, type, variant, ...props }: CardProps): ReactElement;
+export declare const Card: typeof CardRoot & {
+    Grid: typeof CardGrid;
+    Meta: typeof CardMeta;
+};
+export {};

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

@@ -0,0 +1,70 @@
+import Slider, { type Settings as SlickSettings } from "@996-design/996-slick";
+import { type CSSProperties, type ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type Settings = SlickSettings;
+export type CarouselEffect = "scrollx" | "fade";
+export type DotPlacement = "top" | "bottom" | "start" | "end";
+export type CarouselAutoPlayType = "update" | "leave" | "blur";
+type SliderRef = InstanceType<typeof Slider>;
+type SlickInnerSlider = NonNullable<SliderRef["innerSlider"]> & {
+    autoPlay: (playType?: CarouselAutoPlayType) => void;
+};
+export interface CarouselRef {
+    autoPlay: (playType?: CarouselAutoPlayType) => void;
+    goTo: (slide: number, dontAnimate?: boolean) => void;
+    innerSlider: SlickInnerSlider | null;
+    next: () => void;
+    prev: () => void;
+}
+export interface CarouselItem {
+    readonly alt?: string;
+    readonly content?: ReactNode;
+    readonly id: string;
+    readonly imageUrl?: string;
+}
+/** @deprecated Use the AntD-compatible `dots` prop instead. */
+export type CarouselIndicator = "dots" | "none";
+type CarouselSlot = "root" | "viewport" | "track" | "slide" | "image" | "placeholder" | "arrow" | "prev" | "next" | "indicators" | "indicator";
+export interface CarouselProps extends Omit<SlickSettings, "autoplay" | "dots" | "dotsClass"> {
+    readonly autoplay?: boolean | {
+        readonly dotDuration?: boolean;
+    };
+    readonly children?: ReactNode;
+    readonly classNames?: SlotClassNames<CarouselSlot>;
+    readonly dotPlacement?: DotPlacement;
+    /** @deprecated Use `dotPlacement` instead. */
+    readonly dotPosition?: DotPlacement | "left" | "right";
+    readonly dots?: boolean | {
+        readonly className?: string;
+    };
+    readonly effect?: CarouselEffect;
+    readonly id?: string;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly slickGoTo?: number;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<CarouselSlot>;
+    readonly waitForAnimate?: boolean;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `initialSlide` and the ref API. */
+    readonly activeIndex?: number;
+    /** @deprecated Additive adapter for the former 996 Carousel API. */
+    readonly ariaLabel?: string;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `dots`. */
+    readonly indicator?: CarouselIndicator;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Render slides as children. */
+    readonly items?: readonly CarouselItem[];
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `nextArrow`. */
+    readonly nextAriaLabel?: string;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `afterChange`. */
+    readonly onChange?: (index: number) => void;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Put the handler on slide children. */
+    readonly onItemClick?: () => void;
+    /** @deprecated Additive adapter for the former 996 Carousel API. */
+    readonly placeholder?: ReactNode;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `prevArrow`. */
+    readonly prevAriaLabel?: string;
+    /** @deprecated Additive adapter for the former 996 Carousel API. Use `arrows`. */
+    readonly showArrows?: boolean;
+}
+export declare const Carousel: import("react").ForwardRefExoticComponent<CarouselProps & import("react").RefAttributes<CarouselRef>>;
+export {};

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

@@ -0,0 +1,43 @@
+import type { CheckboxChangeEvent, CheckboxRef, CheckboxProps as RcCheckboxProps } from "@rc-component/checkbox";
+import type { CSSProperties, HTMLAttributes, ReactElement, ReactNode, RefAttributes } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type CheckboxStatus = "default" | "hover" | "active";
+export type CheckboxValueType = string | number | boolean;
+export type { CheckboxChangeEvent, CheckboxRef };
+type CheckboxSlot = "root" | "input" | "control" | "icon" | "label";
+export interface CheckboxProps<ValueType = CheckboxValueType> extends Omit<RcCheckboxProps, "children" | "className" | "onChange" | "prefixCls" | "style" | "value"> {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<CheckboxSlot>;
+    readonly indeterminate?: boolean;
+    readonly label?: ReactNode;
+    readonly rootClassName?: string;
+    readonly skipGroup?: boolean;
+    readonly status?: CheckboxStatus;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<CheckboxSlot>;
+    readonly value?: ValueType;
+    readonly onChange?: (event: CheckboxChangeEvent) => void;
+}
+export interface CheckboxOptionType<ValueType = CheckboxValueType> extends Omit<CheckboxProps<ValueType>, "checked" | "children" | "defaultChecked" | "label" | "skipGroup"> {
+    readonly label: ReactNode;
+    readonly value: ValueType;
+}
+export interface CheckboxGroupProps<ValueType = CheckboxValueType> extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    readonly children?: ReactNode;
+    readonly defaultValue?: readonly ValueType[];
+    readonly disabled?: boolean;
+    readonly name?: string;
+    readonly options?: readonly (CheckboxOptionType<ValueType> | string | number)[];
+    readonly orientation?: "horizontal" | "vertical";
+    readonly rootClassName?: string;
+    readonly value?: readonly ValueType[];
+    readonly vertical?: boolean;
+    readonly onChange?: (checkedValue: ValueType[]) => void;
+}
+type CheckboxStandaloneComponent = <ValueType = CheckboxValueType>(props: CheckboxProps<ValueType> & RefAttributes<CheckboxRef>) => ReactElement;
+type CheckboxGroupComponent = <ValueType = CheckboxValueType>(props: CheckboxGroupProps<ValueType> & RefAttributes<HTMLDivElement>) => ReactElement;
+type CheckboxCompoundComponent = CheckboxStandaloneComponent & {
+    readonly Group: CheckboxGroupComponent;
+};
+export declare const Checkbox: CheckboxCompoundComponent;

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

@@ -0,0 +1,23 @@
+import type { CollapsePanelProps as RcCollapsePanelProps, CollapseProps as RcCollapseProps } from "@rc-component/collapse";
+import type { ItemType as RcCollapseItem } from "@rc-component/collapse/es/interface";
+import type { CSSProperties } from "react";
+export type CollapseItem = RcCollapseItem;
+export type CollapseSize = "small" | "medium" | "middle" | "large";
+export type CollapseExpandIconPosition = "start" | "end";
+export type CollapsePanelProps = Omit<RcCollapsePanelProps, "prefixCls">;
+export interface CollapseProps extends Omit<RcCollapseProps, "items" | "onChange" | "prefixCls" | "style"> {
+    readonly bordered?: boolean;
+    readonly destroyInactivePanel?: boolean;
+    readonly expandIconPlacement?: CollapseExpandIconPosition;
+    readonly expandIconPosition?: CollapseExpandIconPosition;
+    readonly ghost?: boolean;
+    readonly items?: readonly CollapseItem[];
+    readonly rootClassName?: string;
+    readonly size?: CollapseSize;
+    readonly style?: CSSProperties;
+    readonly onActiveKeyChange?: (key: string | string[]) => void;
+    readonly onChange?: (key: string[]) => void;
+}
+export declare const Collapse: import("react").ForwardRefExoticComponent<CollapseProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Panel: import("react").ForwardRefExoticComponent<CollapsePanelProps & import("react").RefAttributes<HTMLDivElement>>;
+};