@overmap-ai/forms 1.0.31 → 1.0.32-condition-manager.0

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

@@ -1,3 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { TextField } from './TextField';
-export declare const TextInput: import('react').MemoExoticComponent<(props: ComponentProps<TextField>) => import("react/jsx-runtime").JSX.Element>;
+interface TextInputProps extends FieldRenderProps {
+    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,35 +1,25 @@
 import { ReactNode } from 'react';
-import { RiUpload2Line } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
+import { UUIDFile } from '../../UUIDFile';
+import { UUIDPromise } from '../../UUIDPromise';
+import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
 import { MultiSelectField } from '../MultiSelectField';
 import { NumberField } from '../NumberField';
-import { GetInputProps, InputFieldLevelValidator, ISerializedField } from '../typings';
 import { SerializedUploadField } from './typings';
-export interface UploadFieldOptions extends ChildFieldOptions<File[]> {
+export interface UploadFieldOptions extends FieldOptions<(UUIDPromise<UUIDFile> | UUIDFile)[]> {
     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<File[], "upload"> {
+export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFile> | UUIDFile)[], 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;
     constructor(options: UploadFieldOptions);
-    protected isBlank(value: File[] | undefined): boolean;
-    isEqual(value1: File[] | undefined, value2: File[] | undefined): boolean;
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
         showDirectly: boolean;
@@ -37,8 +27,17 @@ export declare class UploadField extends BaseField<File[], "upload"> {
         field: MultiSelectField;
         showDirectly: boolean;
     })[];
-    getFieldValidators(): InputFieldLevelValidator<File[]>[];
+    getFieldValidators(): FieldValidator<(UUIDPromise<UUIDFile> | UUIDFile)[]>[];
     serialize(): SerializedUploadField;
-    static deserialize(data: ISerializedField): UploadField;
-    getInput(props: GetInputProps<this>): ReactNode;
+    getOptions(): UploadFieldOptions;
+    duplicate(identifier: string): UploadField;
+    setOptions(options: Partial<UploadFieldOptions>): void;
+    static deserialize(data: SerializedUploadField): UploadField;
+    serializeValue(_value: (UUIDPromise<UUIDFile> | UUIDFile)[]): never[];
+    deserializeValue(_value: never[]): (UUIDPromise<UUIDFile> | UUIDFile)[];
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is never[];
+    isValueValid(value: unknown): value is (UUIDPromise<UUIDFile> | UUIDFile)[];
+    areValuesEqual(value1: (UUIDPromise<UUIDFile> | UUIDFile)[], value2: (UUIDPromise<UUIDFile> | UUIDFile)[]): boolean;
+    blankValue(): (UUIDPromise<UUIDFile> | UUIDFile)[];
 }

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

@@ -1,3 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { UploadField } from './UploadField';
-export declare const UploadInput: import('react').MemoExoticComponent<(props: ComponentProps<UploadField>) => import("react/jsx-runtime").JSX.Element>;
+interface UploadInputProps extends FieldRenderProps {
+    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/_utils.d.ts

@@ -0,0 +1 @@
+export declare function isStringArray(value: unknown): value is string[];

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

@@ -1,128 +1,36 @@
+import { IconType } from '@overmap-ai/blocks';
 import { BooleanField } from './BooleanField';
 import { CheckboxListField } from './CheckboxListField';
-import { CustomField } from './CustomField';
 import { DateField } from './DateField';
 import { MultiSelectField } from './MultiSelectField';
 import { MultiStringField } from './MultiStringField';
 import { NumberField } from './NumberField';
+import { OTPField } from './OneTimePasswordField';
+import { PassFailField } from './PassFailField';
 import { RadioField } from './RadioField';
 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;
-    readonly number: typeof NumberField;
-    readonly boolean: typeof BooleanField;
-    readonly select: typeof SelectField;
-    readonly string: typeof StringField;
-    readonly text: typeof TextField;
-    readonly custom: typeof CustomField;
-    readonly upload: typeof UploadField;
-    readonly qr: typeof ScanField;
-    readonly "multi-string": typeof MultiStringField;
-    readonly "multi-select": typeof MultiSelectField;
-    readonly radio: typeof RadioField;
-    readonly "checkbox-list": typeof CheckboxListField;
+    date: typeof DateField;
+    number: typeof NumberField;
+    boolean: typeof BooleanField;
+    select: typeof SelectField;
+    string: typeof StringField;
+    text: typeof TextField;
+    upload: typeof UploadField;
+    qr: typeof ScanField;
+    "multi-string": typeof MultiStringField;
+    "multi-select": typeof MultiSelectField;
+    radio: typeof RadioField;
+    "checkbox-list": typeof CheckboxListField;
+    "pass-fail": typeof PassFailField;
+    otp: typeof OTPField;
 };
-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 custom: {
-        type: string;
-        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,31 @@
 import { ReactNode } from 'react';
-import { BaseField, BaseFormElement } from './BaseField';
-import { FieldValue, 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<BaseField<FieldValue>>) => ReactNode;
+import { FieldRenderProps } from './BaseFormElement';
+import { AnyField, AnyFormElement, ValueOfField } from './typings';
+export declare const useFieldInput: <TField extends AnyFormElement>(field: TField, props: FieldRenderProps) => ReactNode;
+export declare const useFieldInputs: (fields: AnyFormElement[], props: FieldRenderProps) => ReactNode;
+export declare const useFormikInput: <TField extends AnyField>(props: FieldRenderProps & {
+    field: TField;
+}) => readonly [{
+    readonly helpText: string | null;
+    readonly size: import('@overmap-ai/blocks').TextSize | undefined;
+    readonly severity: "danger" | undefined;
+    readonly inputId: string;
+    readonly labelId: string;
+    readonly label: string;
+    readonly showInputOnly: boolean | undefined;
+    readonly fieldProps: {
+        onChange: (value: ValueOfField<TField>) => void;
+        onBlur: (value: ValueOfField<TField>) => void;
+        value: ValueOfField<TField>;
+        name: string;
+        multiple?: boolean;
+        checked?: boolean;
+    };
+    readonly helpers: import('formik').FieldHelperProps<ValueOfField<TField>>;
+    readonly field: TField;
+    readonly touched: boolean;
+}, {
+    readonly "aria-labelledby": string;
+    readonly formId: string;
+    readonly disabled?: boolean;
+}];

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

@@ -1,5 +1,8 @@
+export * from './_utils';
 export * from './BaseField';
-export * from './BaseSelectField';
+export * from './BaseFormElement';
+export * from './BaseOptionsField';
+export * from './BaseStringField';
 export * from './BooleanField';
 export * from './CheckboxListField';
 export * from './components';
@@ -10,12 +13,13 @@ export * from './hooks';
 export * from './MultiSelectField';
 export * from './MultiStringField';
 export * from './NumberField';
+export * from './OneTimePasswordField';
+export * from './PassFailField';
 export * from './RadioField';
 export * from './ScanField';
 export * from './SelectField';
 export * from './StringField';
-export * from './StringOrTextField';
 export * from './TextField';
-export * from './typings';
+export type * from './typings';
 export * from './UploadField';
 export * from './utils';

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

@@ -1,35 +1,48 @@
-import { TextSize } from '@overmap-ai/blocks';
-import { HTMLProps } from 'react';
-import { FormBuilderValues } from '../builder';
-import { FormValues } from '../typings';
-import { BaseField, BaseFormElement } from './BaseField';
-import { SerializedBooleanField } from './BooleanField';
-import { SerializedCheckboxListField } from './CheckboxListField';
-import { SerializedDateField } from './DateField';
-import { SerializedFieldSection } from './FieldSection';
-import { SerializedMultiSelectField } from './MultiSelectField';
-import { SerializedMultiStringField } from './MultiStringField';
-import { SerializedNumberField } from './NumberField';
-import { SerializedRadioField } from './RadioField';
-import { SerializedScanField } from './ScanField';
-import { SerializedSelectField } from './SelectField';
-import { SerializedStringField } from './StringField';
-import { SerializedTextField } from './TextField';
-import { SerializedUploadField } from './UploadField';
-export type FieldTypeIdentifier = "string" | "text" | "boolean" | "number" | "date" | "select" | "custom" | "section" | "multi-string" | "multi-select" | "upload" | "qr" | "radio" | "checkbox-list";
-export type FieldValue = string | number | boolean | string[] | File[] | Date | null;
-export type ValueOfField<Type extends AnyField> = Type extends BaseField<infer TValue> ? TValue : never;
-export type InputFieldLevelValidator<TValue> = (value: TValue | undefined) => string | null | undefined;
-export type InputFormLevelValidator<TValue> = (value: TValue | undefined, allValues: FormValues | FormBuilderValues) => string | null | undefined;
-export type InputValidator<TValue> = InputFieldLevelValidator<TValue> | InputFormLevelValidator<TValue>;
-export interface ComponentProps<TField extends BaseFormElement> extends Omit<HTMLProps<HTMLElement>, "color" | "size" | "ref" | "type" | "onChange" | "onBlur" | "value" | "defaultValue" | "name" | "dir"> {
-    field: TField;
-    formId: string;
-    size?: TextSize;
-    onValuesChange?: (identifier: string, value: ValueOfField<AnyField>) => void;
-    showInputOnly?: boolean;
+import { BaseField } from './BaseField';
+import { BaseFormElement } from './BaseFormElement';
+import { BooleanField, SerializedBooleanField } from './BooleanField';
+import { CheckboxListField, SerializedCheckboxListField } from './CheckboxListField';
+import { DateField, SerializedDateField } from './DateField';
+import { FieldSection, SerializedFieldSection } from './FieldSection';
+import { MultiSelectField, SerializedMultiSelectField } from './MultiSelectField';
+import { MultiStringField, SerializedMultiStringField } from './MultiStringField';
+import { NumberField, SerializedNumberField } from './NumberField';
+import { OTPField, SerializedOTPField } from './OneTimePasswordField';
+import { PassFailField, SerializedPassFailField } from './PassFailField';
+import { RadioField, SerializedRadioField } from './RadioField';
+import { ScanField, SerializedScanField } from './ScanField';
+import { SelectField, SerializedSelectField } from './SelectField';
+import { SerializedStringField, StringField } from './StringField';
+import { SerializedTextField, TextField } from './TextField';
+import { SerializedUploadField, UploadField } from './UploadField';
+export type AnyFormElement = BaseFormElement<any, any>;
+export type AnyField = BaseField<any, any, any, any>;
+export type TypeOfField<TField extends AnyFormElement> = TField extends BaseFormElement<infer TIdentifier, infer _TThis> ? TIdentifier : never;
+export type ValueOfField<TField extends AnyField> = TField extends BaseField<infer _TIdentifier, infer TValue, infer _TSerializedValue, infer _TThis> ? TValue : never;
+export type SerializedValueOfField<TField extends AnyField> = TField extends BaseField<infer _TIdentifier, infer _TValue, infer TSerializedValue, infer _TThis> ? TSerializedValue : never;
+export type FieldType = TypeOfField<BooleanField> | TypeOfField<CheckboxListField> | TypeOfField<PassFailField> | TypeOfField<DateField> | TypeOfField<MultiSelectField> | TypeOfField<MultiStringField> | TypeOfField<NumberField> | TypeOfField<RadioField> | TypeOfField<ScanField> | TypeOfField<SelectField> | TypeOfField<StringField> | TypeOfField<TextField> | TypeOfField<UploadField> | TypeOfField<FieldSection> | TypeOfField<OTPField>;
+export type FieldValue = ValueOfField<BooleanField> | ValueOfField<CheckboxListField> | ValueOfField<PassFailField> | ValueOfField<DateField> | ValueOfField<MultiSelectField> | ValueOfField<MultiStringField> | ValueOfField<NumberField> | ValueOfField<RadioField> | ValueOfField<ScanField> | ValueOfField<SelectField> | ValueOfField<StringField> | ValueOfField<TextField> | ValueOfField<UploadField> | ValueOfField<OTPField>;
+export type SerializedFieldValue = SerializedValueOfField<BooleanField> | SerializedValueOfField<CheckboxListField> | SerializedValueOfField<PassFailField> | SerializedValueOfField<DateField> | SerializedValueOfField<MultiSelectField> | SerializedValueOfField<MultiStringField> | SerializedValueOfField<NumberField> | SerializedValueOfField<RadioField> | SerializedValueOfField<ScanField> | SerializedValueOfField<SelectField> | SerializedValueOfField<StringField> | SerializedValueOfField<TextField> | SerializedValueOfField<UploadField> | SerializedValueOfField<OTPField>;
+export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | ScanField | SelectField | StringField | TextField | UploadField | OTPField;
+export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof OTPField;
+export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField;
+export type SerializedOnlyField = Exclude<SerializedField, SerializedFieldSection>;
+export interface FieldsManager {
+    readonly fields: Field[];
+    getFields(): Field[];
+    addField(field: Field): void;
+    addFields(fields: Field[]): void;
+    moveField(sourceIndex: number, targetIndex: number): void;
+    removeField(field: Field): void;
+    removeFields(fields: Field[]): void;
+}
+export interface FieldSectionManager {
+    readonly fieldSections: FieldSection[];
+    getFields(): Field[];
+    getFieldSections(): FieldSection[];
+    addFieldSection(field: FieldSection): void;
+    addFieldSections(fields: FieldSection[]): void;
+    moveFieldSection(sourceIndex: number, targetIndex: number): void;
+    removeFieldSection(field: FieldSection): void;
+    removeFieldSections(fields: FieldSection[]): void;
 }
-export type GetInputProps<TField extends BaseFormElement> = Omit<ComponentProps<TField>, "field">;
-export type AnyField = BaseField<any, any>;
-export type ISerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedCheckboxListField;
-export type ISerializedOnlyField = Exclude<ISerializedField, SerializedFieldSection>;

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

@@ -1,16 +1,15 @@
-import { BaseFormElement } from './BaseField';
-import { FieldSection, SerializedCondition } from './FieldSection';
-import { AnyField, FieldValue, ISerializedField, ISerializedOnlyField } from './typings';
-/** Deserializes anything but a FieldSection.
- * @see `deserialize` for most use cases
- */
-export declare const deserializeField: (serializedField: ISerializedOnlyField) => AnyField;
-/** Deserializes anything */
-export declare const deserialize: (serialized: ISerializedField) => AnyField | FieldSection;
-export declare function deserializeFields(fields: ISerializedField[]): (AnyField | FieldSection)[];
-export declare function flattenFields(fields: BaseFormElement[]): AnyField[];
-export declare function getFieldsMapping(fields: BaseFormElement[]): Record<string, AnyField>;
-export declare function decodeFieldValues(fields: BaseFormElement[], values: Record<string, string>): Record<string, FieldValue>;
-export declare function encodeFieldValues(fields: BaseFormElement[], values: Record<string, FieldValue>): Record<string, string>;
-export declare function valueIsFile(v: FieldValue | Promise<File>[] | undefined): v is File[] | Promise<File>[];
-export declare function isConditionMet<TValue extends FieldValue | Promise<File>[]>(condition: TValue extends FieldValue ? SerializedCondition<TValue> | null : null, value: TValue | undefined): boolean;
+import { FieldFilesAndPromises, FieldValues, SerializedFieldValues } from '../typings';
+import { FieldSection } from './FieldSection';
+import { Field, SerializedField, SerializedOnlyField } from './typings';
+export declare const deserializeField: (serializedField: SerializedOnlyField) => Field;
+export declare function deserializeFields(fields: SerializedField[]): (Field | FieldSection)[];
+export declare const deserialize: (serialized: SerializedField) => Field | FieldSection;
+export declare function deserializeOnlyFields(fields: SerializedOnlyField[]): Field[];
+export declare function flattenFields(fields: (Field | FieldSection)[]): Field[];
+export declare function getFieldsMapping(fields: (Field | FieldSection)[]): Record<string, Field>;
+export declare function serializeFieldValues(fields: Field[], values: FieldValues): SerializedFieldValues;
+export declare function deserializeFieldValues(fields: Field[], values: SerializedFieldValues): FieldValues;
+export declare function cleanFieldValues(fields: Field[], values: FieldValues): FieldValues;
+export declare function cleanSerializedFieldValues(fields: Field[], values: SerializedFieldValues): SerializedFieldValues;
+export declare function extractFilesAndPromisesFromFieldValues(fields: Field[], values: FieldValues): readonly [FieldValues, FieldFilesAndPromises];
+export declare function insertFilesAndPromisesToFieldValues(fields: Field[], values: FieldValues, filesAndPromises: FieldFilesAndPromises): FieldValues;

package/dist/form/index.d.ts

@@ -1,6 +1,12 @@
 export * from './builder';
+export * from './conditions';
 export * from './constants';
 export * from './fields';
+export * from './modifiers';
+export * from './Observable';
 export * from './renderer';
+export * from './schema';
 export type * from './typings';
-export { initializeFormValues, validateFields } from './utils';
+export * from './utils';
+export * from './UUIDFile';
+export * from './UUIDPromise';

package/dist/form/modifiers/boolean.d.ts

@@ -0,0 +1,3 @@
+import { ConditionModifier } from './conditionModifier';
+export declare const BooleanEqualsConditionModifier: ConditionModifier<boolean, boolean, boolean>;
+export declare const BooleanNotEqualsConditionModifier: ConditionModifier<boolean, boolean, boolean>;

package/dist/form/modifiers/conditionModifier.d.ts

@@ -0,0 +1,17 @@
+import { ConditionModifierFn } from './typings';
+export interface ConditionModifierConfig<TModifierValue, TModifierConditionValue, TSerializedModifierConditionValue = TModifierConditionValue> {
+    id: string;
+    label: string;
+    modifierFn: ConditionModifierFn<TModifierValue, TModifierConditionValue>;
+    serialize: (conditionValue: TModifierConditionValue) => TSerializedModifierConditionValue;
+    deserialize: (serializedConditionValue: TSerializedModifierConditionValue) => TModifierConditionValue | undefined;
+}
+export declare class ConditionModifier<TModifierValue, TConditionValue, TSerializedConditionValue = TConditionValue> {
+    readonly id: string;
+    readonly label: string;
+    readonly modifierFn: ConditionModifierFn<TModifierValue, TConditionValue>;
+    readonly serialize: (conditionValue: TConditionValue) => TSerializedConditionValue;
+    readonly deserialize: (serializedConditionValue: TSerializedConditionValue) => TConditionValue | undefined;
+    private constructor();
+    static create<TValue, TConditionValue, TSerializedConditionValue = TConditionValue>(config: ConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue>): ConditionModifier<TValue, TConditionValue, TSerializedConditionValue>;
+}

package/dist/form/modifiers/date.d.ts

@@ -0,0 +1,9 @@
+import { DateRange } from 'react-day-picker';
+import { SerializedDateRange } from '../fields';
+import { ConditionModifier } from './conditionModifier';
+export declare const DateEqualsConditionModifier: ConditionModifier<Date, Date, string>;
+export declare const DateNotEqualsConditionModifier: ConditionModifier<Date, Date, string>;
+export declare const DateBeforeConditionModifier: ConditionModifier<Date, Date, string>;
+export declare const DateAfterConditionModifier: ConditionModifier<Date, Date, string>;
+export declare const DateRangeInConditionModifier: ConditionModifier<Date, DateRange, SerializedDateRange>;
+export declare const DateRangeNotInConditionModifier: ConditionModifier<Date, DateRange, SerializedDateRange>;

package/dist/form/modifiers/file.d.ts

@@ -0,0 +1,4 @@
+import { UUIDFile } from '../UUIDFile';
+import { ConditionModifier } from './conditionModifier';
+export declare const HasFilesConditionModifier: ConditionModifier<UUIDFile[], boolean, boolean>;
+export declare const DoesNotHaveFilesConditionModifier: ConditionModifier<UUIDFile[], boolean, boolean>;

package/dist/form/modifiers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './boolean';
+export * from './date';
+export * from './file';
+export * from './number';
+export * from './passFailStatus';
+export * from './string';
+export type * from './typings';
+export * from './utils';

package/dist/form/modifiers/number.d.ts

@@ -0,0 +1,10 @@
+import { NumberRange } from '../fields';
+import { ConditionModifier } from './conditionModifier';
+export declare const NumberEqualsConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberNotEqualsConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberLessThanConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberLessThanOrEqualsConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberGreaterThanConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberGreaterThanOrEqualsConditionModifier: ConditionModifier<number, number, number>;
+export declare const NumberRangeInConditionModifier: ConditionModifier<number, NumberRange, NumberRange>;
+export declare const NumberRangeNotInConditionModifier: ConditionModifier<number, NumberRange, NumberRange>;

package/dist/form/modifiers/passFailStatus.d.ts

@@ -0,0 +1,6 @@
+import { PassFailFieldStatus } from '../fields';
+import { ConditionModifier } from './conditionModifier';
+export declare const PassFailEqualsConditionModifier: ConditionModifier<PassFailFieldStatus, PassFailFieldStatus, PassFailFieldStatus>;
+export declare const PassFailNotEqualsConditionModifier: ConditionModifier<PassFailFieldStatus, PassFailFieldStatus, PassFailFieldStatus>;
+export declare const PassFailArrayIncludesConditionModifier: ConditionModifier<PassFailFieldStatus, PassFailFieldStatus[], PassFailFieldStatus[]>;
+export declare const PassFailArrayExcludesConditionModifier: ConditionModifier<PassFailFieldStatus, PassFailFieldStatus[], PassFailFieldStatus[]>;

package/dist/form/modifiers/string.d.ts

@@ -0,0 +1,12 @@
+import { ConditionModifier } from './conditionModifier';
+export declare const StringEqualsConditionModifier: ConditionModifier<string, string, string>;
+export declare const StringNotEqualsConditionModifier: ConditionModifier<string, string, string>;
+export declare const StringIncludesConditionModifier: ConditionModifier<string, string, string>;
+export declare const StringExcludesConditionModifier: ConditionModifier<string, string, string>;
+export declare const StringArrayIncludesConditionModifier: ConditionModifier<string, string[], string[]>;
+export declare const StringArrayExcludesConditionModifier: ConditionModifier<string, string[], string[]>;
+export declare const StringArrayEveryConditionModifier: ConditionModifier<string[], string[], string[]>;
+export declare const StringArraySomeConditionModifier: ConditionModifier<string[], string[], string[]>;
+export declare const StringArrayNoneConditionModifier: ConditionModifier<string[], string[], string[]>;
+export declare const StringArrayEqualsConditionModifier: ConditionModifier<string[], string[], string[]>;
+export declare const StringArrayNotEqualsConditionModifier: ConditionModifier<string[], string[], string[]>;

package/dist/form/modifiers/typings.d.ts

@@ -0,0 +1,11 @@
+import { ConditionModifier } from './conditionModifier';
+export type ConditionModifierFn<TValue, TConditionValue> = (value: TValue, conditionValue: TConditionValue) => boolean;
+export interface FieldConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue, TModifierValue extends TValue, TModifierConditionValue extends TConditionValue, TSerializedModifierConditionValue extends TSerializedConditionValue> {
+    modifier: ConditionModifier<TModifierValue, TModifierConditionValue, TSerializedModifierConditionValue>;
+    isValueValid: (value: TValue) => value is TModifierValue;
+    isConditionValueValid: (conditionValue: TConditionValue) => conditionValue is TModifierConditionValue;
+    isSerializedValueValid: (serializedConditionValue: TSerializedConditionValue) => serializedConditionValue is TSerializedModifierConditionValue;
+}
+export type AnyConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue> = FieldConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue, any, // eslint-disable-line @typescript-eslint/no-explicit-any
+any, // eslint-disable-line @typescript-eslint/no-explicit-any
+any>;

package/dist/form/modifiers/utils.d.ts

@@ -0,0 +1,2 @@
+import { FieldConditionModifierConfig } from './typings';
+export declare const createConditionModifierConfig: <TValue, TConditionValue, TSerializedConditionValue, TModifierValue extends TValue, TModifierConditionalValue extends TConditionValue, TSerializedModifierConditionValue extends TSerializedConditionValue>(conifg: FieldConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue, TModifierValue, TModifierConditionalValue, TSerializedModifierConditionValue>) => FieldConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue, TModifierValue, TModifierConditionalValue, TSerializedModifierConditionValue>;

package/dist/form/renderer/{FormRenderer/FormRenderer.d.ts → FormRenderer.d.ts}

@@ -1,15 +1,15 @@
 import { ButtonProps } from '@overmap-ai/blocks';
-import { FormValues, ISchema } from '../../typings';
+import { FieldValues, ISchema } from '../typings';
 interface FormRendererProps {
     /** The schema of the form the render */
     schema: ISchema;
     /** Initial values of the form */
-    values?: FormValues;
+    values?: FieldValues;
     /** The function to call when the form values change */
-    onValuesChange?: (allValues: FormValues, changedValues: FormValues) => void;
+    onValuesChange?: (allValues: FieldValues, changedValues: FieldValues) => void;
     enableReinitialize?: boolean;
     excludeUnchangedFields?: boolean;
-    onSubmit?: (values: FormValues) => Promise<void> | void;
+    onSubmit?: (values: FieldValues) => Promise<void> | void;
     /** @default "Submit" */
     submitText?: string;
     /** The text of the cancel button (hidden by default)

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

@@ -0,0 +1,2 @@
+export declare const requiredFields: (import('..').Field | import('..').FieldSection)[];
+export declare const notRequiredFields: (import('..').Field | import('..').FieldSection)[];

package/dist/form/renderer/context.d.ts

@@ -0,0 +1,2 @@
+import { ISchema } from '../typings';
+export declare const RendererContext: import('react').Context<ISchema>;

package/dist/form/renderer/index.d.ts

@@ -1,2 +1 @@
-export * from './FormRenderer/FormRenderer';
-export * from './PatchForm';
+export * from './FormRenderer';

package/dist/form/schema/FieldSchema.d.ts

@@ -0,0 +1,22 @@
+import { SerializedCondition } from '../conditions';
+import { Field, FieldSection, FieldSectionManager, SerializedFieldSection } from '../fields';
+import { Observable } from '../Observable';
+import { FieldValues, SerializedFieldValues } from '../typings';
+export declare class FieldSchema extends Observable<FieldSchema> implements FieldSectionManager {
+    fieldSections: FieldSection[];
+    constructor(fields: FieldSection[]);
+    serialize(): SerializedFieldSection[];
+    static deserialize(serializedSections: SerializedFieldSection[]): FieldSchema;
+    private fieldObserver;
+    private initFields;
+    getFields(): Field[];
+    getFieldSections(): FieldSection[];
+    addFieldSection(field: FieldSection): void;
+    addFieldSections(fields: FieldSection[]): void;
+    removeFieldSection(field: FieldSection): void;
+    removeFieldSections(fields: FieldSection[]): void;
+    moveFieldSection(sourceIndex: number, targetIndex: number): void;
+    deserializeValues(values: SerializedFieldValues): FieldValues;
+    serializeValues(values: FieldValues): SerializedFieldValues;
+    deserializeConditions(conditions: SerializedCondition[]): import('..').Condition[];
+}