@_tc/template-core 0.0.1-bate.49 → 0.0.1-bate.50

package/model/packages/common/log/index.d.ts

@@ -0,0 +1,32 @@
+export declare const ANSI_RESET = "\u001B[0m";
+export declare const ansiColors: {
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly pink: "\u001B[95m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+export type LogColor = keyof typeof ansiColors;
+export type ColorLogOptions = {
+    color?: LogColor;
+    prefix?: string;
+    suffix?: string;
+};
+export type ColorLogAffixes = Omit<ColorLogOptions, 'color'>;
+export declare const colorize: (message: unknown, color?: LogColor) => string;
+export declare const joinColorized: (...messages: readonly unknown[]) => string;
+export declare const logJoinColorized: (...messages: readonly unknown[]) => void;
+export declare function colorLog(color: LogColor, ...data: unknown[]): void;
+export declare function colorLog(...data: unknown[]): void;
+export declare const logColor: (color: LogColor, ...data: unknown[]) => void;
+export declare const logColorized: (...messages: readonly unknown[]) => void;
+export declare const logGreen: (...data: unknown[]) => void;
+export declare const logYellow: (...data: unknown[]) => void;
+export declare const logPink: (...data: unknown[]) => void;
+export declare const logWhite: (...data: unknown[]) => void;
+export declare const logRed: (...data: unknown[]) => void;

package/model/packages/common/number/index.d.ts

@@ -0,0 +1,2 @@
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const toFiniteNumber: (value: unknown, fallback?: number) => number;

package/model/packages/common/object/filterEmpty.d.ts

@@ -0,0 +1,2 @@
+export declare function filterEmpty<T>(data: T): T | undefined;
+export declare const filtereEmpty: typeof filterEmpty;

package/model/packages/common/object/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./filterEmpty";
+export declare const pick: <T extends object, K extends keyof T>(target: T, keys: readonly K[]) => Pick<T, K>;
+export declare const omit: <T extends object, K extends keyof T>(target: T, keys: readonly K[]) => Omit<T, K>;
+export declare const mapValues: <T extends object, TResult>(target: T, mapper: <K extends keyof T>(value: T[K], key: K) => TResult) => { [K in keyof T]: TResult; };

package/model/packages/common/string/index.d.ts

@@ -0,0 +1,3 @@
+export declare const isBlank: (value: string | null | undefined) => boolean;
+export declare const capitalize: (value: string) => string;
+export declare const kebabCase: (value: string) => string;

package/model/packages/common/types/index.d.ts

@@ -0,0 +1,3 @@
+export type Maybe<T> = T | null | undefined;
+export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type Dictionary<T = unknown> = Record<string, T>;

package/model/packages/react/hooks/useBreadcrumb.d.ts

@@ -0,0 +1,9 @@
+export declare const useBreadcrumb: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    items: import("../../../../fe/packages/react/ui/index").BreadcrumbItemData[];
+} & {
+    setItems: (items: import("../../../../fe/packages/react/ui/index").BreadcrumbItemData[]) => void;
+    addItem: (item: import("../../../../fe/packages/react/ui/index").BreadcrumbItemData) => void;
+    removeItem: (id: string | number) => void;
+    clearItems: () => void;
+    setActiveItem: (id: string | number) => void;
+}>>;

package/model/packages/react/hooks/useExecuteOnce.d.ts

@@ -0,0 +1,11 @@
+export declare const executionPhaseType: {
+    readonly mount: "mount";
+    readonly render: "render";
+    readonly unMount: "unMount";
+};
+type ExecutionPhaseTypeKeys = keyof typeof executionPhaseType;
+export type ExecutionPhaseType = (typeof executionPhaseType)[ExecutionPhaseTypeKeys];
+export default function useExecuteOnce<T>(factory: () => T, options?: {
+    executionPhase: ExecutionPhaseType[] | ExecutionPhaseType;
+}): T | null;
+export {};

package/model/packages/react/hooks/useLanguage.d.ts

@@ -0,0 +1 @@
+export declare function useLanguage(): import("../../../../fe/packages/react/ui/index").I18nStore;

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

@@ -0,0 +1,24 @@
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, ReactNode } from "react";
+export type ButtonVariant = 'default' | 'primary' | 'dashed' | 'text' | 'link';
+export type ButtonState = 'danger' | 'ghost';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+type ButtonCommonProps = {
+    size?: ButtonSize;
+    state?: ButtonState;
+    disabled?: boolean;
+    loading?: boolean;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    noUnderline?: boolean;
+    children?: ReactNode;
+};
+type ButtonElementVariant = Exclude<ButtonVariant, 'link'>;
+export type ButtonProps = ButtonElementProps | ButtonLinkProps;
+export type ButtonElementProps = ButtonCommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'disabled'> & {
+    variant?: ButtonElementVariant;
+};
+export type ButtonLinkProps = ButtonCommonProps & AnchorHTMLAttributes<HTMLAnchorElement> & {
+    variant: 'link';
+};
+declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+export { Button };

package/model/packages/react/ui/components/Button/SubmitButton.d.ts

@@ -0,0 +1,8 @@
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import { type ButtonElementProps } from "./Button";
+export type SubmitButtonProps = MOmit<ButtonElementProps, 'onClick'> & {
+    onClick?: (e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => Promise<void | boolean> | void;
+};
+declare const SubmitButton: (props: SubmitButtonProps) => import("react/jsx-runtime").JSX.Element;
+declare const AsynchronousButton: (props: SubmitButtonProps) => import("react/jsx-runtime").JSX.Element;
+export { AsynchronousButton, SubmitButton };

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

@@ -0,0 +1,3 @@
+export { Button } from "./Button";
+export type { ButtonElementProps, ButtonLinkProps, ButtonProps, ButtonSize, ButtonState, ButtonVariant } from "./Button";
+export * from "./SubmitButton";

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

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

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

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

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

@@ -0,0 +1,16 @@
+import type { ChangeEvent, InputHTMLAttributes } from "react";
+export type CheckboxProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'value'> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean, e: ChangeEvent<HTMLInputElement>) => void;
+    value?: boolean;
+};
+declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    onChange?: (checked: boolean, e: ChangeEvent<HTMLInputElement>) => void;
+    value?: boolean;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { Checkbox };

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

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

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

@@ -0,0 +1,11 @@
+export interface ConfirmDialogProps {
+    open: boolean;
+    title?: string;
+    content: string;
+    okText?: string;
+    cancelText?: string;
+    loading?: boolean;
+    onOk: () => void | Promise<void>;
+    onCancel: () => void;
+}
+export declare function ConfirmDialog({ open, title, content, okText, cancelText, loading, onOk, onCancel, }: ConfirmDialogProps): import("react/jsx-runtime").JSX.Element;

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

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

package/model/packages/react/ui/components/DataTable/ActionBtn.d.ts

@@ -0,0 +1,7 @@
+import { type DropdownItem } from "../Dropdown";
+export type ActionOverflow = 'auto' | 'dropdown' | 'inline';
+export interface ActionBtnProps {
+    actions: DropdownItem[];
+    overflow?: ActionOverflow;
+}
+export declare const ActionBtn: ({ actions, overflow }: ActionBtnProps) => import("react/jsx-runtime").JSX.Element | "-";

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

@@ -0,0 +1,32 @@
+import { type ReactNode } from "react";
+import type { DropdownItem } from "../Dropdown";
+import { type PaginationProps } from "../Pagination";
+import { type TableFixed } from "../table";
+import type { ColumnDef } from "../types/baseType";
+import { type ActionOverflow } from "./ActionBtn";
+type DataTableActionColumnOptions<T> = {
+    actions?: DropdownItem[] | ((value: unknown, record: T, index: number) => DropdownItem[]);
+    actionOverflow?: ActionOverflow;
+    fixed?: TableFixed;
+};
+type TableColumnDef<T = Record<string, unknown>> = ColumnDef<T> & DataTableActionColumnOptions<T>;
+type RowSelection<T> = {
+    selectedRowKeys?: Array<string | number>;
+    defaultSelectedRowKeys?: Array<string | number>;
+    onChange?: (selectedRowKeys: Array<string | number>, selectedRows: T[], isAll: boolean) => void;
+    isAll?: boolean;
+    beforeCheckboxNode?: ReactNode;
+};
+interface DataTableProps<T = Record<string, unknown>> {
+    columns: TableColumnDef<T>[];
+    data: T[];
+    rowKey?: keyof T | ((record: T, index: number) => string | number);
+    rowSelection?: RowSelection<T>;
+    pagination?: PaginationProps;
+    loading?: boolean;
+    defaultColumnWidth?: number;
+}
+export declare function DataTable<T = Record<string, unknown>>({ columns, data: pData, loading, rowKey, rowSelection, defaultColumnWidth, pagination: pPagination, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;
+export { ActionBtn } from "./ActionBtn";
+export type { ActionBtnProps } from "./ActionBtn";
+export type { DataTableProps, RowSelection, TableColumnDef };

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";