@996-design/996-ui 0.1.0

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

@@ -0,0 +1,42 @@
+import type { ReactNode } from "react";
+import type { SegmentedLabeledOption, SegmentedProps, SegmentedSize, SegmentedValue } from "./Segmented";
+export type SegmentedTabSize = SegmentedSize;
+export type SegmentedTabAppearance = "boxed" | "glow-pill" | "plain" | "segmented";
+/**
+ * @deprecated Use `SegmentedTabAppearance`. This alias only selects a legacy
+ * Segmented visual and does not provide Tabs behavior.
+ */
+export type SegmentedTabsType = "line" | "boxed" | "segmented" | "glow-pill";
+/**
+ * @deprecated SegmentedTabs does not render a Tabs indicator. This type is
+ * retained only for the legacy `indicator` visual adapter.
+ */
+export type SegmentedTabIndicator = "ink" | "none";
+export interface SegmentedTabItem<T extends SegmentedValue> extends Omit<SegmentedLabeledOption<T>, "label" | "value"> {
+    readonly id: T;
+    readonly label: ReactNode;
+}
+export interface SegmentedTabsProps<T extends SegmentedValue = SegmentedValue> extends Omit<SegmentedProps<T>, "items" | "options" | "shape" | "size"> {
+    /** 996-owned visual treatment over the Segmented selection control. */
+    readonly appearance?: SegmentedTabAppearance;
+    /**
+     * @deprecated SegmentedTabs does not expose Tabs animation contracts.
+     * `false` only disables the legacy rc-segmented thumb transition class.
+     */
+    readonly animated?: boolean;
+    /** @deprecated Use the native Segmented `block` prop. */
+    readonly fullWidth?: boolean;
+    /**
+     * @deprecated SegmentedTabs does not render a Tabs indicator. `none` only
+     * suppresses the rc-segmented thumb for the plain legacy appearance.
+     */
+    readonly indicator?: SegmentedTabIndicator;
+    readonly items: readonly SegmentedTabItem<T>[];
+    readonly size?: SegmentedTabSize;
+    /**
+     * @deprecated Use `appearance`. This prop is a visual compatibility adapter
+     * only and does not provide Tabs type or pane behavior.
+     */
+    readonly type?: SegmentedTabsType;
+}
+export declare function SegmentedTabs<T extends SegmentedValue>(props: SegmentedTabsProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,33 @@
+import type { ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+import type { InputProps, InputSize, InputStatus, InputVariant } from "./Input";
+export interface SelectInputOption {
+    readonly disabled?: boolean;
+    readonly label: ReactNode;
+    readonly suffix?: ReactNode;
+    readonly value: string;
+}
+type SelectInputSlot = "root" | "input" | "popup" | "option" | "suffix";
+export interface SelectInputProps extends Omit<InputProps, "classNames" | "onChange" | "styles" | "suffix" | "value"> {
+    readonly activeFirstOption?: boolean;
+    readonly activeValue?: string;
+    readonly classNames?: SlotClassNames<SelectInputSlot>;
+    readonly defaultValue?: string;
+    readonly defaultPopupOpen?: boolean;
+    readonly displayValue?: string;
+    readonly onChange?: (value: string, option?: SelectInputOption) => void;
+    readonly onPopupOpenChange?: (open: boolean) => void;
+    readonly options: readonly SelectInputOption[];
+    readonly popupMatchInputWidth?: boolean;
+    readonly popupOffset?: number;
+    readonly popupOpen?: boolean;
+    readonly placeholder?: string;
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly styles?: SlotStyles<SelectInputSlot>;
+    readonly suffixIcon?: ReactNode;
+    readonly value?: string;
+    readonly variant?: InputVariant;
+}
+export declare function SelectInput({ activeFirstOption, activeValue, allowClear, autoFocus, className, classNames, defaultPopupOpen, defaultValue, disabled, displayValue, id, onBlur, onChange, onClick, onFocus, onKeyDown, onPopupOpenChange, options, placeholder, popupMatchInputWidth, popupOffset, popupOpen, prefix, size, status, style, styles, suffixIcon, tabIndex, title, value, variant, }: SelectInputProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,54 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+type SkeletonSlot = "root" | "header" | "avatar" | "section" | "title" | "paragraph" | "row" | "element";
+export type SkeletonSize = "small" | "medium" | "middle" | "default" | "large" | "sm" | "md" | "lg" | number;
+export type SkeletonShape = "circle" | "square" | "round" | "default";
+export interface SkeletonProps {
+    readonly active?: boolean;
+    readonly avatar?: boolean | {
+        readonly size?: SkeletonSize;
+        readonly shape?: "circle" | "square";
+    };
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<SkeletonSlot>;
+    readonly loading?: boolean;
+    readonly paragraph?: boolean | {
+        readonly rows?: number;
+        readonly width?: number | string | readonly (number | string)[];
+    };
+    readonly round?: boolean;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<SkeletonSlot>;
+    readonly title?: boolean | {
+        readonly width?: number | string;
+    };
+}
+export interface SkeletonElementProps {
+    readonly active?: boolean;
+    readonly className?: string;
+    readonly shape?: SkeletonShape;
+    readonly size?: SkeletonSize;
+    readonly style?: CSSProperties;
+}
+export interface SkeletonButtonProps extends SkeletonElementProps {
+    readonly block?: boolean;
+}
+declare function SkeletonElement({ active, className, shape, size, style, }: SkeletonElementProps): import("react").JSX.Element;
+declare function SkeletonButton({ active, block, className, shape, size, style, }: SkeletonButtonProps): import("react").JSX.Element;
+declare function SkeletonAvatar(props: SkeletonElementProps): import("react").JSX.Element;
+declare function SkeletonInput({ active, block, className, size, style, }: SkeletonButtonProps): import("react").JSX.Element;
+declare function SkeletonImage({ active, className, style }: SkeletonElementProps): import("react").JSX.Element;
+declare function SkeletonNode({ active, children, className, style, }: SkeletonElementProps & {
+    readonly children?: ReactNode;
+}): import("react").JSX.Element;
+declare function SkeletonRoot({ active, avatar, children, className, classNames, loading, paragraph, round, style, styles, title, }: SkeletonProps): 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;
+export declare const Skeleton: typeof SkeletonRoot & {
+    Avatar: typeof SkeletonAvatar;
+    Button: typeof SkeletonButton;
+    Element: typeof SkeletonElement;
+    Image: typeof SkeletonImage;
+    Input: typeof SkeletonInput;
+    Node: typeof SkeletonNode;
+};
+export {};

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

@@ -0,0 +1,48 @@
+import type { SliderProps as RcSliderProps, SliderRef as RcSliderRef } from "@rc-component/slider";
+import type { CSSProperties, ReactElement, ReactNode, RefAttributes } from "react";
+import type { TooltipProps } from "./Tooltip";
+export type SliderValue = number | number[];
+export type SliderRef = RcSliderRef;
+export type SliderMarks = RcSliderProps["marks"];
+export type SliderFormatter = ((value?: number) => ReactNode) | null;
+export type SliderSemanticSlot = "root" | "tracks" | "track" | "rail" | "handle";
+type SliderSemanticClassNameMap = Partial<Record<SliderSemanticSlot, string>>;
+type SliderSemanticStyleMap = Partial<Record<SliderSemanticSlot, CSSProperties>>;
+export type SliderClassNames = SliderSemanticClassNameMap | ((info: {
+    props: SliderProps<SliderValue>;
+}) => SliderSemanticClassNameMap);
+export type SliderStyles = SliderSemanticStyleMap | ((info: {
+    props: SliderProps<SliderValue>;
+}) => SliderSemanticStyleMap);
+export interface SliderTooltipProps extends Omit<TooltipProps, "children" | "title"> {
+    readonly formatter?: SliderFormatter;
+}
+export type SliderProps<ValueType extends SliderValue = number> = Omit<RcSliderProps<ValueType>, "classNames" | "prefixCls" | "styles"> & {
+    readonly classNames?: SliderClassNames;
+    readonly orientation?: "horizontal" | "vertical";
+    readonly rootClassName?: string;
+    readonly styles?: SliderStyles;
+    readonly tooltip?: SliderTooltipProps;
+    /** @deprecated Use `tooltip.formatter`. */
+    readonly tipFormatter?: SliderFormatter;
+    /** @deprecated Use `tooltip.getPopupContainer`. */
+    readonly getTooltipPopupContainer?: SliderTooltipProps["getPopupContainer"];
+    /** @deprecated Use `tooltip.placement`. */
+    readonly tooltipPlacement?: SliderTooltipProps["placement"];
+    /** @deprecated Use `tooltip.open`. */
+    readonly tooltipVisible?: boolean;
+};
+export type SliderRange = Exclude<NonNullable<RcSliderProps<number[]>["range"]>, boolean>;
+export type SliderSingleProps = SliderProps<number> & {
+    readonly range?: false;
+};
+export type SliderRangeProps = SliderProps<number[]> & {
+    readonly range: true | SliderRange;
+};
+type SliderComponent = {
+    (props: SliderRangeProps & RefAttributes<RcSliderRef>): ReactElement;
+    (props: SliderSingleProps & RefAttributes<RcSliderRef>): ReactElement;
+    <ValueType extends SliderValue = number>(props: SliderProps<ValueType> & RefAttributes<RcSliderRef>): ReactElement;
+};
+export declare const Slider: SliderComponent;
+export {};

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

@@ -0,0 +1,21 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export type SpinSize = "small" | "medium" | "middle" | "default" | "large";
+export interface SpinProps extends HTMLAttributes<HTMLDivElement> {
+    readonly delay?: number;
+    readonly description?: ReactNode;
+    readonly fullscreen?: boolean;
+    readonly indicator?: ReactNode;
+    readonly percent?: number | "auto";
+    readonly rootClassName?: string;
+    readonly size?: SpinSize;
+    readonly spinning?: boolean;
+    /** @deprecated Use `description` instead. */
+    readonly tip?: ReactNode;
+    /** @deprecated Use the root semantic class in AntD-compatible code. */
+    readonly wrapperClassName?: string;
+}
+declare function SpinRoot({ children, className, delay, description, fullscreen, indicator, percent, rootClassName, size, spinning, style, tip, wrapperClassName, ...props }: SpinProps): import("react").JSX.Element | null;
+export declare const Spin: typeof SpinRoot & {
+    setDefaultIndicator(indicator: ReactNode): void;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import { SplitterPanel } from "./splitter/Panel";
+import type { SplitterPanelProps, SplitterProps } from "./splitter/interface";
+export type { ShowCollapsibleIconMode, SplitterClassNames, SplitterDraggerClassName, SplitterDraggerStyle, SplitterOrientation, SplitterPanelProps, SplitterProps, SplitterStyles, } from "./splitter/interface";
+export declare const Splitter: import("react").ForwardRefExoticComponent<SplitterProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Panel: typeof SplitterPanel;
+};
+export type { SplitterPanelProps as PanelProps };

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

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+interface StatCardProps {
+    readonly accent?: ReactNode;
+    readonly className?: string;
+    readonly label: ReactNode;
+    readonly meta?: ReactNode;
+    readonly value: ReactNode;
+}
+export declare function StatCard({ accent, className, label, meta, value }: StatCardProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,48 @@
+import type { CSSProperties, HTMLAttributes, ReactNode } from "react";
+export type StatisticValue = number | string;
+export type StatisticSemanticSlot = "root" | "header" | "title" | "content" | "value" | "prefix" | "suffix";
+export interface StatisticRef {
+    readonly nativeElement: HTMLDivElement;
+}
+export interface StatisticFormatConfig {
+    readonly decimalSeparator?: string;
+    readonly formatter?: StatisticFormatter;
+    readonly groupSeparator?: string;
+    readonly precision?: number;
+}
+export type StatisticFormatter = false | "number" | "countdown" | ((value: StatisticValue, config?: StatisticFormatConfig) => ReactNode);
+export interface StatisticProps extends Omit<HTMLAttributes<HTMLDivElement>, "prefix" | "title">, StatisticFormatConfig {
+    readonly loading?: boolean;
+    readonly classNames?: Partial<Record<StatisticSemanticSlot, string>>;
+    readonly prefix?: ReactNode;
+    readonly rootClassName?: string;
+    readonly styles?: Partial<Record<StatisticSemanticSlot, CSSProperties>>;
+    readonly suffix?: ReactNode;
+    readonly title?: ReactNode;
+    readonly value?: StatisticValue;
+    readonly valueRender?: (node: ReactNode) => ReactNode;
+    /** @deprecated Use `styles.content` in AntD-compatible code. */
+    readonly valueStyle?: CSSProperties;
+}
+export type StatisticTimerType = "countdown" | "countup";
+export interface StatisticTimerProps extends Omit<StatisticProps, "onChange"> {
+    readonly format?: string;
+    readonly onChange?: (value?: StatisticValue) => void;
+    /** Called only when a countdown crosses its target time. */
+    readonly onFinish?: () => void;
+    readonly type: StatisticTimerType;
+}
+export interface CountdownProps extends Omit<StatisticProps, "onChange"> {
+    readonly format?: string;
+    readonly onChange?: (value?: StatisticValue) => void;
+    readonly onFinish?: () => void;
+}
+export declare function formatStatisticTime(duration: number, format: string): string;
+declare function StatisticTimer({ format, onChange, onFinish, type, value, ...props }: StatisticTimerProps): import("react").JSX.Element;
+declare function StatisticCountdown(props: CountdownProps): import("react").JSX.Element;
+export declare const Statistic: import("react").ForwardRefExoticComponent<StatisticProps & import("react").RefAttributes<StatisticRef>> & {
+    /** @deprecated Use `Statistic.Timer` with `type="countdown"`. */
+    Countdown: import("react").MemoExoticComponent<typeof StatisticCountdown>;
+    Timer: typeof StatisticTimer;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+interface StatusItemProps {
+    readonly className?: string;
+    readonly icon?: ReactNode;
+    readonly label: string;
+    readonly max?: number;
+    readonly orientation?: "column" | "row";
+    readonly progress?: number;
+    readonly value: string;
+}
+export declare function StatusItem({ className, icon, label, max, orientation, progress, value, }: StatusItemProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,40 @@
+import type { StepsProps as RcStepsProps } from "@rc-component/steps";
+import type { Key, ReactNode } from "react";
+export type StepStatus = "wait" | "process" | "finish" | "error";
+export type StepsSize = "small" | "medium" | "middle" | "default";
+export type StepsType = "default" | "navigation" | "inline" | "panel" | "dot";
+export type StepsVariant = "filled" | "outlined";
+export type StepsOrientation = "horizontal" | "vertical";
+export type StepsTitlePlacement = "horizontal" | "vertical";
+type RcStepItem = NonNullable<RcStepsProps["items"]>[number];
+type RcIconRenderInfo = Parameters<NonNullable<RcStepsProps["iconRender"]>>[1];
+export type StepItem = RcStepItem & {
+    readonly key?: Key;
+};
+export type ProgressDotRender = (iconDot: ReactNode, info: {
+    readonly content: ReactNode;
+    readonly description: ReactNode;
+    readonly index: number;
+    readonly status: StepStatus;
+    readonly title: ReactNode;
+}) => ReactNode;
+export type StepsIconRender = (originNode: ReactNode, info: Pick<RcIconRenderInfo, "active" | "index" | "item" | "components">) => ReactNode;
+export interface StepsProps extends Omit<RcStepsProps, "iconRender" | "items" | "orientation" | "prefixCls" | "titlePlacement"> {
+    readonly direction?: StepsOrientation;
+    readonly ellipsis?: boolean;
+    readonly iconRender?: StepsIconRender;
+    readonly items?: readonly StepItem[];
+    readonly labelPlacement?: StepsTitlePlacement;
+    readonly maxCount?: number;
+    readonly offset?: number;
+    readonly orientation?: StepsOrientation;
+    readonly percent?: number;
+    readonly progressDot?: boolean | ProgressDotRender;
+    readonly responsive?: boolean;
+    readonly size?: StepsSize;
+    readonly titlePlacement?: StepsTitlePlacement;
+    readonly type?: StepsType;
+    readonly variant?: StepsVariant;
+}
+export declare function Steps({ className, current, direction, ellipsis, iconRender, initial, items, labelPlacement, maxCount, offset, onChange, orientation, percent, progressDot, responsive, rootClassName, size, style, titlePlacement, type, variant, ...props }: StepsProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,41 @@
+import RcSwitch from "@rc-component/switch";
+import type { SwitchChangeEventHandler, SwitchClickEventHandler } from "@rc-component/switch";
+import type { CSSProperties, ComponentPropsWithoutRef, ReactNode } from "react";
+export type SwitchStatus = "default" | "hover" | "active";
+export type SwitchSize = "small" | "medium" | "middle" | "default";
+export type SwitchSemanticSlot = "root" | "content" | "indicator";
+type SwitchLegacySemanticSlot = SwitchSemanticSlot | "thumb";
+export type SwitchClassNames = Partial<Record<SwitchLegacySemanticSlot, string>> | ((info: {
+    props: SwitchProps;
+}) => Partial<Record<SwitchLegacySemanticSlot, string>>);
+export type SwitchStyles = Partial<Record<SwitchLegacySemanticSlot, CSSProperties>> | ((info: {
+    props: SwitchProps;
+}) => Partial<Record<SwitchLegacySemanticSlot, CSSProperties>>);
+export type { SwitchChangeEventHandler, SwitchClickEventHandler };
+export interface SwitchProps extends Omit<ComponentPropsWithoutRef<typeof RcSwitch>, "checked" | "className" | "classNames" | "defaultChecked" | "defaultValue" | "disabled" | "loadingIcon" | "onChange" | "onClick" | "prefixCls" | "style" | "styles" | "value"> {
+    readonly checked?: boolean;
+    readonly checkedChildren?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SwitchClassNames;
+    readonly defaultChecked?: boolean;
+    readonly defaultValue?: boolean;
+    readonly disabled?: boolean;
+    readonly loading?: boolean;
+    /** @deprecated Prefer `loading`; this remains an additive 996 adapter. */
+    readonly loadingIcon?: ReactNode;
+    readonly rootClassName?: string;
+    readonly size?: SwitchSize;
+    readonly status?: SwitchStatus;
+    readonly style?: CSSProperties;
+    readonly styles?: SwitchStyles;
+    readonly unCheckedChildren?: ReactNode;
+    readonly value?: boolean;
+    readonly onChange?: SwitchChangeEventHandler;
+    readonly onClick?: SwitchClickEventHandler;
+}
+declare const InternalSwitch: import("react").ForwardRefExoticComponent<SwitchProps & import("react").RefAttributes<HTMLButtonElement>>;
+type SwitchComponent = typeof InternalSwitch & {
+    /** @internal AntD-compatible marker used by compact/form integrations. */
+    __ANT_SWITCH: boolean;
+};
+export declare const Switch: SwitchComponent;

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

@@ -0,0 +1,61 @@
+import { EXPAND_COLUMN, Summary } from "@rc-component/table";
+import type { TableProps as RcTableProps, Reference as RcTableReference } from "@rc-component/table";
+import type { CSSProperties, Key, ReactElement, ReactNode, RefAttributes } from "react";
+import { type SpinProps } from "./Spin";
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from "./table/selection";
+import type { ColumnsType, FilterValue, SortOrder, TableChangeExtra, TableColumn, TableLocale, TablePaginationConfig, TableRowSelection, TableSorterResult, TableSorterTooltipProps } from "./table/types";
+export type { ColumnFilterItem, ColumnsType, FilterValue, RowSelectMethod, SortOrder, TableAction, TableChangeExtra, TableColumn, TableFilterDropdownProps, TableLocale, TablePaginationConfig, TablePaginationProps, TableRowSelection, TableSelectionItem, TableSelectionPreset, TableSorterResult, TableSorterTooltipProps, TableSorterTooltipTarget, } from "./table/types";
+export type TableRef = RcTableReference;
+type LegacyTableSlot = "root" | "table" | "thead" | "tbody" | "row" | "cell" | "pagination" | "empty" | "loading";
+type TableClassNames<T> = NonNullable<RcTableProps<T>["classNames"]> & Partial<Record<LegacyTableSlot, string>>;
+type TableStyles<T> = NonNullable<RcTableProps<T>["styles"]> & Partial<Record<LegacyTableSlot, CSSProperties>>;
+type ChangeSorter<T> = TableSorterResult<T> | TableSorterResult<T>[];
+export interface TableProps<T> extends Omit<RcTableProps<T>, "className" | "classNames" | "columns" | "data" | "emptyText" | "footer" | "prefixCls" | "rowKey" | "scroll" | "style" | "styles" | "title"> {
+    readonly className?: string;
+    readonly classNames?: TableClassNames<T>;
+    readonly columns?: ColumnsType<T>;
+    readonly data?: readonly T[];
+    readonly dataSource?: readonly T[];
+    readonly emptyText?: ReactNode | (() => ReactNode);
+    readonly footer?: (data: readonly T[]) => ReactNode;
+    readonly getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    readonly hidePaginationWhenSinglePage?: boolean;
+    readonly loading?: boolean | SpinProps;
+    readonly loadingText?: string;
+    readonly locale?: TableLocale;
+    readonly minWidth?: string;
+    readonly pagination?: false | TablePaginationConfig;
+    readonly pageSizeOptions?: readonly number[];
+    readonly rowKey?: keyof T | string | ((record: T, index: number) => Key);
+    readonly rowSelection?: TableRowSelection<T>;
+    readonly scroll?: NonNullable<RcTableProps<T>["scroll"]> & {
+        readonly scrollToFirstRowOnChange?: boolean;
+    };
+    readonly showSorterTooltip?: boolean | TableSorterTooltipProps;
+    readonly sortDirections?: readonly Exclude<SortOrder, null>[];
+    readonly style?: CSSProperties;
+    readonly styles?: TableStyles<T>;
+    readonly title?: (data: readonly T[]) => ReactNode;
+    readonly truncate?: boolean;
+    readonly virtual?: boolean;
+    readonly onChange?: (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: ChangeSorter<T>, extra: TableChangeExtra<T>) => void;
+}
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+export type TableColumnProps<T> = DistributiveOmit<TableColumn<T>, "children"> & {
+    readonly children?: null;
+};
+export type TableColumnGroupProps<T> = DistributiveOmit<TableColumn<T>, "children"> & {
+    readonly children: ReactNode;
+};
+type TableComponent = (<T>(props: TableProps<T> & RefAttributes<RcTableReference>) => ReactElement) & {
+    Column: <T>(props: TableColumnProps<T>) => ReactElement | null;
+    ColumnGroup: <T>(props: TableColumnGroupProps<T>) => ReactElement | null;
+    EXPAND_COLUMN: typeof EXPAND_COLUMN;
+    SELECTION_ALL: typeof SELECTION_ALL;
+    SELECTION_COLUMN: typeof SELECTION_COLUMN;
+    SELECTION_INVERT: typeof SELECTION_INVERT;
+    SELECTION_NONE: typeof SELECTION_NONE;
+    Summary: typeof Summary;
+    displayName?: string;
+};
+export declare const Table: TableComponent;

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

@@ -0,0 +1,50 @@
+import RcTabs from "@rc-component/tabs";
+import type { AnimatedConfig, MoreProps, TabPaneProps as RcTabPaneProps, TabsProps as RcTabsProps, Tab } from "@rc-component/tabs";
+import type { CSSProperties, ComponentRef, FC, KeyboardEvent, MouseEvent, ReactNode } from "react";
+export type AntdTabsType = "line" | "card" | "editable-card";
+export type TabsExtensionType = "boxed" | "segmented" | "glow-pill";
+export type TabsType = AntdTabsType | TabsExtensionType;
+export type TabsPosition = "top" | "right" | "bottom" | "left";
+export interface CompatibilityProps {
+    /** @deprecated Use `destroyOnHidden` instead. */
+    readonly destroyInactiveTabPane?: boolean;
+}
+export type TabPaneProps = RcTabPaneProps & CompatibilityProps;
+export type RcTabsRef = ComponentRef<typeof RcTabs>;
+export interface TabsItem extends Omit<Tab, "children" | "key" | "label">, CompatibilityProps {
+    readonly children?: ReactNode;
+    readonly closable?: boolean;
+    readonly closeIcon?: ReactNode;
+    readonly disabled?: boolean;
+    readonly forceRender?: boolean;
+    readonly icon?: ReactNode;
+    readonly key: string;
+    readonly label: ReactNode;
+}
+type TabsSlot = "root" | "item" | "remove" | "indicator" | "body" | "content" | "header" | "popup";
+export interface TabsProps extends CompatibilityProps, Omit<RcTabsProps, "animated" | "classNames" | "editable" | "items" | "more" | "onEdit" | "popupClassName" | "styles" | "tabPosition"> {
+    readonly addIcon?: ReactNode;
+    readonly animated?: boolean | AnimatedConfig;
+    readonly centered?: boolean;
+    readonly classNames?: Partial<Record<TabsSlot, string>>;
+    readonly children?: ReactNode;
+    readonly fullWidth?: boolean;
+    readonly hideAdd?: boolean;
+    readonly items?: readonly TabsItem[];
+    readonly more?: MoreProps;
+    readonly moreIcon?: ReactNode;
+    readonly popupClassName?: string;
+    readonly removeIcon?: ReactNode;
+    readonly rootClassName?: string;
+    readonly styles?: Partial<Record<TabsSlot, CSSProperties>>;
+    readonly tabPosition?: TabsPosition;
+    readonly type?: TabsType;
+    readonly onEdit?: (targetKey: MouseEvent | KeyboardEvent | string, action: "add" | "remove") => void;
+}
+declare const TabPane: FC<TabPaneProps>;
+declare const InternalTabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<HTMLDivElement>>;
+type CompoundedTabs = typeof InternalTabs & {
+    TabPane: typeof TabPane;
+};
+export declare const Tabs: CompoundedTabs;
+export {};

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

@@ -0,0 +1,52 @@
+import type { AriaAttributes, HTMLAttributes, MouseEvent, ReactElement, ReactNode } from "react";
+export type TagPresetColor = "default" | "success" | "processing" | "error" | "warning" | "gold";
+export type TagColor = TagPresetColor | (string & {});
+export type TagVariant = "filled" | "solid" | "outlined";
+export interface TagClosableConfig extends AriaAttributes {
+    readonly afterClose?: () => void;
+    readonly closeIcon?: ReactNode;
+    readonly disabled?: boolean;
+}
+export interface TagProps extends HTMLAttributes<HTMLSpanElement> {
+    /** @deprecated Use `variant` instead. */
+    readonly bordered?: boolean;
+    readonly closable?: boolean | TagClosableConfig;
+    readonly closeIcon?: ReactNode;
+    readonly color?: TagColor;
+    readonly disabled?: boolean;
+    readonly href?: string;
+    readonly icon?: ReactNode;
+    readonly rootClassName?: string;
+    readonly target?: string;
+    readonly variant?: TagVariant;
+    readonly onClose?: (event: MouseEvent<HTMLElement>) => void;
+}
+export interface CheckableTagProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onChange"> {
+    readonly checked: boolean;
+    readonly disabled?: boolean;
+    readonly icon?: ReactNode;
+    /** Legacy button prop retained as a no-op for source compatibility. */
+    readonly type?: "button" | "reset" | "submit";
+    readonly onChange?: (checked: boolean) => void;
+}
+export interface CheckableTagOption<Value extends string | number = string | number> {
+    readonly disabled?: boolean;
+    readonly label: ReactNode;
+    readonly value: Value;
+}
+export interface CheckableTagGroupProps<Value extends string | number = string | number> extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    readonly defaultValue?: Value | readonly Value[];
+    readonly disabled?: boolean;
+    readonly multiple?: boolean;
+    readonly options?: readonly CheckableTagOption<Value>[];
+    readonly value?: Value | readonly Value[];
+    readonly onChange?: (value: Value | Value[]) => void;
+}
+declare function TagRoot({ bordered, children, className, closable, closeIcon, color, disabled, href, icon, onClick, onClose, rootClassName, style, target, variant: customVariant, ...props }: TagProps): ReactElement | null;
+declare function CheckableTag({ checked, children, className, disabled, icon, onChange, onClick, onKeyDown, type: _type, ...props }: CheckableTagProps): import("react").JSX.Element;
+declare function CheckableTagGroup<Value extends string | number = string | number>({ className, defaultValue, disabled, multiple, onChange, options, value, ...props }: CheckableTagGroupProps<Value>): import("react").JSX.Element;
+export declare const Tag: typeof TagRoot & {
+    CheckableTag: typeof CheckableTag;
+    CheckableTagGroup: typeof CheckableTagGroup;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+type TagTone = "amber" | "slate" | "green" | "red";
+export declare function TagPill({ children, tone, }: {
+    readonly children: ReactNode;
+    readonly tone?: TagTone;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,64 @@
+import type { TooltipRef as RcTooltipRef } from "@rc-component/tooltip";
+import type { TooltipProps as RcTooltipProps } from "@rc-component/tooltip/es/Tooltip";
+import type { CSSProperties, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type TooltipPlacement = "topLeft" | "top" | "topRight" | "bottomLeft" | "bottom" | "bottomRight" | "leftTop" | "left" | "leftBottom" | "rightTop" | "right" | "rightBottom";
+export type TooltipTrigger = "hover" | "focus" | "click" | "contextMenu";
+export interface TooltipArrowOptions {
+    readonly pointAtCenter?: boolean;
+}
+export interface TooltipAdjustOverflow {
+    readonly adjustX?: 0 | 1;
+    readonly adjustY?: 0 | 1;
+}
+export type TooltipRef = RcTooltipRef;
+type TooltipSlot = "root" | "trigger" | "popup" | "arrow" | "content";
+export interface TooltipProps {
+    readonly afterOpenChange?: (open: boolean) => void;
+    readonly afterVisibleChange?: (open: boolean) => void;
+    readonly align?: RcTooltipProps["align"];
+    readonly arrow?: boolean | TooltipArrowOptions;
+    readonly autoAdjustOverflow?: boolean | TooltipAdjustOverflow;
+    readonly builtinPlacements?: RcTooltipProps["builtinPlacements"];
+    readonly children: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<TooltipSlot>;
+    readonly color?: string;
+    readonly defaultOpen?: boolean;
+    readonly defaultVisible?: boolean;
+    readonly disabled?: boolean;
+    readonly destroyOnHidden?: boolean;
+    readonly destroyTooltipOnHide?: boolean | {
+        readonly keepParent?: boolean;
+    };
+    readonly forceRender?: boolean;
+    readonly fresh?: boolean;
+    readonly getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    readonly getTooltipContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    readonly id?: string;
+    readonly maxWidth?: number | string;
+    readonly motion?: RcTooltipProps["motion"];
+    readonly mouseEnterDelay?: number;
+    readonly mouseLeaveDelay?: number;
+    readonly open?: boolean;
+    readonly openClassName?: string;
+    readonly overlay?: ReactNode | (() => ReactNode);
+    readonly overlayClassName?: string;
+    readonly overlayInnerStyle?: CSSProperties;
+    readonly overlayStyle?: CSSProperties;
+    readonly placement?: TooltipPlacement;
+    readonly rootClassName?: string;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<TooltipSlot>;
+    readonly title?: ReactNode | (() => ReactNode);
+    readonly trigger?: TooltipTrigger | readonly TooltipTrigger[];
+    readonly unique?: RcTooltipProps["unique"];
+    readonly variant?: "dark" | "light";
+    readonly visible?: boolean;
+    readonly zIndex?: number;
+    readonly onOpenChange?: (open: boolean) => void;
+    readonly onPopupAlign?: RcTooltipProps["onPopupAlign"];
+    readonly onVisibleChange?: (open: boolean) => void;
+}
+export declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<RcTooltipRef>>;
+export {};