@llmnative/react 0.1.0

package/dist/types/src/components/ui/Modal.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import type { MotionUIProps } from '../types';
+export type ModalSaveHandler = (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+export type ModalDeleteHandler = (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+interface ModalProps extends MotionUIProps {
+    children: React.ReactNode;
+    title?: React.ReactNode;
+    header?: React.ReactNode;
+    footer?: React.ReactNode | false;
+    onClose?: () => void;
+    onSave?: ModalSaveHandler;
+    onDelete?: ModalDeleteHandler;
+    size?: "sm" | "md" | "lg" | "xl" | "fullscreen";
+    position?: "center" | "top" | "left" | "right" | "bottom";
+    buttonFullscreen?: boolean;
+    buttonCancel?: boolean;
+    headerClass?: string;
+    titleClass?: string;
+    subTitleClass?: string;
+    bodyClass?: string;
+    footerClass?: string;
+    closeOnBackdrop?: boolean;
+}
+interface ModalYesNoProps {
+    title?: React.ReactNode;
+    children: React.ReactNode;
+    onYes?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    onNo?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    onClose?: () => void;
+}
+interface ModalOkProps {
+    children: React.ReactNode;
+    title?: React.ReactNode;
+    onClose?: () => void;
+}
+declare const Modal: (props: ModalProps) => React.JSX.Element;
+export declare const ModalYesNo: ({ children, title, onYes, onNo, onClose }: ModalYesNoProps) => React.JSX.Element;
+export declare const ModalOk: ({ children, title, onClose }: ModalOkProps) => React.JSX.Element;
+export default Modal;

package/dist/types/src/components/ui/Pagination.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { UIProps } from "../index";
+export type PaginationParams = {
+    page?: number;
+    limit?: number;
+    navLimit?: number;
+    scrollToTopOnChange?: boolean;
+    scrollBehavior?: ScrollBehavior;
+    align?: "start" | "center" | "end";
+    sticky?: boolean;
+};
+interface PaginationProps<T> extends UIProps, PaginationParams {
+    recordSet: T[];
+    children: (pageRecords: T[], pageOffset: number) => React.ReactNode;
+    appendTo?: HTMLElement | null;
+}
+declare const Pagination: <T>({ recordSet, children, limit, page, navLimit, appendTo, pre, post, className, wrapClass, scrollToTopOnChange, scrollBehavior, align, sticky }: PaginationProps<T>) => React.JSX.Element;
+export default Pagination;

package/dist/types/src/components/ui/Percentage.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import { UIProps } from '../..';
+type ColorType = "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
+type ShapeType = "bar" | "circle";
+interface PercentageProps extends UIProps {
+    val?: number;
+    max?: number;
+    min?: number;
+    shape?: ShapeType;
+    type?: ColorType;
+    background?: ColorType;
+    thickness?: number;
+    showText?: boolean;
+    size?: number;
+    fontSize?: number;
+    label?: string;
+}
+declare const Percentage: ({ val, max, min, shape, type, background, thickness, showText, size, fontSize, label, pre, post, wrapClass, className }: PercentageProps) => React.JSX.Element;
+export default Percentage;

package/dist/types/src/components/ui/Repeat.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { FieldOnChange } from '../widgets/Form';
+interface RepeatProps {
+    name: string;
+    children: React.ReactNode | ((record: any) => React.ReactNode);
+    value?: any[];
+    onChange?: FieldOnChange;
+    onAdd?: (value: any[]) => void;
+    onRemove?: (index: number) => void;
+    className?: string;
+    layout?: 'vertical' | 'horizontal' | 'inline';
+    min?: number;
+    max?: number;
+    label?: string;
+    readOnly?: boolean;
+}
+declare const Repeat: ({ name, children, onChange, onAdd, onRemove, className, layout, min, max, label, readOnly, }: RepeatProps) => React.JSX.Element;
+export default Repeat;

package/dist/types/src/components/ui/Tab.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { MotionUIProps } from '../types';
+export type TabPosition = "default" | "top" | "left" | "right" | "bottom";
+interface TabItemProps {
+    label: React.ReactNode;
+    children: React.ReactNode;
+}
+interface TabLayoutProps {
+    menu: React.ReactNode;
+    content: React.ReactNode;
+}
+interface TabProps extends MotionUIProps {
+    children: React.ReactNode;
+    defaultTab?: number;
+    tabPosition?: TabPosition;
+}
+export declare const TabLayouts: Record<TabPosition, (props: TabLayoutProps) => JSX.Element>;
+export declare const TabItem: React.FC<TabItemProps>;
+declare const Tab: React.FC<TabProps>;
+export default Tab;

package/dist/types/src/components/ui/TabDynamic.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { TabPosition } from './Tab';
+import { FieldOnChange } from '../widgets/Form';
+interface TabDynamicProps {
+    children: React.ReactNode | ((record: any) => React.ReactNode);
+    name: string;
+    onChange?: FieldOnChange;
+    onAdd?: (value: any[]) => void;
+    onRemove?: (index: number) => void;
+    value?: any[];
+    label?: string;
+    min?: number;
+    max?: number;
+    activeIndex?: number;
+    title?: string;
+    readOnly?: boolean;
+    tabPosition?: TabPosition;
+}
+declare const TabDynamic: ({ children, name, onChange, onAdd, onRemove, label, min, max, activeIndex, title, readOnly, tabPosition }: TabDynamicProps) => React.JSX.Element;
+export default TabDynamic;

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import { RecordArray, RecordProps } from "../../providers/data/DataProvider";
+import { UIProps } from '../';
+import { PaginationParams } from './Pagination';
+import { type OrderConfig } from '../../libs/order';
+import { RecordSelectionState } from './useRecordSelection';
+export type TableHeaderProp = {
+    key: string;
+    label: string;
+    className?: string;
+    sort?: boolean;
+};
+export type TableReorderMeta = {
+    fromIndex: number;
+    toIndex: number;
+    record: RecordProps;
+};
+export type TableSelectionState = RecordSelectionState<RecordProps>;
+export type TableSelectionMode = 'single' | 'multiple';
+export type TableSelectionChangeHandler = (selection: TableSelectionState) => void;
+export type TableReorderHandler = (reorderedRecords: RecordArray, meta: TableReorderMeta) => void;
+interface TableProps extends UIProps {
+    header?: TableHeaderProp[];
+    body?: RecordArray;
+    Footer?: string | React.ReactNode;
+    onClick?: (record: RecordProps) => void;
+    onReorder?: TableReorderHandler;
+    onSelectionChange?: TableSelectionChangeHandler;
+    selectionMode?: TableSelectionMode;
+    sortable?: boolean | OrderConfig;
+    pagination?: PaginationParams;
+    activeKey?: string | null;
+    selectedKeys?: string[];
+    selectedRowKeys?: string[];
+    headerClass?: string;
+    bodyClass?: string;
+    footerClass?: string;
+    heightClass?: string;
+    scrollClass?: string;
+    selectedClass?: string;
+}
+declare function Table({ header, body, Footer, onClick, onReorder, onSelectionChange, selectionMode, sortable, pagination, activeKey, selectedKeys, selectedRowKeys, pre, post, wrapClass, className, headerClass, bodyClass, footerClass, heightClass, scrollClass, selectedClass }: TableProps): React.JSX.Element;
+export default Table;

package/dist/types/src/components/ui/fields/AssistantAI.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { UIProps } from '../../index';
+interface AssistantAIProps extends UIProps {
+    name: string;
+    promptTopic: {
+        prompt: string;
+        label: string;
+    };
+    configVariables: {
+        lang: string;
+        voice: string;
+        style: string;
+        limit: string;
+    };
+    initialValue?: string;
+    children?: React.ReactNode;
+    onChange: (e: any) => void;
+    viewMode?: 'list' | 'carousel';
+    autoStart?: boolean;
+    onReset?: () => void;
+}
+declare const AssistantAI: ({ name, promptTopic, configVariables, initialValue, children, onChange, viewMode, autoStart, onReset, pre, post, wrapClass, className }: AssistantAIProps) => React.JSX.Element;
+export default AssistantAI;

package/dist/types/src/components/ui/fields/Command.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export declare const Command: React.FC<{
+    children: React.ReactNode;
+}> & {
+    Trigger: React.FC<TriggerProps>;
+};
+type TriggerProps = {
+    char: string;
+    onSelect: (value: string) => React.ReactNode;
+    children: (props: {
+        filter: string;
+        select: (value: string) => void;
+    }) => React.ReactNode;
+};
+export {};

package/dist/types/src/components/ui/fields/Crop.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import { FileProps } from "./Upload";
+interface CropProps {
+    fileName: string;
+    type: string;
+    scale: string;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    base64?: string;
+}
+interface ImageProps extends FileProps {
+    variants: Record<string, CropProps>;
+}
+export declare const CropImage: React.ForwardRefExoticComponent<{
+    img: ImageProps;
+    title?: string;
+} & React.RefAttributes<unknown>>;
+interface FileNameEditorProps {
+    value: string;
+    onChange: (newName: string) => void;
+    scale?: string;
+    label?: string;
+}
+export declare const FileNameEditor: ({ value, onChange, label, scale, }: FileNameEditorProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/ui/fields/ImageUrl.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { FormFieldProps } from "../../widgets/Form";
+import { PromptMode } from "./Prompt";
+export interface ImageUrlProps extends FormFieldProps {
+    mode?: PromptMode;
+}
+export declare const ImageUrl: ({ name, label, required, onChange, defaultValue, pre, post, wrapClass, className, mode, }: ImageUrlProps) => React.JSX.Element;

package/dist/types/src/components/ui/fields/Input.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import { UIProps } from '../../..';
+import { FormFieldProps, InputType } from '../../widgets/Form';
+interface BaseInputProps extends FormFieldProps {
+    placeholder?: string;
+    type?: InputType;
+    updatable?: boolean;
+    disabled?: boolean;
+    feedback?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+interface LabelProps {
+    label: string;
+    required?: boolean;
+    htmlFor?: string;
+    className?: string;
+}
+export type InputProps = Omit<BaseInputProps, 'type'>;
+export interface CheckboxProps extends FormFieldProps {
+    title?: string;
+    valueChecked?: string | number;
+}
+export interface TextAreaProps extends FormFieldProps {
+    placeholder?: string;
+    updatable?: boolean;
+    disabled?: boolean;
+    rows?: number;
+    feedback?: string;
+    useRef?: any;
+}
+export interface ListGroupProps extends UIProps {
+    children: React.ReactNode[];
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, index: number) => void;
+    label?: string;
+    draggable?: boolean;
+    onDrop?: (text: string) => string;
+    actives?: number[];
+    disables?: number[];
+    loaders?: number[];
+    itemClass?: string;
+}
+export declare const Input: ({ name, onChange, defaultValue, placeholder, label, type, required, updatable, disabled, pre, post, feedback, min, max, step, wrapClass, className }: BaseInputProps) => React.JSX.Element;
+export declare const String: (props: InputProps) => React.JSX.Element;
+export declare const Number: (props: InputProps) => React.JSX.Element;
+export declare const Email: (props: InputProps) => React.JSX.Element;
+export declare const Password: (props: InputProps) => React.JSX.Element;
+export declare const Color: (props: InputProps) => React.JSX.Element;
+export declare const Date: (props: InputProps) => React.JSX.Element;
+export declare const Time: (props: InputProps) => React.JSX.Element;
+export declare const DateTime: (props: InputProps) => React.JSX.Element;
+export declare const Week: (props: InputProps) => React.JSX.Element;
+export declare const Month: (props: InputProps) => React.JSX.Element;
+export declare const Range: (props: InputProps) => React.JSX.Element;
+export declare const Url: (props: InputProps) => React.JSX.Element;
+export declare const Checkbox: ({ name, onChange, defaultValue, label, title, required, valueChecked, pre, post, wrapClass, className }: CheckboxProps) => React.JSX.Element;
+export declare const Switch: (props: CheckboxProps) => React.JSX.Element;
+export declare const Label: ({ label, required, htmlFor, className }: LabelProps) => React.JSX.Element;
+export declare const TextArea: ({ name, onChange, defaultValue, placeholder, label, required, updatable, disabled, rows, useRef, pre, post, feedback, className, wrapClass }: TextAreaProps) => React.JSX.Element;
+export declare const ListGroup: ({ children, onClick, label, actives, draggable, onDrop, disables, loaders, pre, post, wrapClass, className, itemClass }: ListGroupProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/ui/fields/Prompt.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { AIFetchConfig } from '../../../providers/ai';
+import { PromptVariables } from '../../../conf/Prompt';
+import { FormFieldProps } from '../../widgets/Form';
+export declare enum PromptMode {
+    EDITOR = "editor",
+    LIVE = "live"
+}
+type PromptOptions = AIFetchConfig & {
+    value: string;
+};
+type OnRunPrompt = (prompt: string, config: AIFetchConfig, data?: PromptVariables) => Promise<string>;
+export interface PromptProps extends FormFieldProps {
+    mode?: PromptMode;
+    onRunPrompt?: OnRunPrompt;
+    renderPromptDisabled?: (props: Omit<FormFieldProps, "defaultValue">) => React.ReactNode;
+    rows?: number;
+    defaultValue?: {
+        value?: string;
+        enabled?: boolean;
+        role?: string;
+        language?: string;
+        voice?: string;
+        style?: string;
+        model?: string;
+        temperature?: number;
+    };
+}
+export declare const Prompt: ({ mode, onRunPrompt, renderPromptDisabled, ...props }: PromptProps) => React.JSX.Element;
+export declare const runPrompt: (options: PromptOptions, data?: PromptVariables, onRunPrompt?: OnRunPrompt) => Promise<string>;
+export {};

package/dist/types/src/components/ui/fields/Select.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { type OrderConfig } from "../../../libs/order";
+import { DBConfig, RecordProps } from "../../../providers/data/DataProvider";
+import { FormFieldProps } from '../../widgets/Form';
+interface Option extends RecordProps {
+    label: string;
+    value: string;
+}
+type OptionOrderConfig = OrderConfig & {
+    field: 'label' | 'value';
+};
+interface BaseProps extends FormFieldProps {
+    updatable?: boolean;
+    disabled?: boolean;
+    title?: string;
+    feedback?: string;
+    options?: Option[] | string[] | number[];
+    db?: DBConfig;
+    order?: OptionOrderConfig;
+}
+export interface SelectProps extends BaseProps {
+    optionEmpty?: Option;
+    value?: string | number;
+}
+export interface AutocompleteProps extends BaseProps {
+    min?: number;
+    max?: number;
+    placeholder?: string;
+    creatable?: boolean;
+    onCreate?: (value: string) => Promise<void> | void;
+}
+export interface ChecklistProps extends BaseProps {
+    checkClass?: string;
+}
+export declare const Select: ({ name, onChange, defaultValue, required, updatable, disabled, optionEmpty, label, title, pre, post, feedback, options, db, order, wrapClass, className, }: SelectProps) => React.JSX.Element;
+export declare const Autocomplete: ({ name, defaultValue, min, max, onChange, required, updatable, disabled, label, title, placeholder, pre, post, feedback, options, db, order, wrapClass, className, creatable, onCreate, }: AutocompleteProps) => React.JSX.Element;
+export declare const Checklist: ({ name, defaultValue, onChange, required, updatable, disabled, label, title, pre, post, feedback, options, db, order, wrapClass, className, checkClass, }: ChecklistProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/ui/fields/Upload.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import { FormFieldProps } from "../../widgets/Form";
+export interface FileProps {
+    key: string;
+    fileName: string;
+    size: number;
+    type: string;
+    progress: number;
+    url: string;
+    base64?: string;
+    variants: Record<string, any>;
+}
+export interface UploadDocumentProps extends FormFieldProps {
+    editable?: boolean;
+    multiple?: boolean;
+    accept?: string;
+    max?: number;
+}
+export interface UploadImageProps extends UploadDocumentProps {
+    previewHeight?: number;
+    previewWidth?: number;
+}
+export declare const getFileUrl: (file: FileProps, suffix?: string) => string;
+export declare const UploadDocument: ({ name, onChange, label, required, editable, multiple, max, accept, pre, post, wrapClass, className, }: UploadDocumentProps) => React.JSX.Element;
+export declare const UploadImage: ({ name, onChange, label, editable, multiple, accept, required, max, previewHeight, previewWidth, pre, post, wrapClass, className, }: UploadImageProps) => React.JSX.Element;

package/dist/types/src/components/ui/fields/UploadCSV.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { UIProps } from '../../..';
+export type UploadCSVCell = string | null | undefined;
+export interface UploadCSVRow {
+    [key: string]: UploadCSVCell;
+}
+export interface UploadCSVData {
+    data: UploadCSVRow[];
+    fields: string[];
+    file: File;
+}
+export type UploadCSVParseField = [key: string, value: UploadCSVCell];
+export type UploadCSVDataLoadedHandler = (results: UploadCSVData) => void;
+export type UploadCSVParseFieldHandler = (field: UploadCSVParseField) => UploadCSVParseField | undefined;
+interface UploadCSVProps extends UIProps {
+    name: string;
+    onDataLoaded: UploadCSVDataLoadedHandler;
+    onParseField?: UploadCSVParseFieldHandler;
+    label?: string;
+    icon?: string;
+    delimiter?: string;
+    normalizeKeys?: boolean;
+    removeEmptyFields?: boolean;
+}
+export declare const UploadCSV: React.FC<UploadCSVProps>;
+export {};

package/dist/types/src/components/ui/useRecordSelection.d.ts

@@ -0,0 +1,20 @@
+export type RecordSelectionState<TRecord> = {
+    keys: string[];
+    records: TRecord[];
+    clear: () => void;
+    hasSelection: boolean;
+};
+type UseRecordSelectionArgs<TRecord> = {
+    records: TRecord[];
+    selectedKeys?: string[];
+    legacySelectedKeys?: string[];
+    onSelectionChange?: (selection: RecordSelectionState<TRecord>) => void;
+    getRecordKey: (record: TRecord, index: number) => string;
+};
+export declare function useRecordSelection<TRecord>({ records, selectedKeys, legacySelectedKeys, onSelectionChange, getRecordKey, }: UseRecordSelectionArgs<TRecord>): {
+    activeSelectedKeys: string[];
+    selectionState: RecordSelectionState<TRecord>;
+    showSelection: boolean;
+    updateSelection: (nextKeys: string[]) => void;
+};
+export {};

package/dist/types/src/components/ui/useStableRecordKey.d.ts

@@ -0,0 +1,5 @@
+type RecordWithOptionalKey = {
+    _key?: string;
+};
+export declare function useStableRecordKey<TRecord extends RecordWithOptionalKey>(prefix: string): (record: TRecord, _index?: number) => string;
+export {};

package/dist/types/src/components/widgets/Form.d.ts

@@ -0,0 +1,129 @@
+import React from 'react';
+import { RecordProps } from "../../providers/data/DataProvider";
+import { FormTree, ModelProps } from "../Component";
+import { UIProps } from '../';
+export type ChangeHandler = React.ChangeEvent<any> | {
+    target: {
+        name: string;
+        value?: any;
+    };
+};
+type FormHandleChange = (event: ChangeHandler) => void;
+export type FieldOnChange = (params: {
+    event: ChangeHandler;
+    name: string;
+    value: any;
+    record: RecordProps;
+    onChange: FormHandleChange;
+}) => void;
+export type InputType = "text" | "number" | "email" | "password" | "color" | "date" | "time" | "datetime-local" | "week" | "month" | "range" | "checkbox" | "radio" | "url";
+interface FormContextProps {
+    name: string;
+    onChange?: FieldOnChange;
+    wrapClass?: string;
+    inputType?: InputType;
+    defaultValue?: any;
+}
+interface FormContextResult {
+    value: any;
+    handleChange: FormHandleChange;
+    formWrapClass?: string;
+    record: RecordProps;
+}
+export interface FormFieldProps extends UIProps {
+    name: string;
+    label?: string;
+    value?: any;
+    required?: boolean;
+    onChange?: FieldOnChange;
+    defaultValue?: any;
+}
+interface SetFormFieldsNameProps {
+    children: React.ReactNode;
+    parentName: string;
+    parentKey?: string;
+    wrapClass?: string;
+}
+export declare const useFormContext: ({ name, onChange, wrapClass, inputType, defaultValue }: FormContextProps) => FormContextResult;
+type UseHandleDropProps = {
+    name: string;
+    value: string;
+    handleChange?: FormHandleChange;
+};
+export declare const useHandleDrop: ({ name, value, handleChange }: UseHandleDropProps) => (e: React.DragEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+export declare const setFormFieldsName: ({ children, parentName, parentKey, wrapClass }: SetFormFieldsNameProps) => React.ReactNode;
+export type SavePathProps = {
+    record: RecordProps;
+    storagePath?: string;
+};
+export type FormSaveArgs = {
+    record?: RecordProps;
+    prevRecord?: RecordProps;
+    storagePath?: string;
+    action: 'create' | 'update';
+};
+export type FormDeleteArgs = {
+    record?: RecordProps;
+};
+export type FormFinallyArgs = {
+    record?: RecordProps;
+    action: 'create' | 'update' | 'delete';
+};
+export type FormSaveHandler = (args: FormSaveArgs) => Promise<string | undefined>;
+export type FormDeleteHandler = (args: FormDeleteArgs) => Promise<string | undefined>;
+export type FormFinallyHandler = (args: FormFinallyArgs) => Promise<boolean>;
+interface BaseFormProps {
+    aspect?: "card" | "empty";
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    dataStoragePath?: string;
+    handlers?: FormHandlers;
+    setPrimaryKey?: (record: RecordProps) => string;
+    savePath?: (props: SavePathProps) => string | undefined;
+    onLoad?: (record: RecordProps) => void;
+    onChange?: (record: RecordProps) => void;
+    onSave?: FormSaveHandler;
+    onDelete?: FormDeleteHandler;
+    onFinally?: FormFinallyHandler;
+    log?: boolean;
+    showNotice?: boolean;
+    showBack?: boolean;
+    wrapClass?: string;
+    headerClass?: string;
+    className?: string;
+    footerClass?: string;
+}
+interface FormDefaultProps extends BaseFormProps {
+    children: React.ReactNode | ((fields: FormTree) => React.ReactNode) | ((args: {
+        record?: RecordProps;
+    }) => React.ReactNode);
+    defaultValues?: RecordProps;
+}
+interface FormDatabaseProps extends FormDefaultProps {
+    dataStoragePath: string;
+}
+interface FormModelProps extends BaseFormProps {
+    model: ModelProps;
+    children?: ((fields: FormTree) => React.ReactNode);
+}
+interface FormProps extends BaseFormProps {
+    children?: React.ReactNode | ((fields: FormTree) => React.ReactNode) | ((args: {
+        record?: RecordProps;
+    }) => React.ReactNode);
+    defaultValues?: RecordProps;
+}
+export interface FormRef {
+    handleSave: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    handleDelete: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    getHeader: () => React.ReactNode;
+    getRecord: () => {
+        record: RecordProps;
+        isNewRecord: boolean;
+    };
+    getFooter: () => React.ReactNode;
+}
+type FormHandlers = Partial<FormRef>;
+export declare const FormDatabase: React.ForwardRefExoticComponent<FormDatabaseProps & React.RefAttributes<FormRef>>;
+export declare function FormModel({ model, children, ...formProps }: FormModelProps): React.JSX.Element | null;
+declare const _default: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<FormRef>>;
+export default _default;

package/dist/types/src/components/widgets/Grid.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { type RecordProps } from "../../providers/data/DataProvider";
+import { type GridProps } from "./grid-core/types";
+declare function Grid<TRecord extends RecordProps = RecordProps>(props: GridProps<TRecord>): React.JSX.Element;
+export default Grid;
+export type * from "./grid-core/types";

package/dist/types/src/components/widgets/ImageEditor.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import 'tui-image-editor/dist/tui-image-editor.css';
+type ImageEditorProps = {
+    imageUrl: string;
+    title?: string;
+    width?: number;
+    height?: number;
+    modal?: boolean;
+    onImageLoad?: () => void;
+    onClose?: () => void;
+    onSave?: (dataUrl: string) => void;
+};
+declare const ImageEditor: ({ imageUrl, title, width, height, modal, onImageLoad, onClose, onSave }: ImageEditorProps) => React.JSX.Element;
+export default ImageEditor;

package/dist/types/src/components/widgets/MarkdownReader.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Components } from 'react-markdown';
+import { type PageMetadataState } from '../../Head';
+type MarkdownComponents = Components;
+export interface MarkdownReaderProps {
+    content: string;
+    components?: MarkdownComponents;
+    className?: string;
+    wrapClass?: string;
+    head?: PageMetadataState;
+    onNavigateInternal?: (href: string, event: React.MouseEvent<HTMLAnchorElement>) => void;
+}
+export default function MarkdownReader({ content, components, className, wrapClass, head, onNavigateInternal, }: MarkdownReaderProps): React.JSX.Element;
+export {};