@overmap-ai/forms 1.0.32-react-flow-david.1 → 1.0.32-react-flow-david-fixes.1

package/dist/form/fields/NumberField/NumberField.d.ts

@@ -1,45 +1,27 @@
 import { ReactNode } from 'react';
-import { RiHashtag } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
+import { BaseField, FieldOptions } from '../BaseField';
 import { BooleanField } from '../BooleanField';
-import { GetInputProps, InputFieldLevelValidator, InputValidator, ISerializedField } from '../typings';
+import { ComponentProps, FieldValidator } from '../typings';
 import { SerializedNumberField } from './typings';
-export declare const emptyNumberField: {
-    type: string;
-    minimum: number;
-    maximum: number;
-    integers: boolean;
-    label: string;
-    description: string;
-    required: boolean;
+export type NumberRange = {
+    to: number | null;
+    from: number | null;
 };
-export interface NumberFieldOptions extends ChildFieldOptions<number> {
+export interface NumberFieldOptions extends FieldOptions<number> {
     maximum?: number;
     minimum?: number;
     integers?: boolean;
     placeholder?: string;
 }
-export declare class NumberField extends BaseField<"number", number, number, number> {
+export declare class NumberField extends BaseField<"number", number, number, NumberField> {
+    readonly type = "number";
     static readonly fieldTypeName = "Number";
     static readonly fieldTypeDescription = "Allows specifying a number within a given range.";
-    readonly minimum: number | undefined;
-    readonly maximum: number | undefined;
-    readonly integers: boolean;
-    readonly placeholder: string;
-    static Icon: typeof RiHashtag;
-    readonly defaultConditionValue: number | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-        lessThan: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-        lessThanOrEquals: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-        greaterThan: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-        greaterThanOrEquals: import('../../conditions/typings').FieldConditionModifierConfig<number, number, unknown, number, number, number>;
-    };
+    minimum: number | undefined;
+    maximum: number | undefined;
+    integers: boolean;
+    placeholder?: string;
     constructor(options: NumberFieldOptions);
-    static _validateMin: (path: string) => InputValidator<number>;
-    static _validateMax: (path: string) => InputValidator<number>;
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
         showDirectly: boolean;
@@ -47,9 +29,13 @@ export declare class NumberField extends BaseField<"number", number, number, num
         field: BooleanField;
         showDirectly: boolean;
     })[];
-    getFieldValidators(): InputFieldLevelValidator<number>[];
+    getFieldValidators(): FieldValidator<number>[];
     serialize(): SerializedNumberField;
-    static deserialize(data: ISerializedField): NumberField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<NumberField>): ReactNode;
+    getOptions(): NumberFieldOptions;
+    duplicate(identifier: string): NumberField;
+    setOptions(options: Partial<NumberFieldOptions>): void;
+    static deserialize(data: SerializedNumberField): NumberField;
+    serializeValue(value: number): number;
+    deserializeValue(value: number): number;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/NumberField/NumberInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { NumberField } from './NumberField';
-export declare const NumberInput: import('react').MemoExoticComponent<(props: ComponentProps<NumberField>) => import("react/jsx-runtime").JSX.Element>;
+interface NumberInputProps extends ComponentProps {
+    field: NumberField;
+}
+export declare const NumberInput: import('react').MemoExoticComponent<(props: NumberInputProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/form/fields/NumberField/typings.d.ts

@@ -1,6 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-export interface SerializedNumberField extends BaseSerializedField {
-    type: "number";
+export interface SerializedNumberField extends BaseSerializedField<"number"> {
     minimum: number | undefined;
     maximum: number | undefined;
     integers: boolean;

package/dist/form/fields/RadioField/RadioField.d.ts

@@ -1,41 +1,21 @@
 import { ReactNode } from 'react';
-import { RiRadioButtonFill } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-import { MultiStringField } from '../MultiStringField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
+import { ComponentProps } from '../typings';
 import { SerializedRadioField } from './typings';
-export declare const emptyRadioField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
-};
-export interface RadioFieldConfig extends ChildFieldOptions<string> {
-    options: SelectFieldOption[];
+export interface RadioFieldOptions extends BaseOptionsFieldOptions<string> {
 }
-export declare class RadioField extends BaseField<"radio", string, string | string[], string | string[]> {
-    readonly options: SelectFieldOption[];
+export declare class RadioField extends BaseOptionsField<"radio", string, string, RadioField> {
+    readonly type = "radio";
     readonly onlyValidateAfterTouched = false;
     static readonly fieldTypeName = "Option list";
     static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
-    static Icon: typeof RiRadioButtonFill;
-    readonly defaultConditionValue: string[] | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string, string>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string, string>;
-        includes: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string[], string[]>;
-        excludes: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string[], string[]>;
-    };
-    constructor(config: RadioFieldConfig);
+    constructor(options: RadioFieldOptions);
     serialize(): SerializedRadioField;
-    static deserialize(data: ISerializedField): RadioField;
-    static getFieldCreationSchema(parentPath?: string): {
-        field: MultiStringField;
-        showDirectly: boolean;
-    }[];
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<RadioField>): ReactNode;
+    getOptions(): RadioFieldOptions;
+    duplicate(identifier: string): RadioField;
+    setOptions(options: Partial<RadioFieldOptions>): void;
+    static deserialize(data: SerializedRadioField): RadioField;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/RadioField/RadioInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { RadioField } from './RadioField';
-export declare const RadioInput: import('react').MemoExoticComponent<(props: ComponentProps<RadioField>) => import("react/jsx-runtime").JSX.Element>;
+interface RadioInputProps extends ComponentProps {
+    field: RadioField;
+}
+export declare const RadioInput: import('react').NamedExoticComponent<RadioInputProps>;
+export {};

package/dist/form/fields/RadioField/typings.d.ts

@@ -1,6 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-export interface SerializedRadioField extends BaseSerializedField {
-    type: "radio";
+import { SelectFieldOption } from '../BaseOptionsField';
+export interface SerializedRadioField extends BaseSerializedField<"radio"> {
     options: SelectFieldOption[];
 }

package/dist/form/fields/ScanField/ScanField.d.ts

@@ -1,30 +1,21 @@
 import { ReactNode } from 'react';
-import { RiFullscreenLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { ComponentProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { ComponentProps } from '../typings';
 import { SerializedScanField } from './typings';
-export declare const emptyScanField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class ScanField extends BaseField<"qr", string, string, string> {
+export interface ScanFieldOptions extends FieldOptions<string> {
+}
+export declare class ScanField extends BaseField<"qr", string, string, ScanField> {
+    readonly type = "qr";
     static readonly fieldTypeName = "Scan";
     static readonly fieldTypeDescription = "Used for scanning/reading QR and barcodes.";
     readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiFullscreenLine;
-    readonly defaultConditionValue: string | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string, string, unknown, string, string, string>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string, string, unknown, string, string, string>;
-        includes: import('../../conditions/typings').FieldConditionModifierConfig<string, string, unknown, string, string, string>;
-        excludes: import('../../conditions/typings').FieldConditionModifierConfig<string, string, unknown, string, string, string>;
-    };
-    constructor(options: ChildFieldOptions<string>);
+    constructor(options: ScanFieldOptions);
     serialize(): SerializedScanField;
-    static deserialize(data: ISerializedField): ScanField;
-    getInput(props: ComponentProps<ScanField>): ReactNode;
-    renderCondition(props: ConditionRenderProps<ScanField>): ReactNode;
+    getOptions(): ScanFieldOptions;
+    duplicate(identifier: string): ScanField;
+    setOptions(options: Partial<ScanFieldOptions>): void;
+    static deserialize(data: SerializedScanField): ScanField;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/ScanField/ScanInput.d.ts

@@ -1,6 +1,9 @@
 import { ComponentProps } from '../typings';
 import { ScanField } from './ScanField';
-export declare const ScanInput: import('react').MemoExoticComponent<(props: ComponentProps<ScanField>) => import("react/jsx-runtime").JSX.Element>;
+interface ScanInputProps extends ComponentProps {
+    field: ScanField;
+}
+export declare const ScanInput: import('react').NamedExoticComponent<ScanInputProps>;
 interface ScannerProps {
     onScan: (data: string) => void;
 }

package/dist/form/fields/ScanField/typings.d.ts

@@ -1,4 +1,3 @@
 import { BaseSerializedField } from '../BaseField';
-export interface SerializedScanField extends BaseSerializedField {
-    type: "qr";
+export interface SerializedScanField extends BaseSerializedField<"qr"> {
 }

package/dist/form/fields/SelectField/SelectField.d.ts

@@ -1,35 +1,22 @@
 import { ReactNode } from 'react';
-import { RiMenuFoldLine } from 'react-icons/ri';
-import { ConditionRenderProps } from '../BaseField';
-import { BaseSelectField, BaseSelectFieldOptions } from '../BaseSelectField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
+import { ComponentProps } from '../typings';
 import { SerializedSelectField } from './typings';
-/**
- * The options passed to the constructor of SelectField.
- */
-export type SelectFieldOptions = Omit<BaseSelectFieldOptions<string, "select">, "type">;
-export declare const emptySelectField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
+export type SelectFieldOptions = BaseOptionsFieldOptions<string> & {
+    placeholder?: string;
 };
-export declare class SelectField extends BaseSelectField<"select", string, string | string[], string | string[]> {
+export declare class SelectField extends BaseOptionsField<"select", string, string, SelectField> {
+    readonly type = "select";
     static readonly fieldTypeName = "Dropdown";
     static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
-    static Icon: typeof RiMenuFoldLine;
-    readonly defaultConditionValue: string | string[] | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string, string>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string, string>;
-        includes: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string[], string[]>;
-        excludes: import('../../conditions/typings').FieldConditionModifierConfig<string, string | string[], unknown, string, string[], string[]>;
-    };
+    placeholder?: string;
     constructor(options: SelectFieldOptions);
     serialize(): SerializedSelectField;
-    static deserialize(data: ISerializedField): SelectField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<SelectField>): ReactNode;
+    getOptions(): SelectFieldOptions;
+    duplicate(identifier: string): SelectField;
+    setOptions(options: Partial<SelectFieldOptions>): void;
+    static deserialize(data: SerializedSelectField): SelectField;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/SelectField/SelectInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { SelectField } from './SelectField';
-export declare const SelectInput: import('react').MemoExoticComponent<(props: ComponentProps<SelectField>) => import("react/jsx-runtime").JSX.Element>;
+interface SelectInputProps extends ComponentProps {
+    field: SelectField;
+}
+export declare const SelectInput: import('react').NamedExoticComponent<SelectInputProps>;
+export {};

package/dist/form/fields/SelectField/typings.d.ts

@@ -1,7 +1,4 @@
-import { BaseSerializedField } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-export interface SerializedSelectField extends BaseSerializedField {
-    type: "select";
-    options: SelectFieldOption[];
+import { BaseSerializedSelectField } from '../BaseOptionsField';
+export interface SerializedSelectField extends BaseSerializedSelectField<"select"> {
     placeholder?: string;
 }

package/dist/form/fields/StringField/StringField.d.ts

@@ -1,28 +1,18 @@
 import { ReactNode } from 'react';
-import { RiInputField } from 'react-icons/ri';
-import { ConditionRenderProps } from '../BaseField';
-import { StringOrTextField, StringOrTextFieldOptions } from '../StringOrTextField';
-import { GetInputProps, ISerializedField } from '../typings';
-import { SerializedStringField, StringInputType } from './typings';
-export interface StringFieldOptions extends Omit<StringOrTextFieldOptions, "type"> {
-    inputType?: StringInputType;
+import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
+import { ComponentProps } from '../typings';
+import { SerializedStringField } from './typings';
+export interface StringFieldOptions extends BaseStringFieldOptions {
 }
-export declare const emptyStringField: {
-    type: string;
-    maximum_length: number;
-    input_type: string;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class StringField extends StringOrTextField<"string"> {
+export declare class StringField extends BaseStringField<"string", StringField> {
+    readonly type = "string";
     static readonly fieldTypeName = "Short Text";
     static readonly fieldTypeDescription = "Short text fields can hold up to 500 characters on a single line.";
-    readonly inputType: StringInputType;
-    static Icon: typeof RiInputField;
     constructor(options: StringFieldOptions);
     serialize(): SerializedStringField;
-    static deserialize(data: ISerializedField): StringField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<StringField>): ReactNode;
+    getOptions(): StringFieldOptions;
+    duplicate(identifier: string): StringField;
+    setOptions(options: Partial<StringFieldOptions>): void;
+    static deserialize(data: SerializedStringField): StringField;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/StringField/StringInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { StringField } from './StringField';
-export declare const StringInput: import('react').MemoExoticComponent<(props: ComponentProps<StringField>) => import("react/jsx-runtime").JSX.Element>;
+interface StringInputProps extends ComponentProps {
+    field: StringField;
+}
+export declare const StringInput: import('react').NamedExoticComponent<StringInputProps>;
+export {};

package/dist/form/fields/StringField/typings.d.ts

@@ -1,7 +1,3 @@
-import { HTMLInputTypeAttribute } from 'react';
-import { BaseSerializedStringField } from '../StringOrTextField';
-export type StringInputType = Exclude<HTMLInputTypeAttribute, "checkbox" | "number" | "button">;
-export interface SerializedStringField extends BaseSerializedStringField {
-    type: "string";
-    input_type?: StringInputType;
+import { BaseSerializedStringField } from '../BaseStringField';
+export interface SerializedStringField extends BaseSerializedStringField<"string"> {
 }

package/dist/form/fields/TextField/TextField.d.ts

@@ -1,24 +1,17 @@
 import { ReactNode } from 'react';
-import { RiAlignJustify } from 'react-icons/ri';
-import { ConditionRenderProps } from '../BaseField';
-import { StringOrTextField, StringOrTextFieldOptions } from '../StringOrTextField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
+import { ComponentProps } from '../typings';
 import { SerializedTextField } from './typings';
-export type TextFieldOptions = Omit<StringOrTextFieldOptions, "type">;
-export declare const emptyTextField: {
-    type: string;
-    maximum_length: number;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class TextField extends StringOrTextField<"text"> {
+export type TextFieldOptions = BaseStringFieldOptions;
+export declare class TextField extends BaseStringField<"text", TextField> {
+    readonly type = "text";
     static readonly fieldTypeName = "Paragraph";
     static readonly fieldTypeDescription = "Paragraph fields can hold up to 10000 characters and can have multiple lines.";
-    static Icon: typeof RiAlignJustify;
     constructor(options: TextFieldOptions);
     serialize(): SerializedTextField;
-    static deserialize(data: ISerializedField): TextField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<TextField>): ReactNode;
+    getOptions(): TextFieldOptions;
+    duplicate(identifier: string): TextField;
+    setOptions(options: Partial<TextFieldOptions>): void;
+    static deserialize(data: SerializedTextField): TextField;
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/TextField/TextInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { TextField } from './TextField';
-export declare const TextInput: import('react').MemoExoticComponent<(props: ComponentProps<TextField>) => import("react/jsx-runtime").JSX.Element>;
+interface TextInputProps extends ComponentProps {
+    field: TextField;
+}
+export declare const TextInput: import('react').NamedExoticComponent<TextInputProps>;
+export {};

package/dist/form/fields/TextField/typings.d.ts

@@ -1,4 +1,3 @@
-import { BaseSerializedStringField } from '../StringOrTextField';
-export interface SerializedTextField extends BaseSerializedStringField {
-    type: "text";
+import { BaseSerializedStringField } from '../BaseStringField';
+export interface SerializedTextField extends BaseSerializedStringField<"text"> {
 }

package/dist/form/fields/UploadField/UploadField.d.ts

@@ -1,40 +1,24 @@
 import { ReactNode } from 'react';
-import { RiUpload2Line } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
+import { BaseField, FieldOptions } from '../BaseField';
 import { MultiSelectField } from '../MultiSelectField';
 import { NumberField } from '../NumberField';
-import { GetInputProps, InputFieldLevelValidator, ISerializedField } from '../typings';
+import { ComponentProps, FieldValidator } from '../typings';
 import { SerializedUploadField } from './typings';
-export interface UploadFieldOptions extends ChildFieldOptions<File[]> {
+export interface UploadFieldOptions extends FieldOptions<File[]> {
     extensions?: string[];
     maximum_size?: number | string;
     maximum_files?: number | string;
 }
-export declare const emptyUploadField: {
-    type: string;
-    extensions: never[];
-    maximum_size: undefined;
-    maximum_files: number;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class UploadField extends BaseField<"upload", File[], boolean, boolean> {
+export declare class UploadField extends BaseField<"upload", File[], never[], UploadField> {
+    readonly type = "upload";
     static readonly fieldTypeName = "Upload";
     static readonly fieldTypeDescription = "Allows a file to be uploaded.";
-    readonly extensions?: string[];
-    readonly maxFileSize: number | undefined;
-    readonly maxFiles: number;
+    extensions?: string[];
+    maxFileSize: number | undefined;
+    maxFiles: number;
     readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiUpload2Line;
-    readonly defaultConditionValue: boolean | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<File[], boolean, unknown, File[], boolean, boolean>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<File[], boolean, unknown, File[], boolean, boolean>;
-    };
     constructor(options: UploadFieldOptions);
-    protected isBlank(value: File[] | undefined): boolean;
+    isBlank(value: File[] | undefined): boolean;
     isEqual(value1: File[] | undefined, value2: File[] | undefined): boolean;
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
@@ -43,9 +27,13 @@ export declare class UploadField extends BaseField<"upload", File[], boolean, bo
         field: MultiSelectField;
         showDirectly: boolean;
     })[];
-    getFieldValidators(): InputFieldLevelValidator<File[]>[];
+    getFieldValidators(): FieldValidator<File[]>[];
     serialize(): SerializedUploadField;
-    static deserialize(data: ISerializedField): UploadField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<UploadField>): ReactNode;
+    getOptions(): UploadFieldOptions;
+    duplicate(identifier: string): UploadField;
+    setOptions(options: Partial<UploadFieldOptions>): void;
+    static deserialize(data: SerializedUploadField): UploadField;
+    serializeValue(_value: File[]): never[];
+    deserializeValue(_value: never[]): File[];
+    render(props: ComponentProps): ReactNode;
 }

package/dist/form/fields/UploadField/UploadInput.d.ts

@@ -1,3 +1,7 @@
 import { ComponentProps } from '../typings';
 import { UploadField } from './UploadField';
-export declare const UploadInput: import('react').MemoExoticComponent<(props: ComponentProps<UploadField>) => import("react/jsx-runtime").JSX.Element>;
+interface UploadInputProps extends ComponentProps {
+    field: UploadField;
+}
+export declare const UploadInput: import('react').MemoExoticComponent<(props: UploadInputProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/form/fields/UploadField/typings.d.ts

@@ -1,6 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-export interface SerializedUploadField extends BaseSerializedField {
-    type: "upload";
+export interface SerializedUploadField extends BaseSerializedField<"upload"> {
     /** @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept */
     extensions?: string[];
     /** in bytes */

package/dist/form/fields/constants.d.ts

@@ -1,3 +1,4 @@
+import { IconType } from '@overmap-ai/blocks';
 import { BooleanField } from './BooleanField';
 import { CheckboxListField } from './CheckboxListField';
 import { DateField } from './DateField';
@@ -9,7 +10,7 @@ import { ScanField } from './ScanField';
 import { SelectField } from './SelectField';
 import { StringField } from './StringField';
 import { TextField } from './TextField';
-import { FieldTypeIdentifier } from './typings';
+import { FieldType } from './typings';
 import { UploadField } from './UploadField';
 export declare const FieldTypeToClsMapping: {
     readonly date: typeof DateField;
@@ -25,96 +26,7 @@ export declare const FieldTypeToClsMapping: {
     readonly radio: typeof RadioField;
     readonly "checkbox-list": typeof CheckboxListField;
 };
-export declare const FieldTypeToEmptyFieldMapping: {
-    readonly date: {
-        type: string;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly number: {
-        type: string;
-        minimum: number;
-        maximum: number;
-        integers: boolean;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly boolean: {
-        type: string;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly select: {
-        type: string;
-        options: never[];
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly string: {
-        type: string;
-        maximum_length: number;
-        input_type: string;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly text: {
-        type: string;
-        maximum_length: number;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly upload: {
-        type: string;
-        extensions: never[];
-        maximum_size: undefined;
-        maximum_files: number;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly qr: {
-        type: string;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly "multi-string": {
-        type: string;
-        minimum_length: number;
-        maximum_length: null;
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly "multi-select": {
-        type: string;
-        options: never[];
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly radio: {
-        type: string;
-        options: never[];
-        label: string;
-        description: string;
-        required: boolean;
-    };
-    readonly "checkbox-list": {
-        type: string;
-        options: never[];
-        label: string;
-        description: string;
-        required: boolean;
-    };
-};
-export declare const fieldIcons: Record<FieldTypeIdentifier, string>;
+export declare const fieldIcons: Record<FieldType, IconType>;
 export declare const maxFileSizeMB = 50;
 export declare const maxFileSizeKB: number;
 export declare const maxFileSizeB: number;

package/dist/form/fields/hooks.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { BaseFormElement } from './BaseField';
-import { AnyField, GetInputProps } from './typings';
-export declare const useFieldInput: <TField extends BaseFormElement | null>(field: TField, props: TField extends BaseFormElement ? GetInputProps<TField> : null) => ReactNode;
-export declare const useFieldInputs: (fields: BaseFormElement[], props: GetInputProps<AnyField>) => ReactNode;
+import { AnyFormElement } from './BaseFormElement';
+import { ComponentProps } from './typings';
+export declare const useFieldInput: <TField extends AnyFormElement>(field: TField, props: ComponentProps) => ReactNode;
+export declare const useFieldInputs: (fields: AnyFormElement[], props: ComponentProps) => ReactNode;