@_tc/template-core 0.1.16 → 0.2.0-bate.1

package/model/packages/react/ui/components/Date/Calendar.d.ts

@@ -0,0 +1,21 @@
+import { ModeType } from "./data";
+import { type DateLocaleConfig } from "./locales";
+export type DateRange = {
+    from: Date | undefined;
+    to?: Date | undefined;
+};
+export type QuickRangePreset = {
+    label: string;
+    getRange: () => DateRange;
+};
+export interface CalendarProps {
+    mode?: ModeType;
+    value?: Date | DateRange | null;
+    onChange?: (date: Date | DateRange) => void;
+    disabledDate?: (date: Date) => boolean;
+    showTime?: boolean;
+    className?: string;
+    locale?: Partial<DateLocaleConfig>;
+    quickRanges?: QuickRangePreset[];
+}
+export declare function Calendar({ mode, value, onChange, disabledDate, showTime, className, locale: customLocale, quickRanges, }: CalendarProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,26 @@
+import { type DateRange, type QuickRangePreset } from "./Calendar";
+import { ModeType } from "./data";
+import { type DateLocaleConfig } from "./locales";
+export type DateChangeStrValue = [string, string] | string;
+type DateBaseValue = Date | DateRange;
+type Dates = DateBaseValue | [Date, Date];
+export type DateValue = Dates | DateChangeStrValue;
+export type DatePickerProps = {
+    mode?: ModeType;
+    value?: DateValue;
+    defaultValue?: DateValue;
+    format?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    showTime?: boolean;
+    onChange?: (value?: DateChangeStrValue, date?: Dates) => void;
+    disabledDate?: (current: Date) => boolean;
+    className?: string;
+    locale?: Partial<DateLocaleConfig>;
+    quickRanges?: QuickRangePreset[];
+    getPopupContainer?: () => HTMLElement;
+};
+declare const DatePicker: import("react").ForwardRefExoticComponent<DatePickerProps & import("react").RefAttributes<HTMLDivElement>>;
+export { DatePicker };
+export type { DateRange };

package/model/packages/react/ui/components/Date/LocaleContext.d.ts

@@ -0,0 +1 @@
+export declare const useDateLocale: () => import("./locales").DateLocaleConfig;

package/model/packages/react/ui/components/Date/LocaleProvider.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+import { type DateLocaleConfig } from "./locales";
+export interface DateLocaleProviderProps {
+    locale?: DateLocaleConfig;
+    children: ReactNode;
+}
+export declare function DateLocaleProvider({ locale, children }: DateLocaleProviderProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Date/TimePicker.d.ts

@@ -0,0 +1,6 @@
+export interface TimePickerProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    className?: string;
+}
+export declare function TimePicker({ value, onChange, className }: TimePickerProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+export declare const ModeType: {
+    readonly Single: "single";
+    readonly Range: "range";
+};
+export type ModeType = (typeof ModeType)[keyof typeof ModeType];

package/model/packages/react/ui/components/Date/dateLocaleStore.d.ts

@@ -0,0 +1,9 @@
+import { type DateLocaleConfig } from "./locales";
+type DateLocaleState = {
+    locale: DateLocaleConfig;
+    setLocale: (patch: Partial<DateLocaleConfig>) => void;
+    replaceLocale: (nextLocale: DateLocaleConfig) => void;
+    resetLocale: () => void;
+};
+export declare const useDateLocaleStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DateLocaleState>>;
+export {};

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

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

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

@@ -0,0 +1,5 @@
+export * from "./Date";
+export * from "./dateLocaleStore";
+export { useDateLocale } from "./LocaleContext";
+export * from "./LocaleProvider";
+export * from "./locales";

package/model/packages/react/ui/components/Date/locales.d.ts

@@ -0,0 +1,23 @@
+export interface DateLocaleConfig {
+    placeholder: string;
+    placeholderDateTime: string;
+    placeholderRange: string;
+    placeholderDateTimeRange: string;
+    weekDays: string[];
+    selectTime: string;
+    startTime: string;
+    endTime: string;
+    confirm: string;
+    monthFormat: string;
+    quickRanges: string;
+    quickRangeToday: string;
+    quickRangeYesterday: string;
+    quickRangeLast7Days: string;
+    quickRangeLast30Days: string;
+    quickRangeThisMonth: string;
+    quickRangeLastYear: string;
+    clear: string;
+}
+export declare const zhCNLocale: DateLocaleConfig;
+export declare const enUSLocale: DateLocaleConfig;
+export declare const defaultLocale: DateLocaleConfig;

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

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+export type DrawerPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type DrawerProps = {
+    open?: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    mask?: boolean;
+    maskClosable?: boolean;
+    lockScroll?: boolean;
+    closable?: boolean;
+    placement?: DrawerPlacement;
+    width?: number | string;
+    height?: number | string;
+    zIndex?: number;
+    renderNode?: HTMLElement | (() => HTMLElement);
+    keyboard?: boolean;
+};
+export declare function Drawer({ open, onClose, title, children, footer, className, contentClassName, mask, maskClosable, lockScroll, closable, placement, width, height, renderNode, keyboard, zIndex, }: DrawerProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Drawer } from "./Drawer";
+export type { DrawerPlacement, DrawerProps } from "./Drawer";

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

@@ -0,0 +1,24 @@
+import type { ReactNode } from "react";
+import { type DropdownPlacement } from "../hooks/useDropdownPositioning";
+export interface DropdownBaseItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    danger?: boolean;
+    onClick?: () => void;
+}
+export interface DropdownRenderItem {
+    render: (item: DropdownRenderItem, context: {
+        onClick: () => void;
+        close: () => void;
+    }) => ReactNode;
+}
+export type DropdownItem = Omit<DropdownBaseItem, 'render'> | DropdownRenderItem;
+export interface DropdownProps {
+    items: DropdownItem[];
+    children: ReactNode;
+    className?: string;
+    placement?: DropdownPlacement;
+    getPopupContainer?: () => HTMLElement;
+}
+export declare function Dropdown({ items, children, className, placement, getPopupContainer }: DropdownProps): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,11 @@
+import type { FormProps as RcFormProps } from "rc-field-form";
+import type { ReactNode } from "react";
+export interface FormProps<T> extends Omit<RcFormProps<T>, 'component'> {
+    className?: string;
+    children?: ReactNode;
+}
+declare const Form: {
+    <T extends object>({ className, children, ...props }: FormProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Form };

package/model/packages/react/ui/components/Form/FormItem.d.ts

@@ -0,0 +1,19 @@
+import { Field } from "rc-field-form";
+import type { ReactNode } from "react";
+import { type LabelLayout } from "../Label";
+type FieldProps = Parameters<typeof Field>[0];
+export interface FormItemProps<T = any> extends Omit<FieldProps, 'children'> {
+    className?: string;
+    label?: ReactNode;
+    labelClassName?: string;
+    required?: boolean;
+    children?: ReactNode | ((value: T, onChange: (value: T) => void, meta: {
+        errors: string[];
+        warnings: string[];
+    }) => ReactNode);
+    errorClassName?: string;
+    showError?: boolean;
+    layout?: Required<LabelLayout>['layout'];
+}
+declare const FormItem: <T>(props: FormItemProps<T>) => ReactNode | Promise<ReactNode>;
+export { FormItem };

package/model/packages/react/ui/components/Form/SchemaForm/data.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import { CheckboxProps } from "../../Checkbox";
+import { type DatePickerProps } from "../../Date";
+import { type InputProps } from "../../Input";
+import { InputNumberProps } from "../../InputNumber";
+import { type SelectProps } from "../../Select";
+import { type SwitchProps } from "../../Switch";
+import { type TextareaProps } from "../../Textarea";
+export type SchemaFormComponentPropsMap = {
+    input: InputProps;
+    inputNumber: InputNumberProps;
+    select: SelectProps;
+    textarea: TextareaProps;
+    switch: SwitchProps;
+    date: DatePickerProps;
+    checkbox: CheckboxProps;
+};
+export type SchemaFormFieldType = keyof SchemaFormComponentPropsMap;
+export declare namespace SchemaFormNamespace {
+    interface FieldTypes {
+    }
+    interface PropsMap {
+    }
+}
+export type ExtendedFieldType = Extract<keyof SchemaFormNamespace.FieldTypes | keyof SchemaFormNamespace.PropsMap, string>;
+export type SchemaFormAllFieldType = SchemaFormFieldType | ExtendedFieldType;
+export type SchemaFormAllPropsMap = SchemaFormComponentPropsMap & SchemaFormNamespace.PropsMap;
+export type SchemaFormComponent = React.ComponentType<any> | React.LazyExoticComponent<React.ComponentType<any>>;
+export declare const componentsMap: Record<SchemaFormAllFieldType, SchemaFormComponent>;
+export type SchemaFormComponentsMap = Partial<Record<ExtendedFieldType, SchemaFormComponent>>;
+export type FieldProps = {
+    [K in SchemaFormAllFieldType]: {
+        type: K;
+        fieldProps?: K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown;
+    };
+}[SchemaFormAllFieldType] | {
+    type?: 'input';
+    fieldProps?: InputProps;
+};

package/model/packages/react/ui/components/Form/SchemaForm/index.d.ts

@@ -0,0 +1,59 @@
+import type { MOmit } from "../../../../../../../fe/packages/react/ui/types/index";
+import { type FormInstance } from "rc-field-form";
+import type { Rule } from "rc-field-form/es/interface";
+import { type ReactNode } from "react";
+import { type FormProps } from "..";
+import { type ButtonElementProps } from "../../Button";
+import type { LabelLayout } from "../../Label";
+import { type FieldProps, type SchemaFormAllFieldType } from "./data";
+export type { FieldProps, SchemaFormAllFieldType, SchemaFormAllPropsMap, SchemaFormComponent, SchemaFormComponentsMap, SchemaFormComponentPropsMap, SchemaFormFieldType, SchemaFormNamespace, } from "./data";
+export type FormFieldType = SchemaFormAllFieldType;
+type BaseField<T> = {
+    [K in keyof T]: {
+        key: K | number | (K | number)[];
+        label?: ReactNode;
+        rules?: Rule[];
+        required?: boolean;
+        className?: string;
+        labelClassName?: string;
+        errorClassName?: string;
+        showError?: boolean;
+        render?: (value: T[K], onChange: (value: T[K]) => void, meta: {
+            errors: string[];
+            warnings: string[];
+        }) => ReactNode;
+        layout?: Required<LabelLayout>['layout'];
+        affterNode?: ReactNode;
+    };
+}[keyof T];
+type GroupField<T> = {
+    type: 'group';
+    childrens: FormFieldSchema<T>[];
+    fieldProps: React.HTMLAttributes<HTMLDivElement>;
+} & BaseField<T>;
+type NotGroupField<T> = FieldProps & BaseField<T>;
+export type FormFieldSchema<T> = GroupField<T> | NotGroupField<T>;
+export interface SchemaFormProps<T = object> extends MOmit<FormProps<T>, 'initialValues' | 'children' | 'preserve'> {
+    form?: FormInstance<T>;
+    getForm?: (formInstance: FormInstance<T>) => void;
+    schemas: FormFieldSchema<T>[];
+    className?: string;
+    onFinish?: (values: T) => void;
+    onFinishFailed?: (errorInfo: any) => void;
+    initialValues?: T;
+    layout?: Required<LabelLayout>['layout'];
+    fieldLayout?: Required<LabelLayout>['layout'];
+    footerButtons?: boolean | ReactNode;
+    submitText?: ReactNode;
+    cancelText?: ReactNode;
+    onCancel?: () => void;
+    buttonClassName?: string;
+    submitButtonProps?: Omit<ButtonElementProps, 'type' | 'onClick' | 'children'>;
+    cancelButtonProps?: Omit<ButtonElementProps, 'onClick' | 'children'>;
+    preserve?: boolean;
+}
+export declare const SchemaForm: {
+    <T extends object>({ form, getForm, schemas, className, onFinish, onFinishFailed, initialValues, footerButtons, submitText, cancelText, onCancel, buttonClassName, submitButtonProps, layout, fieldLayout, cancelButtonProps, ...formProps }: SchemaFormProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default SchemaForm;

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

@@ -0,0 +1,4 @@
+export * from "./Form";
+export * from "./FormItem";
+export * from "./useForm";
+export * from "./SchemaForm";

package/model/packages/react/ui/components/Form/useForm.d.ts

@@ -0,0 +1,2 @@
+export { useForm } from "rc-field-form";
+export type { FormInstance } from "rc-field-form";

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

@@ -0,0 +1,7 @@
+export type ImagePreviewControllerProps = {
+    open: boolean;
+    images: string[];
+    initialIndex?: number;
+    onClose: () => void;
+};
+export declare function ImagePreviewController({ open, images, initialIndex, onClose }: ImagePreviewControllerProps): import("react/jsx-runtime").JSX.Element | null;

package/model/packages/react/ui/components/ImagePreview/PreviewImage.d.ts

@@ -0,0 +1,7 @@
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import { type ImagePreviewControllerProps } from "./ImagePreview";
+export type PreviewImageProps = MOmit<ImagePreviewControllerProps, 'open' | 'onClose'> & Pick<Partial<ImagePreviewControllerProps>, 'onClose'> & {
+    thumbSize?: number | string;
+    direction?: 'horizontal' | 'vertical';
+};
+export declare function PreviewImage(props: PreviewImageProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,2 @@
+export * from "./ImagePreview";
+export * from "./PreviewImage";

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

@@ -0,0 +1,22 @@
+import type { ChangeEvent, InputHTMLAttributes, ReactNode } from "react";
+export type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'defaultValue'> & {
+    value?: string;
+    onChange?: (v: string, e: ChangeEvent<HTMLInputElement>) => void;
+    defaultValue?: string;
+    allowClear?: boolean | {
+        clearIcon: ReactNode;
+    };
+    addonAfter?: ReactNode;
+    inputClassName?: string;
+};
+declare const Input: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange"> & {
+    value?: string;
+    onChange?: (v: string, e: ChangeEvent<HTMLInputElement>) => void;
+    defaultValue?: string;
+    allowClear?: boolean | {
+        clearIcon: ReactNode;
+    };
+    addonAfter?: ReactNode;
+    inputClassName?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { Input };

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

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

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

@@ -0,0 +1,25 @@
+import type { ChangeEvent, InputHTMLAttributes, ReactNode } from "react";
+import { type InputNumberConstraints } from "./inputNumberUtils";
+export type InputNumberProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'onChange' | 'step' | 'type' | 'value'> & InputNumberConstraints & {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number | undefined, e: ChangeEvent<HTMLInputElement>) => void;
+    allowClear?: boolean | {
+        clearIcon: ReactNode;
+    };
+    addonAfter?: ReactNode;
+    allowStep?: boolean;
+    inputClassName?: string;
+};
+declare const InputNumber: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "type" | "defaultValue" | "onChange" | "step"> & InputNumberConstraints & {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number | undefined, e: ChangeEvent<HTMLInputElement>) => void;
+    allowClear?: boolean | {
+        clearIcon: ReactNode;
+    };
+    addonAfter?: ReactNode;
+    allowStep?: boolean;
+    inputClassName?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { InputNumber };

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

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

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;