@_tc/template-core 0.0.1-bate.6 → 0.0.1-bate.60

package/model/packages/react/ui/components/InputNumber/inputNumberUtils.d.ts

@@ -0,0 +1,29 @@
+export interface InputNumberConstraints {
+    min?: number;
+    max?: number;
+    precision?: number;
+    step?: number;
+}
+export type ParsedInputNumber = {
+    kind: 'empty';
+} | {
+    kind: 'incomplete';
+} | {
+    kind: 'invalid';
+} | {
+    kind: 'number';
+    value: number;
+};
+export type StepDirection = 'up' | 'down';
+export declare const isValidNumberInput: (value: string) => boolean;
+export declare const clampValue: (value: number, constraints: InputNumberConstraints) => number;
+export declare const applyPrecision: (value: number, precision?: number) => number;
+export declare const normalizeNumber: (value: number, constraints: InputNumberConstraints) => number;
+export declare const formatNumber: (value: number, constraints: InputNumberConstraints) => string;
+export declare const parseInputNumber: (value: string) => ParsedInputNumber;
+export declare const shouldSyncDisplayValue: ({ isFocused, displayValue, currentValue, }: {
+    isFocused: boolean;
+    displayValue: string;
+    currentValue: number | undefined;
+}) => boolean;
+export declare const stepValue: (currentValue: number | undefined, direction: StepDirection, constraints: InputNumberConstraints) => number;

package/model/packages/react/ui/components/Label/Label.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+type VerticalLayout = {
+    layout?: 'vertical';
+};
+type HorizontalLayout = {
+    layout?: 'horizontal';
+    labelWidth?: string | number;
+    labelAlign?: 'left' | 'right' | 'center';
+};
+export type LabelLayout = HorizontalLayout | VerticalLayout;
+export type LabelProps = {
+    label: ReactNode;
+    children: ReactNode;
+    required?: boolean;
+    htmlFor?: string;
+    className?: string;
+    labelClassName?: string;
+    contentClassName?: string;
+} & LabelLayout;
+declare const Label: import("react").ForwardRefExoticComponent<LabelProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Label };

package/model/packages/react/ui/components/Label/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Label";
+export { Label as default } from "./Label";

package/model/packages/react/ui/components/Layout/Layout.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+export type LayoutProps = {
+    header?: ReactNode;
+    sidebar?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+};
+declare const Layout: import("react").ForwardRefExoticComponent<LayoutProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Layout };

package/model/packages/react/ui/components/Layout/index.d.ts

@@ -0,0 +1 @@
+export * from "./Layout";

package/model/packages/react/ui/components/Loading/Loading.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export type LoadingProps = {
+    size?: 'sm' | 'md' | 'lg';
+    text?: ReactNode;
+    className?: string;
+};
+export type LoadingIndicatorProps = {
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+};
+export declare function LoadingIndicator({ size, className }: LoadingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+declare const Loading: import("react").ForwardRefExoticComponent<LoadingProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Loading };

package/model/packages/react/ui/components/Loading/index.d.ts

@@ -0,0 +1 @@
+export * from "./Loading";

package/model/packages/react/ui/components/Menu/Menu.d.ts

@@ -0,0 +1,17 @@
+import { type FC } from "react";
+import { MenuItem } from "./MenuItem";
+import { SubMenu } from "./SubMenu";
+import type { MenuProps } from "./menuTypes";
+export interface CollapseToggleHandle {
+    collapse: () => void;
+    expand: () => void;
+}
+export interface CollapseToggleProps {
+    className?: string;
+}
+export declare const CollapseToggle: import("react").ForwardRefExoticComponent<CollapseToggleProps & import("react").RefAttributes<CollapseToggleHandle>>;
+export declare const Menu: FC<MenuProps> & {
+    Item: typeof MenuItem;
+    SubMenu: typeof SubMenu;
+    CollapseToggle: typeof CollapseToggle;
+};

package/model/packages/react/ui/components/Menu/MenuContext.d.ts

@@ -0,0 +1,38 @@
+export declare const CollapsedContext: import("react").Context<boolean>;
+interface MenuStore {
+    mode: 'top' | 'left';
+    expandTrigger: 'hover' | 'click';
+    expandMode: 'accordion' | 'multiple';
+    selectedKey: string | undefined;
+    openKeys: string[];
+    openKeyParents: Record<string, string>;
+    collapsed: boolean;
+    propsCollapsed: boolean | undefined;
+    collapsedWidth: number;
+    collapsedLabelTooltip: boolean;
+    onSelect: ((key: string) => void) | undefined;
+    onCollapse: ((collapsed: boolean) => void) | undefined;
+    isControlledSelected: boolean;
+    isControlledCollapsed: boolean;
+    setSelectedKey: (key: string) => void;
+    toggleOpenKey: (key: string, parentKey?: string) => void;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare const MenuStoreContext: import("react").Context<import("zustand").StoreApi<MenuStore> | null>;
+export declare function useMenuStore<T>(selector: (state: MenuStore) => T): T;
+export declare function createMenuContextValue(overrides: {
+    mode?: 'top' | 'left';
+    expandTrigger?: 'hover' | 'click';
+    expandMode?: 'accordion' | 'multiple';
+    selectedKey?: string;
+    defaultSelectedKey?: string;
+    collapsed?: boolean;
+    propsCollapsed?: boolean;
+    defaultCollapsed?: boolean;
+    collapsedWidth?: number;
+    collapsedLabelTooltip?: boolean;
+    onSelect?: (key: string) => void;
+    onCollapse?: (collapsed: boolean) => void;
+}): import("zustand").StoreApi<MenuStore>;
+export { MenuStoreContext };
+export type { MenuStore };

package/model/packages/react/ui/components/Menu/MenuItem.d.ts

@@ -0,0 +1,2 @@
+import type { MenuItemProps } from "./menuTypes";
+export declare function MenuItem({ eventKey, icon, disabled, danger, onClick, children, className, style, width, minWidth, maxWidth, ...props }: MenuItemProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Menu/SubMenu.d.ts

@@ -0,0 +1,2 @@
+import type { SubMenuProps } from "./menuTypes";
+export declare function SubMenu({ eventKey, label, icon, disabled, popup: forcePopup, parentKey, children, }: SubMenuProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Menu/index.d.ts

@@ -0,0 +1,8 @@
+export { Menu } from "./Menu";
+export { MenuItem } from "./MenuItem";
+export { SubMenu } from "./SubMenu";
+export { CollapseToggle } from "./Menu";
+export type { MenuProps, MenuItemData, MenuItemProps, SubMenuProps } from "./menuTypes";
+export type { CollapseToggleHandle, CollapseToggleProps } from "./Menu";
+export { useMenuStore } from "./MenuContext";
+export type { MenuStore } from "./MenuContext";

package/model/packages/react/ui/components/Menu/menuTypes.d.ts

@@ -0,0 +1,57 @@
+import type { CSSProperties, MouseEventHandler, ReactNode, Ref } from "react";
+export interface MenuItemData {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    popup?: boolean;
+    children?: MenuItemData[];
+    onClick?: () => void;
+    className?: string;
+    style?: CSSProperties;
+    width?: CSSProperties['width'];
+    minWidth?: CSSProperties['minWidth'];
+    maxWidth?: CSSProperties['maxWidth'];
+}
+export interface MenuProps {
+    mode?: 'top' | 'left';
+    expandTrigger?: 'hover' | 'click';
+    expandMode?: 'accordion' | 'multiple';
+    selectedKey?: string;
+    defaultSelectedKey?: string;
+    onSelect?: (key: string) => void;
+    items?: MenuItemData[];
+    children?: ReactNode;
+    className?: string;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+    collapsedWidth?: number;
+    collapsedLabelTooltip?: boolean;
+}
+export interface SubMenuProps {
+    eventKey: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    popup?: boolean;
+    parentKey?: string;
+    children?: ReactNode;
+}
+export interface MenuItemProps {
+    eventKey?: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    onClick?: () => void;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    width?: CSSProperties['width'];
+    minWidth?: CSSProperties['minWidth'];
+    maxWidth?: CSSProperties['maxWidth'];
+    onMouseLeave?: MouseEventHandler<HTMLButtonElement>;
+    onMouseEnter?: MouseEventHandler<HTMLButtonElement>;
+    ref?: Ref<HTMLButtonElement>;
+}

package/model/packages/react/ui/components/Menu/utils.d.ts

@@ -0,0 +1 @@
+export declare function getFirstChar(node: React.ReactNode): string;

package/model/packages/react/ui/components/Message/Message.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+export type MessageType = 'success' | 'error' | 'warning' | 'info';
+export type MessageProps = {
+    type?: MessageType;
+    content?: ReactNode;
+    children?: ReactNode;
+    duration?: number;
+    onClose?: () => void;
+    closable?: boolean;
+    className?: string;
+};
+export declare function Message({ type, content, children, duration, onClose, closable, className, }: MessageProps): import("react/jsx-runtime").JSX.Element | null;

package/model/packages/react/ui/components/Message/MessageManager.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from "react";
+import { type MessageProps, type MessageType } from "./Message";
+type MessageConfig = Omit<MessageProps, 'onClose' | 'children'> & {
+    id: string;
+    content?: ReactNode;
+    onClose?: () => void;
+};
+declare class MessageManagerClass {
+    private messages;
+    private container;
+    private offScreenContainer;
+    private root;
+    private offScreenRoot;
+    private maxCount;
+    private init;
+    private render;
+    show(config: Omit<MessageConfig, 'id'>, type?: MessageType): string;
+    close(id: string): void;
+    closeAll(): void;
+    setMaxCount(count: number): void;
+}
+export declare const messageManager: MessageManagerClass;
+type MessageFN = (content: ReactNode, config?: {
+    duration?: number;
+    onClose?: () => void;
+}) => string;
+export declare const message: {
+    success: MessageFN;
+    error: MessageFN;
+    warning: MessageFN;
+    info: MessageFN;
+    close: (id: string) => void;
+    closeAll: () => void;
+    setMaxCount: (count: number) => void;
+};
+export {};

package/model/packages/react/ui/components/Message/data.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_DURATION = 3000;

package/model/packages/react/ui/components/Message/index.d.ts

@@ -0,0 +1,2 @@
+export type { MessageProps, MessageType } from "./Message";
+export { message } from "./MessageManager";

package/model/packages/react/ui/components/Modal/Modal.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+export type ModalProps = {
+    open?: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    mask?: boolean;
+    maskClosable?: boolean;
+    lockScroll?: boolean;
+    closable?: boolean;
+    width?: number | string;
+    centered?: boolean;
+    zIndex?: number;
+    renderNode?: HTMLElement | (() => HTMLElement);
+    keyboard?: boolean;
+};
+export declare function Modal({ open, onClose, title, children, footer, className, contentClassName, mask, maskClosable, lockScroll, closable, width, centered, renderNode, keyboard, zIndex, }: ModalProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Modal/ModalManager.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from "react";
+import { type SubmitButtonProps } from "../Button";
+import { type ModalProps } from "./Modal";
+type ModalConfig = Omit<ModalProps, 'open' | 'onClose' | 'children'> & {
+    id: string;
+    onClose?: () => void;
+    content?: ReactNode;
+};
+declare class ModalManagerClass {
+    private modals;
+    private listeners;
+    private container;
+    private root;
+    private init;
+    private notify;
+    subscribe(listener: () => void): () => void;
+    open(config: Omit<ModalConfig, 'id'>): string;
+    close(id: string): void;
+    closeAll(): void;
+    getModals(): ModalConfig[];
+    private render;
+}
+type OpenModalConfig = Omit<ModalConfig, 'id'>;
+export declare const openConfirmModal: (pConfig: Pick<OpenModalConfig, "content"> & {
+    title?: ReactNode;
+    content: ReactNode;
+    okText?: string;
+    cancelText?: string;
+    onOk?: SubmitButtonProps["onClick"];
+    onCancel?: () => void;
+}) => string;
+export declare const modalManager: ModalManagerClass;
+export declare const modal: {
+    open: (config: OpenModalConfig) => string;
+    confirm: (pConfig: Pick<OpenModalConfig, "content"> & {
+        title?: ReactNode;
+        content: ReactNode;
+        okText?: string;
+        cancelText?: string;
+        onOk?: SubmitButtonProps["onClick"];
+        onCancel?: () => void;
+    }) => string;
+    close: (id: string) => void;
+    closeAll: () => void;
+};
+export {};

package/model/packages/react/ui/components/Modal/index.d.ts

@@ -0,0 +1,3 @@
+export { Modal } from "./Modal";
+export type { ModalProps } from "./Modal";
+export { modal } from "./ModalManager";

package/model/packages/react/ui/components/Notification/Notification.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+export type NotificationProps = {
+    type?: NotificationType;
+    title?: ReactNode;
+    message?: ReactNode;
+    duration?: number;
+    closable?: boolean;
+    onClose?: () => void;
+    className?: string;
+};
+declare const Notification: import("react").ForwardRefExoticComponent<NotificationProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Notification };

package/model/packages/react/ui/components/Notification/index.d.ts

@@ -0,0 +1 @@
+export * from "./Notification";

package/model/packages/react/ui/components/Overlay/Overlay.d.ts

@@ -0,0 +1,19 @@
+import type { CSSProperties, MouseEvent, ReactNode } from "react";
+export declare const canUseDocument: () => boolean;
+export type OverlayProps = {
+    open?: boolean;
+    visible?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    zIndex?: number;
+    mask?: boolean;
+    maskClosable?: boolean;
+    lockScroll?: boolean;
+    keyboard?: boolean;
+    closable?: boolean;
+    onClose?: () => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    renderNode?: HTMLElement | (() => HTMLElement);
+};
+export declare function Overlay({ open, visible, children, className, style, zIndex, mask, maskClosable, lockScroll, keyboard, closable, onClose, onClick, renderNode, }: OverlayProps): import("react").ReactPortal | null;

package/model/packages/react/ui/components/Overlay/index.d.ts

@@ -0,0 +1,2 @@
+export { Overlay, canUseDocument } from "./Overlay";
+export type { OverlayProps } from "./Overlay";

package/model/packages/react/ui/components/Pagination/Pagination.d.ts

@@ -0,0 +1,10 @@
+export interface PaginationProps {
+    current: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    pageSizeOptions?: number[];
+    className?: string;
+}
+export declare function Pagination({ current, pageSize, total, onChange, onPageSizeChange, pageSizeOptions, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element | null;

package/model/packages/react/ui/components/Pagination/index.d.ts

@@ -0,0 +1 @@
+export * from "./Pagination";

package/model/packages/react/ui/components/Popup/Popup.d.ts

@@ -0,0 +1,25 @@
+import type { CSSProperties, ReactNode, RefObject } from "react";
+import { type DropdownPlacement, type DropdownPosition, type DropdownPositioningStrategy, type UseDropdownPositioningResult } from "../hooks/useDropdownPositioning";
+export interface PopupProps {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    placement?: DropdownPlacement;
+    offset?: number;
+    keepMounted?: boolean;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    matchAnchorWidth?: boolean;
+    position?: DropdownPosition;
+    positioning?: UseDropdownPositioningResult;
+    strategy?: DropdownPositioningStrategy;
+    contentRef?: RefObject<HTMLDivElement | null>;
+    container?: HTMLElement;
+    positionMode?: "fixed" | "absolute";
+    hoverBridge?: number;
+    hoverBridgePlacement?: "auto" | "horizontal";
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function Popup({ open, anchorRef, children, className, style, placement, offset, keepMounted, closeOnClickOutside, closeOnEscape, matchAnchorWidth, position, positioning, strategy, contentRef, container, positionMode, hoverBridge, hoverBridgePlacement, onOpenChange, }: PopupProps): import("react").ReactPortal | null;

package/model/packages/react/ui/components/Popup/index.d.ts

@@ -0,0 +1 @@
+export * from "./Popup";

package/model/packages/react/ui/components/Radio/Radio.d.ts

@@ -0,0 +1,8 @@
+import type { InputHTMLAttributes, ReactNode } from "react";
+export type RadioProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'children'> & {
+    label?: ReactNode;
+};
+declare const Radio: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "type"> & {
+    label?: ReactNode;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { Radio };

package/model/packages/react/ui/components/Radio/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+export type RadioGroupProps = {
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    direction?: 'horizontal' | 'vertical';
+    children?: ReactNode;
+    className?: string;
+};
+type RadioGroupContextValue = {
+    name?: string;
+    selectedValue?: string;
+    onSelect?: (value: string) => void;
+};
+export declare function useRadioGroupContext(): RadioGroupContextValue;
+declare const RadioGroup: import("react").ForwardRefExoticComponent<RadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export { RadioGroup };

package/model/packages/react/ui/components/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Radio";
+export * from "./RadioGroup";

package/model/packages/react/ui/components/Search/Search.d.ts

@@ -0,0 +1,13 @@
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import type { FormInstance } from "rc-field-form";
+import type { ReactNode } from "react";
+import { type FormFieldSchema } from "../Form";
+export type SearchProps<T> = {
+    defaultValue?: T;
+    schemas: MOmit<FormFieldSchema<T>, 'rules' | 'required'>[];
+    children?: ReactNode;
+    getForm?: (form: FormInstance<T>) => void;
+    btnsClassName?: string;
+};
+declare const Search: <T extends object>(props: SearchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default Search;

package/model/packages/react/ui/components/Search/index.d.ts

@@ -0,0 +1 @@
+export { default as Search } from "./Search";

package/model/packages/react/ui/components/Select/Select.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+export type SelectOption = {
+    label: React.ReactNode;
+    value: string | number;
+    searchText?: string;
+};
+export type SelectProps = {
+    options: SelectOption[];
+    value?: string | number;
+    defaultValue?: string | number;
+    placeholder?: string;
+    onChange?: (value: string | number | undefined) => void;
+    loading?: boolean;
+    className?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    searchable?: boolean;
+    getPopupContainer?: 'parent' | (() => HTMLElement);
+};
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLDivElement>>;
+export { Select };

package/model/packages/react/ui/components/Select/dropdownPositioning.d.ts

@@ -0,0 +1,2 @@
+import type { DropdownPositioningStrategy } from "../hooks/useDropdownPositioning";
+export declare const getSelectDropdownPosition: DropdownPositioningStrategy;

package/model/packages/react/ui/components/Select/index.d.ts

@@ -0,0 +1 @@
+export * from "./Select";

package/model/packages/react/ui/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from "react";
+export type SkeletonMode = 'pageloading' | 'tableloading' | 'componentsloading';
+export interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    mode?: SkeletonMode;
+    rows?: number;
+    showTitle?: boolean;
+    showActions?: boolean;
+}
+export declare const Skeleton: {
+    ({ mode, className, rows, showTitle, showActions, ...props }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/model/packages/react/ui/components/Skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton } from "./Skeleton";
+export type { SkeletonProps, SkeletonMode } from "./Skeleton";

package/model/packages/react/ui/components/Switch/Switch.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export type SwitchProps = {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+};
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/model/packages/react/ui/components/Switch/index.d.ts

@@ -0,0 +1 @@
+export * from "./Switch";

package/model/packages/react/ui/components/TableSearch/TableSearch.d.ts

@@ -0,0 +1,30 @@
+import { ExportType } from "../../../../../../fe/packages/react/ui/lib/export";
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import { type ReactNode } from "react";
+import { type DropdownItem } from "../Dropdown";
+import type { FormFieldSchema } from "../Form";
+import type { SearchProps } from "../Search/Search";
+export type TableSearchSchema<T> = MOmit<FormFieldSchema<T>, 'rules' | 'required'> & {
+    isPermanent?: boolean;
+};
+type TableSearchProps<T> = MOmit<SearchProps<T>, 'children' | 'schemas'> & {
+    onSearch?: (values: T) => void;
+    onReset?: () => void;
+    renderActionBtnArea?: () => ReactNode;
+    schemas: TableSearchSchema<T>[];
+    exportMenuItems?: DropdownItem[];
+    btnConfig?: Partial<{
+        export?: ReactNode;
+        collapse?: ReactNode;
+        expandIcon?: ReactNode;
+        expand?: ReactNode;
+        reset?: ReactNode;
+        search?: ReactNode;
+    }>;
+    expandBoundaries?: number;
+    onExport?: (exportType: ExportType, searchData: T) => void;
+    additionalButtons?: ReactNode;
+    defaultExpand?: boolean;
+};
+declare const TableSearch: <T extends object>(props: TableSearchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default TableSearch;

package/model/packages/react/ui/components/TableSearch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TableSearch } from "./TableSearch";
+export type { TableSearchSchema } from "./TableSearch";

package/model/packages/react/ui/components/TableSearch/lang.d.ts

@@ -0,0 +1,14 @@
+export interface TableSearchLocaleConfig {
+    reset: string;
+    search: string;
+    export: string;
+    expand: string;
+    collapse: string;
+    exportCurrentPage: string;
+    exportCurrentQuery: string;
+}
+export declare const zhCNLocale: TableSearchLocaleConfig;
+export declare const enUSLocale: TableSearchLocaleConfig;
+export declare const defaultLocale: TableSearchLocaleConfig;
+export declare const btnConfig: TableSearchLocaleConfig;
+export declare const updateBtnConfig: (config: Partial<TableSearchLocaleConfig>) => void;

package/model/packages/react/ui/components/TableSearch/tableSearchLocaleStore.d.ts

@@ -0,0 +1,8 @@
+import { type TableSearchLocaleConfig } from "./lang";
+type TableSearchLocaleState = {
+    locale: TableSearchLocaleConfig;
+    replaceLocale: (nextLocale: TableSearchLocaleConfig) => void;
+    resetLocale: () => void;
+};
+export declare const useTableSearchLocaleStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TableSearchLocaleState>>;
+export {};

package/model/packages/react/ui/components/Tabs/Tabs.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export type TabItem = {
+    key: string;
+    label: ReactNode;
+    disabled?: boolean;
+};
+export type TabsProps = {
+    items: TabItem[];
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    className?: string;
+};
+declare const Tabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Tabs };

package/model/packages/react/ui/components/Tabs/index.d.ts

@@ -0,0 +1 @@
+export * from "./Tabs";