autoforma 1.0.85 → 1.1.0

package/README.md

@@ -1,157 +1,211 @@
-
-# AutoForm
-
-AutoForm is a dynamic form builder component for React applications, using **Mantine**. It generates forms dynamically based on a schema definition. This allows for faster form creation and less repetitive code when working with forms in your React applications.
-
-## Features
-
-- **Dynamic Form Rendering**: AutoForm renders fields based on the provided schema, making form generation easy.
-- **Field Types Support**: Supports various input types like `text`, `number`, `password`, `select`, `checkbox`, etc.
-- **Validation Support**: Integrates with form validation mechanisms.
-- **Custom Layout**: Supports custom layout rendering via the `container` and `fieldContainer` props.
-- **Read-Only Mode**: Option to set the form in read-only mode.
-- **Field Customization**: Easily customize field rendering for different input types.
-- **Conditional Rendering**: Hide fields or conditionally render based on certain conditions.
-
-## Installation
-
-To install `AutoForm`, you can use npm or yarn:
-
-```bash
-npm install @mantine/core react
-```
-
-## Usage
-
-### Example Usage
-
-```tsx
-import React from 'react';
-import AutoForm from './AutoForm';  // Path to your AutoForm component
-import { Button, Grid, Group } from '@mantine/core';
-
-const schema = [
-  { name: 'firstName', label: 'First Name', type: 'text' },
-  { name: 'age', label: 'Age', type: 'number' },
-  { name: 'subscribe', label: 'Subscribe?', type: 'checkbox' },
-  { name: 'role', label: 'Role', type: 'select', options: ['User', 'Admin'] },
-];
-
-const MyForm = () => {
-  const onSubmit = (values) => {
-    alert(JSON.stringify(values, null, 2));
-  };
-
-  return (
-    <AutoForm
-      schema={schema}
-      onSubmit={onSubmit}
-      container={(form, onSubmit, readOnly) => (
-        <>
-          <Grid>{form}</Grid>
-          {!readOnly && (
-            <Group justify="flex-end">
-              <Button onClick={onSubmit}>Submit</Button>
-            </Group>
-          )}
-        </>
-      )}
-    />
-  );
-};
-```
-
-### Props
-
-| Prop             | Type                                                                           | Description                                                                 |
-|------------------|--------------------------------------------------------------------------------|-----------------------------------------------------------------------------|
-| `schema`         | `FieldSchema[]`                                                                | List of field definitions to render. Each field specifies `name`, `type`, etc. |
-| `values`         | `Record<string, any>`                                                          | Initial values for the form fields. Optional.                              |
-| `onSubmit`       | `(values: Record<string, any>) => void`                                        | Callback triggered on form submission with current form values.            |
-| `container`      | `(form: ReactNode, onSubmit: () => void, readOnly?: true) => ReactNode`        | Custom render wrapper around the form and submit button.                   |
-| `fieldContainer` | `(field: ReactNode, fieldSchema: FieldSchema) => ReactNode`                    | Optional. Custom layout for each field (e.g., grid wrappers).              |
-| `customRender`   | `FieldRenderCustomRender`                                                      | Optional. Override how specific field types are rendered.                  |
-| `validate`       | `FormValidateInput<Record<string, any>>`                                       | Optional validation logic. Uses Mantine-compatible validation.             |
-| `readOnly`       | `true`                                                                         | Optional. When true, disables all inputs (read-only mode).                 |
-| `onFieldChange`  | `(name: string, value: any, values: Record<string, any>) => Record<string, any>` | Optional. Modify or transform values when a field changes.                 |
-
-### Custom Layout
-
-You can customize the layout of the entire form or specific fields by using the `container` and `fieldContainer` props.
-
-#### Example: Customizing the Form Layout
-
-```tsx
-const customLayout = (form, onSubmit, readOnly) => (
-  <>
-    <div className="form-container">{form}</div>
-    {!readOnly && <button onClick={onSubmit}>Submit</button>}
-  </>
-);
-```
-
-#### Example: Customizing Field Layout
-
-```tsx
-const customFieldLayout = (field, fieldSchema) => (
-  <div className="custom-field">{field}</div>
-);
-```
-
-### Validation
-
-AutoForm supports validation through the `validate` prop. You can pass a validation function that returns an object of validation errors.
-
-Example:
-
-```tsx
-const validateForm = (values) => {
-  const errors = {};
-  if (!values.firstName) errors.firstName = 'First name is required';
-  if (!values.age) errors.age = 'Age is required';
-  return errors;
-};
-
-<AutoForm
-  schema={schema}
-  validate={validateForm}
-  onSubmit={(values) => console.log(values)}
-  container={(form, onSubmit) => (
-    <>
-      <Grid>{form}</Grid>
-      <Button onClick={onSubmit}>Submit</Button>
-    </>
-  )}
-/>
-```
-
-### Hide Fields
-
-To hide a field from rendering, you can set the `hidden` property in the schema.
-
-Example:
-
-```tsx
-const schema = [
-  { name: 'firstName', label: 'First Name', type: 'text' },
-  { name: 'internalCode', label: 'Internal Code', type: 'text', hidden: true },
-];
-```
-
-This will ensure the "Internal Code" field is not rendered.
-
----
-
-## Contributing
-
-1. Fork the repository
-2. Create a new branch (`git checkout -b feature-branch`)
-3. Commit your changes (`git commit -am 'Add feature'`)
-4. Push to the branch (`git push origin feature-branch`)
-5. Create a new Pull Request
-
----
-
-## License
-
-Distributed under the MIT License. See `LICENSE` for more information.
+# 🚀 Introduction
+
+**AutoForma** is a modern, dynamic, and extensible **form builder for React** — built on top of [Mantine](https://mantine.dev/) and fully written in TypeScript.  
+It allows you to create powerful forms **entirely from JSON schema definitions**, removing repetitive boilerplate code and giving you full control over field behavior and layout.
+
+With AutoForma, you can:
+- 🧩 Define forms using schema objects — no manual wiring.
+- 🪄 Dynamically show, hide, or disable fields based on other values.
+- 🎨 Customize the UI with your own field renderers.
+- 🧠 Extend with new field types or layouts effortlessly.
+
+> 💡 AutoForma is perfect for dashboards, admin panels, and SaaS apps where flexibility and maintainability matter.
+
+---
+
+## 📦 Installation
+
+Install **AutoForma** along with its required Mantine and React peer dependencies:
+
+```bash
+npm install autoforma   @mantine/core@^8.3.2   @mantine/hooks@^8.3.2   @mantine/form@^8.3.2   @mantine/dates@^8.3.2   @mantine/tiptap@^8.3.2   @tiptap/react@^3.6.6   react@^19.0.0   react-dom@^19.0.0
+```
+
+---
+
+## ⚙️ Setup Requirements
+
+Before using `AutoForma`, wrap your app with the `MantineProvider`  
+and import Mantine’s global styles and optional TipTap editor styles:
+
+```tsx
+import { MantineProvider } from "@mantine/core";
+import "@mantine/core/styles.css";
+import "@mantine/dates/styles.css";
+import "@mantine/tiptap/styles.css";
+
+const Root = () => (
+  <MantineProvider>
+    <App />
+  </MantineProvider>
+);
+```
+
+> ⚠️ Without wrapping your app in `MantineProvider`,  
+> the components may not render or style correctly.
+
+---
+
+# 🧩 Basic Usage
+
+Here’s a quick example of how you can generate a complete form instantly using **AutoForma**.  
+Just define your schema and pass it to the `AutoForm` component — it handles layout, validation, and submission automatically.
+
+```tsx
+import AutoForm from "autoforma";
+import { userFormSchema } from "./schema";
+
+const App = () => (
+  <AutoForm
+    schema={userFormSchema}
+    onSubmit={(values) => console.log("Submitted:", values)}
+  />
+);
+```
+
+> ✅ AutoForma automatically generates labels, validation, and layouts based on your schema.
+
+---
+
+# 🎨 Customization & Field Types
+
+AutoForma gives you full control over how your form behaves and looks.  
+You can **dynamically update field properties** (like visibility, enabled state, or placeholder)  
+and even **inject your own custom field types** using `customFieldTypes`.
+
+---
+
+## 🧠 Supported Field Types
+
+Out of the box, AutoForma supports a rich set of field types:
+
+| Type | Description |
+|------|--------------|
+| `text` | Standard text input |
+| `number` | Numeric input |
+| `select` | Dropdown list |
+| `checkbox` | Boolean checkbox |
+| `date` | Date picker |
+| `datetime` | Combined date & time picker |
+| `time` | Time-only picker |
+| `object` | Nested object field (grouped sub-fields) |
+| `array` | Repeating array of fields |
+| `switch` | Toggle switch |
+| `texteditor` | Rich text editor (TipTap powered) |
+| `tags` | Multi-value tag input |
+| `TCustom` | Any custom type you define via `customFieldTypes` |
+
+You can define your own type like this:
+
+```tsx
+<AutoForm
+  schema={schema}
+  customFieldTypes={{
+    colorPicker: (field, form) => (
+      <input
+        type="color"
+        {...form.getInputProps(field.name)}
+      />
+    ),
+  }}
+/>
+```
+
+---
+
+# ⚙️ API Reference
+
+AutoForma exposes several TypeScript interfaces and configuration objects that make it fully type-safe and flexible.  
+Below are the main types you can use to configure and extend the library.
+
+## 🧩 `AutoFormProps<TValues>`
+
+The main props accepted by the `AutoForm` component.
+
+```ts
+export type AutoFormProps<
+  TValues extends Record<string, any> = Record<string, any>
+> = CustomRenderersConfig<TValues> & {
+  schema: (FieldSchema<TValues> & Record<string, any>)[];
+
+  initialValues?: ValueProvider<TValues>;
+  currentValues?: ValueProvider<TValues>;
+
+  prepareValues?: (values: TValues) => TValues | Promise<TValues>;
+  onSubmit: (values: TValues) => void | Promise<void>;
+  afterSubmit?: (values: TValues) => void | Promise<void>;
+
+  validate?: FormValidateInput<TValues>;
+  readOnly?: boolean;
+
+  onFieldChange?: OnFieldChangeMap<TValues>;
+
+  layout?: "vertical" | "horizontal" | "grid";
+
+  updateFieldSchema?: UpdateFieldSchemaMap<TValues>;
+
+  submitButton?: boolean | React.ReactNode;
+
+  loading?: boolean;
+};
+```
+
+### 🧠 Description of Properties
+
+| Prop | Type | Description |
+|------|------|--------------|
+| `schema` | `FieldSchema[]` | The main schema defining all form fields. |
+| `initialValues` | `ValueProvider<TValues>` | Function or object returning the **initial form values** (called once). |
+| `currentValues` | `ValueProvider<TValues>` | Function or object providing **current values** (reactively updated). |
+| `prepareValues` | `(values) => TValues \| Promise<TValues>` | Modify or sanitize values before submit. |
+| `onSubmit` | `(values) => void \| Promise<void>` | Called when the form is submitted. |
+| `afterSubmit` | `(values) => void \| Promise<void>` | Called after successful submission (for side effects). |
+| `validate` | `FormValidateInput<TValues>` | Mantine validation config or validation schema. |
+| `readOnly` | `boolean` | Makes the entire form read-only. |
+| `onFieldChange` | `OnFieldChangeMap<TValues>` | Map of field-specific change handlers. |
+| `layout` | `"vertical" \| "horizontal" \| "grid"` | Form layout type. |
+| `updateFieldSchema` | `UpdateFieldSchemaMap<TValues>` | Dynamically modify schema based on values. |
+| `submitButton` | `boolean \| ReactNode` | Whether to render or customize the submit button. |
+| `loading` | `boolean` | Display a global loading state for the form. |
+
+---
+
+## 🧩 `CustomRenderersConfig<TValues>`
+
+Defines all the ways you can override the default rendering logic.
+
+```ts
+export type CustomRenderersConfig<
+  TValues extends Record<string, any> = Record<string, any>
+> = {
+  customFieldRenderers?: Record<
+    string,
+    (
+      field: FieldSchema<TValues>,
+      form: UseFormReturnType<TValues>
+    ) => React.ReactNode
+  >;
+  customTypeRenderers?: Record<
+    string,
+    (
+      field: FieldSchema<TValues>,
+      form: UseFormReturnType<TValues>
+    ) => React.ReactNode
+  >;
+  customFieldTypes?: Record<
+    string,
+    (
+      field: FieldSchema<TValues>,
+      form: UseFormReturnType<TValues>
+    ) => React.ReactNode
+  >;
+};
+```
+
+### 🧠 Description of Properties
+
+| Prop | Type | Description |
+|------|------|--------------|
+| `customFieldRenderers` | `Record<string, (field, form) => ReactNode>` | Override rendering for specific **field names**. |
+| `customTypeRenderers` | `Record<string, (field, form) => ReactNode>` | Override rendering for specific **field types** (like `select`, `text`, etc.). |
+| `customFieldTypes` | `Record<string, (field, form) => ReactNode>` | Register completely new **custom field types**. |

package/dist/components/AutoForm/AutoForm.d.ts

@@ -0,0 +1,3 @@
+import { AutoFormProps, AutoFormRef } from './AutoForm.types';
+declare const AutoForm: import('react').ForwardRefExoticComponent<AutoFormProps<Record<string, any>> & import('react').RefAttributes<AutoFormRef>>;
+export default AutoForm;

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

@@ -0,0 +1,54 @@
+import { FieldSchema } from '../../fields/types';
+import { UseFormReturnType } from '@mantine/form';
+type FormValues = Record<string, any>;
+export type UpdateFieldSchema = {
+    [key: string]: (path: string, fieldSchema: FieldSchema, values: FormValues) => FieldSchema | Promise<FieldSchema>;
+};
+export interface FieldRendererProps<TValues = any> {
+    field: FieldSchema;
+    form: UseFormReturnType<TValues>;
+}
+export type OnFieldChangeMap<TValues extends Record<string, any> = Record<string, any>> = {
+    [K in keyof TValues]?: (path: string, value: TValues[K], form: UseFormReturnType<TValues>) => void | Promise<void>;
+};
+export interface AutoFormProps<FormValues extends Record<string, any> = Record<string, any>> {
+    schema: FieldSchema[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    layout?: "vertical" | "horizontal" | "grid";
+    primaryAction?: boolean;
+    submitLabel?: string;
+    loading?: boolean;
+    values?: () => FormValues | Promise<FormValues>;
+    initialValues?: () => FormValues | Promise<FormValues>;
+    onFieldChange?: OnFieldChangeMap<FormValues>;
+    updateFieldSchema?: UpdateFieldSchema;
+    validate?: (values: FormValues) => Partial<Record<string, string>> | Promise<Partial<Record<string, string>>>;
+    preSubmit?: (values: FormValues) => FormValues | Promise<FormValues>;
+    onSubmit: (values: FormValues) => void | Promise<void>;
+    postSubmit?: (values: FormValues) => void | Promise<void>;
+    uiConfig?: {
+        layout?: {
+            gap?: number;
+            columns?: number;
+            align?: "start" | "center" | "end";
+        };
+        customTypeRenderer?: Record<string, React.ComponentType<FieldRendererProps<FormValues>>>;
+        customFieldNameRenderer?: Record<string, React.ComponentType<FieldRendererProps<FormValues>>>;
+        customFieldTypeRenderer?: Record<string, React.ComponentType<FieldRendererProps<FormValues>>>;
+    };
+}
+export interface AutoFormRef {
+    submit: () => void;
+    reset: (values?: Partial<FormValues>) => void;
+    validate: () => boolean;
+    getValues: () => FormValues;
+    setValues: (values: Partial<FormValues>) => void;
+    getFieldValue: (path: string) => any;
+    setFieldValue: (path: string, value: any) => void;
+    isValid: () => boolean;
+    isDirty: () => boolean;
+    isLoading: () => boolean;
+    watch: <Field extends string>(path: Field, subscriber: (value: any, previousValue: any) => void) => void;
+}
+export {};

package/dist/components/AutoForm/context/FormContext.d.ts

@@ -0,0 +1,3 @@
+export type FormValues = Record<string, any>;
+declare const FormProvider: import('react').FC<import('@mantine/form/lib/FormProvider/FormProvider').FormProviderProps<import('@mantine/form').UseFormReturnType<FormValues, (values: FormValues) => FormValues>>>, useFormContext: () => import('@mantine/form').UseFormReturnType<FormValues, (values: FormValues) => FormValues>, useForm: import('@mantine/form').UseForm<FormValues, (values: FormValues) => FormValues>;
+export { FormProvider, useFormContext, useForm };

package/dist/components/AutoForm/context/RenderersContext.d.ts

@@ -0,0 +1,7 @@
+import { RendererResolverChain } from '../../../fields/renderer-resolver/RendererResolverChain';
+export declare const RendererContext: import('react').Context<RendererResolverChain | null>;
+export declare const RendererProvider: ({ children, value, }: {
+    children: React.ReactNode;
+    value: RendererResolverChain;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useRenderers: <TValues extends Record<string, any> = Record<string, any>>() => RendererResolverChain;

package/dist/components/AutoForm/context/UpdateFieldSchemaContext.d.ts

@@ -0,0 +1,7 @@
+import { UpdateFieldSchema } from '../AutoForm.types';
+export declare const UpdateFieldSchemaContext: import('react').Context<UpdateFieldSchema | null>;
+export declare const UpdateFieldSchemaProvider: ({ children, value, }: {
+    children: React.ReactNode;
+    value: UpdateFieldSchema;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useUpdateFieldSchema: () => UpdateFieldSchema;

package/dist/fields/FieldRenderer/ArrayLayout.d.ts

@@ -0,0 +1,4 @@
+import { FormValues } from '../../components/AutoForm/context/FormContext';
+import { DefaultFieldRendererProps } from './FieldRenderer.types';
+declare const ArrayLayout: (props: DefaultFieldRendererProps<FormValues>) => import("react/jsx-runtime").JSX.Element;
+export default ArrayLayout;

package/dist/fields/FieldRenderer/DefaultFieldRender.d.ts

@@ -0,0 +1,3 @@
+import { DefaultFieldRendererProps } from './FieldRenderer.types';
+export declare function FieldRenderer<TValues extends Record<string, any> = Record<string, any>>(props: DefaultFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default FieldRenderer;

package/dist/fields/FieldRenderer/FieldLayoutWrapper.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FieldSchema } from '../types';
+type FieldLayoutWrapperProps = {
+    field: FieldSchema;
+    layout: "vertical" | "horizontal" | "grid";
+    children: React.ReactNode;
+};
+export declare function FieldLayoutWrapper({ field, layout, children, }: FieldLayoutWrapperProps): import("react/jsx-runtime").JSX.Element;
+export default FieldLayoutWrapper;

package/dist/fields/FieldRenderer/FieldRenderer.d.ts

@@ -0,0 +1,5 @@
+import { FieldSchema } from '../types';
+declare const FieldRenderer: (props: {
+    fieldSchema: FieldSchema;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default FieldRenderer;

package/dist/fields/FieldRenderer/FieldRenderer.types.d.ts

@@ -0,0 +1,7 @@
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from '../types';
+export interface DefaultFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> {
+    field: FieldSchema<TValues>;
+    form: UseFormReturnType<TValues>;
+    layout?: "vertical" | "horizontal" | "grid";
+}

package/dist/fields/FieldRenderer/ObjectLayout.d.ts

@@ -0,0 +1,4 @@
+import { FormValues } from '../../components/AutoForm/context/FormContext';
+import { DefaultFieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+declare const ObjectLayout: ({ field, layout, }: DefaultFieldRendererProps<FormValues>) => import("react/jsx-runtime").JSX.Element;
+export default ObjectLayout;

package/dist/fields/renderer-resolver/BuiltInHandler.d.ts

@@ -0,0 +1,9 @@
+import { FieldSchema } from '../types';
+import { RendererHandler } from './RendererHandler';
+import { default as FieldRenderer } from '../FieldRenderer/DefaultFieldRender';
+export declare class BuiltInHandler implements RendererHandler {
+    private layout;
+    constructor(layout: "vertical" | "horizontal" | "grid");
+    canHandle(): boolean;
+    resolve(field: FieldSchema): typeof FieldRenderer;
+}

package/dist/fields/renderer-resolver/FieldNameHandler.d.ts

@@ -0,0 +1,8 @@
+import { FieldSchema } from '../types';
+import { RendererHandler } from './RendererHandler';
+export declare class FieldNameHandler implements RendererHandler {
+    private renderers;
+    constructor(renderers: Record<string, React.ComponentType<any>>);
+    canHandle(field: FieldSchema): boolean;
+    resolve(field: FieldSchema): import('react').ComponentType<any>;
+}

package/dist/fields/renderer-resolver/FieldTypeHandler.d.ts

@@ -0,0 +1,8 @@
+import { FieldSchema } from '../types';
+import { RendererHandler } from './RendererHandler';
+export declare class FieldTypeHandler implements RendererHandler {
+    private renderers;
+    constructor(renderers: Record<string, React.ComponentType<any>>);
+    canHandle(field: FieldSchema): boolean;
+    resolve(field: FieldSchema): import('react').ComponentType<any>;
+}

package/dist/fields/renderer-resolver/RendererHandler.d.ts

@@ -0,0 +1,6 @@
+import { FieldRendererProps } from '../../components/AutoForm/AutoForm';
+import { FieldSchema } from '../types';
+export interface RendererHandler {
+    canHandle(field: FieldSchema): boolean;
+    resolve(field: FieldSchema): React.ComponentType<FieldRendererProps> | null;
+}

package/dist/fields/renderer-resolver/RendererResolverChain.d.ts

@@ -0,0 +1,7 @@
+import { FieldSchema } from '../types';
+import { RendererHandler } from './RendererHandler';
+export declare class RendererResolverChain {
+    private handlers;
+    constructor(handlers: RendererHandler[]);
+    resolve(field: FieldSchema): import('react').ComponentType<FieldRendererProps> | null;
+}

package/dist/fields/renderer.types.d.ts

@@ -0,0 +1,12 @@
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from './types';
+export type FieldRendererResolverProps<TValues extends Record<string, any> = Record<string, any>> = CustomRenderersConfig<TValues> & {
+    field: FieldSchema<TValues>;
+    form: UseFormReturnType<TValues>;
+    layout?: "vertical" | "horizontal" | "grid";
+};
+export type CustomRenderersConfig<TValues extends Record<string, any> = Record<string, any>> = {
+    customFieldRenderers?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+    customTypeRenderers?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+    customFieldTypes?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+};

package/dist/fields/renderers/CheckBoxFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type CheckBoxFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function CheckBoxFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: CheckBoxFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default CheckBoxFieldRenderer;

package/dist/fields/renderers/DateFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type DateFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function DateFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: DateFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default DateFieldRenderer;

package/dist/fields/renderers/DateTimeFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type DateTimeFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function DateTimeFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: DateTimeFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default DateTimeFieldRenderer;

package/dist/fields/renderers/NumberFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type NumberFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function NumberFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: NumberFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default NumberFieldRenderer;

package/dist/fields/renderers/RichTextEditorFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type RichTextEditorFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function RichTextEditorFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: RichTextEditorFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default RichTextEditorFieldRenderer;

package/dist/fields/renderers/SelectFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type SelectFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function SelectFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: SelectFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default SelectFieldRenderer;

package/dist/fields/renderers/SwitchFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type SwitchFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function SwitchFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: SwitchFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default SwitchFieldRenderer;

package/dist/fields/renderers/TagsFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type TagsInputFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function TagsInputFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: TagsInputFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default TagsInputFieldRenderer;

package/dist/fields/renderers/TextFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type TextFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function TextFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: TextFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default TextFieldRenderer;

package/dist/fields/renderers/TimeFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type TimeFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function TimeFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: TimeFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default TimeFieldRenderer;