@overmap-ai/forms 1.0.32-react-flow-david-fixes.41 → 1.0.33-toast-migration.0

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

@@ -0,0 +1,32 @@
+import { BooleanFieldCondition } from './BooleanFieldCondition';
+import { CheckboxListFieldCondition } from './CheckboxListFieldCondition';
+import { DateFieldCondition } from './DateFieldCondition';
+import { MultiSelectFieldCondition } from './MultiSelectFieldCondition';
+import { MultiStringFieldCondition } from './MultiStringFieldCondition';
+import { NumberFieldCondition } from './NumberFieldCondition';
+import { OTPFieldCondition } from './OTPFieldCondition';
+import { PassFailFieldCondition } from './PassFailFieldCondition';
+import { RadioFieldCondition } from './RadioFieldCondition';
+import { RatingFieldCondition } from './RatingFieldCondition';
+import { ScanFieldCondition } from './ScanFieldCondition';
+import { SelectFieldCondition } from './SelectFieldCondition';
+import { StringFieldCondition } from './StringFieldCondition';
+import { TextFieldCondition } from './TextFieldCondition';
+import { UploadFieldCondition } from './UploadFieldCondition';
+export declare const ConditionTypeToClsMapping: {
+    date: typeof DateFieldCondition;
+    number: typeof NumberFieldCondition;
+    boolean: typeof BooleanFieldCondition;
+    select: typeof SelectFieldCondition;
+    string: typeof StringFieldCondition;
+    text: typeof TextFieldCondition;
+    upload: typeof UploadFieldCondition;
+    qr: typeof ScanFieldCondition;
+    "multi-string": typeof MultiStringFieldCondition;
+    "multi-select": typeof MultiSelectFieldCondition;
+    radio: typeof RadioFieldCondition;
+    "checkbox-list": typeof CheckboxListFieldCondition;
+    "pass-fail": typeof PassFailFieldCondition;
+    otp: typeof OTPFieldCondition;
+    rating: typeof RatingFieldCondition;
+};

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

@@ -1,12 +1,15 @@
 export * from './BaseCondition';
 export * from './BooleanFieldCondition';
 export * from './CheckboxListFieldCondition';
+export * from './ConditionManager';
 export * from './DateFieldCondition';
 export * from './MultiSelectFieldCondition';
 export * from './MultiStringFieldCondition';
 export * from './NumberFieldCondition';
 export * from './OTPFieldCondition';
+export * from './PassFailFieldCondition';
 export * from './RadioFieldCondition';
+export * from './RatingFieldCondition';
 export * from './ScanFieldCondition';
 export * from './SelectFieldCondition';
 export * from './StringFieldCondition';

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

@@ -6,15 +6,18 @@ import { MultiSelectFieldCondition, SerializedMultiSelectCondition } from './Mul
 import { MultiStringFieldCondition, SerializedMultiStringCondition } from './MultiStringFieldCondition';
 import { NumberFieldCondition, SerializedNumberCondition } from './NumberFieldCondition';
 import { OTPFieldCondition, SerializedOTPCondition } from './OTPFieldCondition';
+import { PassFailFieldCondition, SerializedPassFailFieldCondition } from './PassFailFieldCondition';
 import { RadioFieldCondition, SerializedRadioCondition } from './RadioFieldCondition';
+import { RatingFieldCondition, SerializedRatingCondition } from './RatingFieldCondition';
 import { ScanFieldCondition, SerializedScanCondition } from './ScanFieldCondition';
 import { SelectFieldCondition, SerializedSelectCondition } from './SelectFieldCondition';
 import { SerializedStringCondition, StringFieldCondition } from './StringFieldCondition';
 import { SerializedTextCondition, TextFieldCondition } from './TextFieldCondition';
 import { SerializedUploadCondition, UploadFieldCondition } from './UploadFieldCondition';
-export type Condition = BooleanFieldCondition | CheckboxListFieldCondition | DateFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | RadioFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition | OTPFieldCondition;
-export type SerializedCondition = SerializedTextCondition | SerializedBooleanCondition | SerializedNumberCondition | SerializedDateCondition | SerializedStringCondition | SerializedSelectCondition | SerializedMultiStringCondition | SerializedMultiSelectCondition | SerializedUploadCondition | SerializedScanCondition | SerializedRadioCondition | SerializedCheckboxListCondition | SerializedOTPCondition;
-export interface ConditionManager<TCondition extends AnyCondition> {
+export type Condition = BooleanFieldCondition | CheckboxListFieldCondition | PassFailFieldCondition | DateFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | RadioFieldCondition | RatingFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition | OTPFieldCondition;
+export type SerializedCondition = SerializedTextCondition | SerializedBooleanCondition | SerializedNumberCondition | SerializedDateCondition | SerializedStringCondition | SerializedSelectCondition | SerializedMultiStringCondition | SerializedMultiSelectCondition | SerializedUploadCondition | SerializedScanCondition | SerializedRadioCondition | SerializedRatingCondition | SerializedCheckboxListCondition | SerializedPassFailFieldCondition | SerializedOTPCondition;
+export type ConditionClass = typeof BooleanFieldCondition | typeof CheckboxListFieldCondition | typeof PassFailFieldCondition | typeof DateFieldCondition | typeof MultiSelectFieldCondition | typeof MultiStringFieldCondition | typeof NumberFieldCondition | typeof RadioFieldCondition | typeof RatingFieldCondition | typeof ScanFieldCondition | typeof SelectFieldCondition | typeof StringFieldCondition | typeof TextFieldCondition | typeof UploadFieldCondition | typeof OTPFieldCondition;
+export interface FieldConditionManager<TCondition extends AnyCondition> {
     readonly conditions: Record<string, TCondition[]>;
     getConditions(identifier: string): TCondition[];
     addCondition(identifier: string, condition: TCondition): void;

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

@@ -1,7 +1,6 @@
-import { Field } from '../fields';
 import { FieldValues } from '../typings';
-import { AnyCondition } from './BaseCondition';
 import { Condition, SerializedCondition } from './typings';
-export declare const deserializeCondition: (serializedCondition: SerializedCondition, field: Field) => Condition;
-export declare const deserializeConditions: (serializedConditions: SerializedCondition[], fields: Field[]) => Condition[];
-export declare const applyConditions: (conditions: AnyCondition[], values: FieldValues) => boolean;
+import { Field } from '../fields';
+export declare const deserializeCondition: (field: Field, serializedCondition: SerializedCondition) => Condition;
+export declare const deserializeConditions: (fields: Field[], serializedConditions: SerializedCondition[]) => Condition[];
+export declare const applyConditions: (conditions: Condition[], values: FieldValues) => boolean;

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

@@ -1,12 +1,11 @@
-import { BaseFormElement } from '../BaseFormElement';
 import { BaseSerializedField, FieldOptions, FieldValidator } from './typings';
-export declare abstract class BaseField<TIdentifier extends string, TValue, TSerializedValue, This extends BaseField<TIdentifier, TValue, TSerializedValue, This>> extends BaseFormElement<TIdentifier, This> {
+import { BaseFormElement } from '../BaseFormElement';
+export declare abstract class BaseField<TType extends string, TValue, TSerializedValue, This extends BaseField<TType, TValue, TSerializedValue, This>> extends BaseFormElement<TType, This> {
     static readonly fieldTypeName: string;
     static readonly fieldTypeDescription: string;
     label: string;
     description: string | null;
     required: boolean;
-    private fieldValidators;
     image: File | Promise<File> | undefined;
     /**
      * By default, validation doesn't execute on `onChange` events when editing fields
@@ -15,11 +14,11 @@ export declare abstract class BaseField<TIdentifier extends string, TValue, TSer
      * which don't have a `onBlur` event (which is used to set the `touched` state).
      */
     readonly onlyValidateAfterTouched: boolean;
-    protected constructor(options: FieldOptions<TValue>);
+    protected constructor(options: FieldOptions);
     getError(value: TValue): string | undefined;
-    serialize(): BaseSerializedField<TIdentifier>;
-    getOptions(): FieldOptions<TValue>;
-    setOptions(options: Partial<FieldOptions<TValue>>): void;
+    serialize(): BaseSerializedField<TType>;
+    getOptions(): FieldOptions;
+    setOptions(options: Partial<FieldOptions>): void;
     abstract isSerializedValueValid(value: unknown): value is TSerializedValue;
     abstract serializeValue(value: TValue): TSerializedValue;
     abstract isValueValid(value: unknown): value is TValue;

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

@@ -1,17 +1,16 @@
-import { BaseSerializedObject, FormElementOptions } from '../BaseFormElement';
+import { BaseFormElementOptions, BaseSerializedFormElement } from '../BaseFormElement';
 import { AnyField } from '../typings';
-export interface BaseSerializedField<TIdentifier extends string> extends BaseSerializedObject<TIdentifier> {
+export interface BaseSerializedField<TType extends string> extends BaseSerializedFormElement<TType> {
     label: string;
     description?: string | null;
     required: boolean;
     image?: File | Promise<File>;
 }
-export interface FieldOptions<TValue> extends FormElementOptions {
+export interface FieldOptions extends BaseFormElementOptions {
     label: string;
     description?: string | null;
     required: boolean;
     image?: File | Promise<File>;
-    fieldValidators?: FieldValidator<TValue>[];
 }
 export interface FieldCreationSchemaObject {
     field: AnyField;

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

@@ -1,13 +1,13 @@
 import { ReactNode } from 'react';
-import { Observable } from '../../observable/Observable';
-import { BaseSerializedObject, FieldRenderProps, FormElementOptions } from './typings';
-export declare abstract class BaseFormElement<TIdentifier extends string, This extends BaseFormElement<TIdentifier, This>> extends Observable<This> {
-    abstract readonly type: TIdentifier;
+import { BaseFormElementOptions, BaseSerializedFormElement, FieldRenderProps } from './typings';
+import { Observable } from '../../Observable';
+export declare abstract class BaseFormElement<TType extends string, This extends BaseFormElement<TType, This>> extends Observable<This> {
+    abstract readonly type: TType;
     identifier: string;
-    protected constructor(options: FormElementOptions);
-    getOptions(): FormElementOptions;
-    setOptions(options: Partial<FormElementOptions>): void;
-    abstract duplicate(identifier: string): BaseFormElement<TIdentifier, This>;
-    serialize(): BaseSerializedObject<TIdentifier>;
+    protected constructor(options: BaseFormElementOptions);
+    getOptions(): BaseFormElementOptions;
+    setOptions(options: Partial<BaseFormElementOptions>): void;
+    abstract duplicate(identifier: string): BaseFormElement<TType, This>;
+    serialize(): BaseSerializedFormElement<TType>;
     abstract render(props: FieldRenderProps): ReactNode;
 }

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

@@ -1,10 +1,10 @@
 import { TextSize } from '@overmap-ai/blocks';
-export interface FormElementOptions {
+export interface BaseFormElementOptions {
     identifier: string;
 }
-export interface BaseSerializedObject<TIdentifier extends string> {
+export interface BaseSerializedFormElement<TType extends string> {
     identifier: string;
-    type: TIdentifier;
+    type: TType;
 }
 export interface FieldRenderProps {
     formId: string;

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

@@ -1,14 +1,14 @@
-import { BaseField, FieldCreationSchemaObject, FieldOptions } from '../BaseField';
 import { BaseSerializedSelectField, SelectFieldOption } from './typings';
-export interface BaseOptionsFieldOptions<TValue> extends FieldOptions<TValue> {
+import { BaseField, FieldCreationSchemaObject, FieldOptions } from '../BaseField';
+export interface BaseOptionsFieldOptions extends FieldOptions {
     options: string[] | SelectFieldOption[];
 }
-export declare abstract class BaseOptionsField<TIdentifier extends string, TValue, TSerializedValue, This extends BaseOptionsField<TIdentifier, TValue, TSerializedValue, This>> extends BaseField<TIdentifier, TValue, TSerializedValue, This> {
+export declare abstract class BaseOptionsField<TType extends string, TValue, TSerializedValue, This extends BaseOptionsField<TType, TValue, TSerializedValue, This>> extends BaseField<TType, TValue, TSerializedValue, This> {
     options: SelectFieldOption[];
     readonly onlyValidateAfterTouched = false;
-    protected constructor(options: BaseOptionsFieldOptions<TValue>);
-    serialize(): BaseSerializedSelectField<TIdentifier>;
-    getOptions(): BaseOptionsFieldOptions<TValue>;
-    setOptions(options: Partial<BaseOptionsFieldOptions<TValue>>): void;
+    protected constructor(options: BaseOptionsFieldOptions);
+    serialize(): BaseSerializedSelectField<TType>;
+    getOptions(): BaseOptionsFieldOptions;
+    setOptions(options: Partial<BaseOptionsFieldOptions>): void;
     static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];
 }

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

@@ -3,7 +3,7 @@ export interface SelectFieldOption {
     value: string;
     label: string;
 }
-export interface BaseSerializedSelectField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
-    type: TIdentifier;
+export interface BaseSerializedSelectField<TType extends string> extends BaseSerializedField<TType> {
+    type: TType;
     options: SelectFieldOption[];
 }

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

@@ -1,12 +1,12 @@
+import { BaseSerializedStringField } from './typings';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
 import { NumberField } from '../NumberField';
-import { BaseSerializedStringField } from './typings';
-export interface BaseStringFieldOptions extends FieldOptions<string> {
+export interface BaseStringFieldOptions extends FieldOptions {
     minLength?: number;
     maxLength?: number;
     placeholder?: string;
 }
-export declare abstract class BaseStringField<TIdentifier extends string, This extends BaseStringField<TIdentifier, This>> extends BaseField<TIdentifier, string, string, This> {
+export declare abstract class BaseStringField<TType extends string, This extends BaseStringField<TType, This>> extends BaseField<TType, string, string, This> {
     minLength?: number;
     maxLength: number;
     placeholder?: string;
@@ -16,7 +16,7 @@ export declare abstract class BaseStringField<TIdentifier extends string, This e
         showDirectly: boolean;
     }[];
     getFieldValidators(): FieldValidator<string>[];
-    serialize(): BaseSerializedStringField<TIdentifier>;
+    serialize(): BaseSerializedStringField<TType>;
     getOptions(): BaseStringFieldOptions;
     setOptions(options: Partial<BaseStringFieldOptions>): void;
     serializeValue(value: string): string;

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

@@ -1,5 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-export interface BaseSerializedStringField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
+export interface BaseSerializedStringField<TType extends string> extends BaseSerializedField<TType> {
     minimum_length?: number;
     maximum_length: number;
     placeholder?: string;

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

@@ -1,9 +1,8 @@
 import { ReactNode } from 'react';
+import { SerializedBooleanField } from './typings';
 import { BaseField, FieldOptions } from '../BaseField';
 import { FieldRenderProps } from '../BaseFormElement';
-import { SerializedField } from '../typings';
-import { SerializedBooleanField } from './typings';
-export type BooleanFieldOptions = FieldOptions<boolean>;
+export type BooleanFieldOptions = FieldOptions;
 export declare class BooleanField extends BaseField<"boolean", boolean, boolean, BooleanField> {
     readonly type = "boolean";
     static readonly fieldTypeName = "Checkbox";
@@ -14,7 +13,7 @@ export declare class BooleanField extends BaseField<"boolean", boolean, boolean,
     getOptions(): BooleanFieldOptions;
     setOptions(options: Partial<BooleanFieldOptions>): void;
     duplicate(identifier: string): BooleanField;
-    static deserialize(data: SerializedField): BooleanField;
+    static deserialize(data: SerializedBooleanField): BooleanField;
     serializeValue(value: boolean): boolean;
     deserializeValue(value: boolean): boolean;
     render(props: FieldRenderProps): ReactNode;

package/dist/form/fields/BooleanField/BooleanInput.d.ts

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { BooleanField } from './BooleanField';
+import { FieldRenderProps } from '../BaseFormElement';
 interface BooleanInputProps extends FieldRenderProps {
     field: BooleanField;
 }

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

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
+import { SerializedCheckboxListField } from './typings';
 import { FieldRenderProps } from '../BaseFormElement';
 import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedCheckboxListField } from './typings';
-export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions<string[]> {
+export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions {
 }
 export declare class CheckboxListField extends BaseOptionsField<"checkbox-list", string[], string[], CheckboxListField> {
     readonly type = "checkbox-list";

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

@@ -1,12 +1,12 @@
 import { ReactNode } from 'react';
+import { SerializedDateField } from './typings';
 import { BaseField, FieldOptions } from '../BaseField';
 import { FieldRenderProps } from '../BaseFormElement';
-import { SerializedDateField } from './typings';
 export type SerializedDateRange = {
     to: string | null;
     from: string | null;
 };
-export interface DateFieldOptions extends FieldOptions<Date | null> {
+export interface DateFieldOptions extends FieldOptions {
 }
 export declare class DateField extends BaseField<"date", Date | null, string | null, DateField> {
     readonly type = "date";

package/dist/form/fields/DateField/DateInput.d.ts

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { DateField } from './DateField';
+import { FieldRenderProps } from '../BaseFormElement';
 interface DateInputProps extends FieldRenderProps {
     field: DateField;
 }

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

@@ -1,16 +1,16 @@
 import { ReactNode } from 'react';
-import { Condition, ConditionManager } from '../../conditions';
 import { FieldValues } from '../../typings';
-import { BaseFormElement, FieldRenderProps, FormElementOptions } from '../BaseFormElement';
 import { Field, FieldsManager } from '../typings';
+import { Condition, FieldConditionManager } from '../../conditions';
+import { BaseFormElement, BaseFormElementOptions, FieldRenderProps } from '../BaseFormElement';
 import { FieldSectionConditions, SerializedFieldSection } from './typings';
-export interface FieldSectionOptions extends FormElementOptions {
+export interface FieldSectionOptions extends BaseFormElementOptions {
     label?: string | null;
     description?: string | null;
     conditions?: FieldSectionConditions;
     fields: Field[];
 }
-export declare class FieldSection extends BaseFormElement<"section", FieldSection> implements ConditionManager<Condition>, FieldsManager {
+export declare class FieldSection extends BaseFormElement<"section", FieldSection> implements FieldConditionManager<Condition>, FieldsManager {
     static readonly fieldTypeName = "Section";
     static readonly fieldTypeDescription = "Sections can be useful for grouping fields together. They can also be conditionally shown or hidden.";
     readonly type = "section";
@@ -20,7 +20,7 @@ export declare class FieldSection extends BaseFormElement<"section", FieldSectio
     fields: Field[];
     constructor(options: FieldSectionOptions);
     serialize(): SerializedFieldSection;
-    static deserialize(data: SerializedFieldSection): FieldSection;
+    static deserialize: (data: SerializedFieldSection) => FieldSection;
     getOptions(): FieldSectionOptions;
     duplicate(identifier: string): FieldSection;
     setOptions(options: Partial<FieldSectionOptions>): void;
@@ -28,11 +28,9 @@ export declare class FieldSection extends BaseFormElement<"section", FieldSectio
     private fieldObserver;
     private initFields;
     getFields(): Field[];
-    addField(field: Field): void;
-    addFields(fields: Field[]): void;
+    addField(field: Field, index?: number): void;
     moveField(sourceIndex: number, targetIndex: number): void;
     removeField(field: Field): void;
-    removeFields(fields: Field[]): void;
     private conditionObserver;
     private initConditions;
     getConditions(identifier: string): Condition[];

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

@@ -1,9 +1,9 @@
 import { Condition, SerializedCondition } from '../../conditions';
-import { BaseSerializedObject } from '../BaseFormElement';
+import { BaseSerializedFormElement } from '../BaseFormElement';
 import { SerializedOnlyField } from '../typings';
 export type FieldSectionConditions = Record<string, Condition[]>;
 export type SerializedFieldSectionConditions = Record<string, SerializedCondition[]>;
-export interface SerializedFieldSection extends BaseSerializedObject<"section"> {
+export interface SerializedFieldSection extends BaseSerializedFormElement<"section"> {
     label: string | null;
     description?: string | null;
     conditions: SerializedFieldSectionConditions;

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

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
+import { SerializedMultiSelectField } from './typings';
 import { FieldRenderProps } from '../BaseFormElement';
 import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedMultiSelectField } from './typings';
-export type MultiSelectFieldOptions = BaseOptionsFieldOptions<string[]> & {
+export type MultiSelectFieldOptions = BaseOptionsFieldOptions & {
     placeholder?: string;
 };
 export declare class MultiSelectField extends BaseOptionsField<"multi-select", string[], string[], MultiSelectField> {

package/dist/form/fields/MultiSelectField/MultiSelectInput.d.ts

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { MultiSelectField } from './MultiSelectField';
+import { FieldRenderProps } from '../BaseFormElement';
 export interface MultiSelectInputProps extends FieldRenderProps {
     field: MultiSelectField;
 }

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

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
+import { SerializedMultiStringField } from './typings';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
 import { FieldRenderProps } from '../BaseFormElement';
-import { SerializedMultiStringField } from './typings';
-export interface MultiStringFieldOptions extends FieldOptions<string[]> {
+export interface MultiStringFieldOptions extends FieldOptions {
     minimum_length?: number;
     maximum_length?: number;
     placeholder?: string;

package/dist/form/fields/MultiStringField/MultiStringInput.d.ts

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { MultiStringField } from './MultiStringField';
+import { FieldRenderProps } from '../BaseFormElement';
 interface MultiStringInputProps extends FieldRenderProps {
     field: MultiStringField;
 }

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

@@ -1,13 +1,13 @@
 import { ReactNode } from 'react';
+import { SerializedNumberField } from './typings';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
 import { FieldRenderProps } from '../BaseFormElement';
 import { BooleanField } from '../BooleanField';
-import { SerializedNumberField } from './typings';
 export type NumberRange = {
     to: number | null;
     from: number | null;
 };
-export interface NumberFieldOptions extends FieldOptions<number | null> {
+export interface NumberFieldOptions extends FieldOptions {
     maximum?: number;
     minimum?: number;
     integers?: boolean;

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

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { NumberField } from './NumberField';
+import { FieldRenderProps } from '../BaseFormElement';
 interface NumberInputProps extends FieldRenderProps {
     field: NumberField;
 }

package/dist/form/fields/OneTimePasswordField/OTPField.d.ts

@@ -1,10 +1,10 @@
 import { ReactNode } from 'react';
+import { OTPFieldValidationType, SerializedOTPField } from './typings';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
 import { FieldRenderProps } from '../BaseFormElement';
 import { NumberField } from '../NumberField';
 import { SelectField } from '../SelectField';
-import { OTPFieldValidationType, SerializedOTPField } from './typings';
-export interface OTPFieldOptions extends FieldOptions<string> {
+export interface OTPFieldOptions extends FieldOptions {
     length: number;
     validationType: OTPFieldValidationType;
 }

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

@@ -1,5 +1,5 @@
-import { OneTimePasswordField } from '@overmap-ai/blocks';
 import { ComponentProps } from 'react';
+import { OneTimePasswordField } from '@overmap-ai/blocks';
 import { BaseSerializedField } from '../BaseField';
 export type OTPFieldValidationType = NonNullable<ComponentProps<typeof OneTimePasswordField.Root>["validationType"]>;
 export interface SerializedOTPField extends BaseSerializedField<"otp"> {

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

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailField, SerializedPassFailFieldValue } from './typings';
+import { BaseField, FieldCreationSchemaObject, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
+export interface PassFailFieldOptions extends FieldOptions {
+    showNotesAndFilesOn: PassFailFieldStatus[];
+}
+export declare class PassFailField extends BaseField<"pass-fail", PassFailFieldValue, SerializedPassFailFieldValue, PassFailField> {
+    readonly type = "pass-fail";
+    static readonly fieldTypeName = "Pass - Fail";
+    static readonly fieldTypeDescription = "Track pass, fail, or N/A outcome.";
+    readonly onlyValidateAfterTouched = false;
+    showNotesAndFilesOn: PassFailFieldStatus[];
+    constructor(options: PassFailFieldOptions);
+    static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];
+    serialize(): SerializedPassFailField;
+    getOptions(): PassFailFieldOptions;
+    duplicate(identifier: string): PassFailField;
+    setOptions(options: Partial<PassFailFieldOptions>): void;
+    getFieldValidators(): FieldValidator<PassFailFieldValue>[];
+    static deserialize(data: SerializedPassFailField): PassFailField;
+    serializeValue(value: PassFailFieldValue): SerializedPassFailFieldValue;
+    deserializeValue(value: SerializedPassFailFieldValue): PassFailFieldValue;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is SerializedPassFailFieldValue;
+    isValueValid(value: unknown): value is PassFailFieldValue;
+    areValuesEqual(value1: PassFailFieldValue, value2: PassFailFieldValue): boolean;
+    blankValue(): PassFailFieldValue;
+    cleanValue(value: PassFailFieldValue): PassFailFieldValue;
+}

package/dist/form/fields/PassFailField/PassFailInput.d.ts

@@ -0,0 +1,7 @@
+import { PassFailField } from './PassFailField';
+import { FieldRenderProps } from '../BaseFormElement';
+interface PassFailInputProps extends FieldRenderProps {
+    field: PassFailField;
+}
+export declare const PassFailInput: import('react').MemoExoticComponent<(props: PassFailInputProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -0,0 +1,7 @@
+import { IconComponent } from '@overmap-ai/blocks';
+import { PassFailFieldStatus } from './typings';
+export declare const passFailFieldStatusMapping: Record<PassFailFieldStatus, {
+    label: string;
+    icon: IconComponent;
+}>;
+export declare const passFailFieldStatuses: PassFailFieldStatus[];

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

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './PassFailField';
+export * from './PassFailInput';
+export * from './typings';
+export * from './utils';

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

@@ -0,0 +1,17 @@
+import { UUIDPromise } from '../../UUIDPromise';
+import { BaseSerializedField } from '../BaseField';
+import { UUIDFile } from '../../UUIDFile';
+export type PassFailFieldStatus = "pass" | "fail" | "na";
+export interface PassFailFieldValue {
+    status: PassFailFieldStatus | null;
+    notes: string;
+    files: (UUIDPromise<UUIDFile> | UUIDFile)[];
+}
+export interface SerializedPassFailFieldValue {
+    status: PassFailFieldStatus | null;
+    notes: string;
+    files: never[];
+}
+export interface SerializedPassFailField extends BaseSerializedField<"pass-fail"> {
+    showNotesAndFilesOn: PassFailFieldStatus[];
+}

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

@@ -0,0 +1,7 @@
+import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailFieldValue } from './typings';
+export declare const isPassFailFieldStatus: (value: unknown) => value is PassFailFieldStatus;
+export declare const isSerializedPassFailFieldValue: (value: unknown) => value is SerializedPassFailFieldValue;
+export declare const isPassFailFieldValue: (value: unknown) => value is PassFailFieldValue;
+export declare const serializePassFailFieldValue: (value: PassFailFieldValue) => SerializedPassFailFieldValue;
+export declare const deserializePassFailFieldValue: (value: SerializedPassFailFieldValue) => PassFailFieldValue;
+export declare const arePassFieldValuesEqual: (value1: PassFailFieldValue, value2: PassFailFieldValue) => boolean;

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

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
+import { SerializedRadioField } from './typings';
 import { FieldRenderProps } from '../BaseFormElement';
 import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedRadioField } from './typings';
-export interface RadioFieldOptions extends BaseOptionsFieldOptions<string | null> {
+export interface RadioFieldOptions extends BaseOptionsFieldOptions {
 }
 export declare class RadioField extends BaseOptionsField<"radio", string | null, string | null, RadioField> {
     readonly type = "radio";

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

@@ -1,5 +1,5 @@
-import { FieldRenderProps } from '../BaseFormElement';
 import { RadioField } from './RadioField';
+import { FieldRenderProps } from '../BaseFormElement';
 interface RadioInputProps extends FieldRenderProps {
     field: RadioField;
 }

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

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { SerializedRatingField } from './typings';
+import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
+import { NumberField } from '../NumberField';
+export interface RatingFieldOptions extends FieldOptions {
+    maxRating: number;
+}
+export declare class RatingField extends BaseField<"rating", number | null, number | null, RatingField> {
+    readonly type = "rating";
+    static readonly fieldTypeName = "Rating";
+    static readonly fieldTypeDescription = "Allows users to select a rating value.";
+    maxRating: number;
+    constructor(options: RatingFieldOptions);
+    static getFieldCreationSchema(parentPath?: string): {
+        field: NumberField;
+        showDirectly: boolean;
+    }[];
+    getFieldValidators(): FieldValidator<number | null>[];
+    serialize(): SerializedRatingField;
+    getOptions(): RatingFieldOptions;
+    duplicate(identifier: string): RatingField;
+    setOptions(options: Partial<RatingFieldOptions>): void;
+    static deserialize(data: SerializedRatingField): RatingField;
+    serializeValue(value: number | null): number | null;
+    deserializeValue(value: number | null): number | null;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is number;
+    isValueValid(value: unknown): value is number | null;
+    areValuesEqual(value1: number | null, value2: number | null): boolean;
+    blankValue(): number | null;
+}

package/dist/form/fields/RatingField/RatingInput.d.ts

@@ -0,0 +1,7 @@
+import { RatingField } from './RatingField';
+import { FieldRenderProps } from '../BaseFormElement';
+interface RatingInputProps extends FieldRenderProps {
+    field: RatingField;
+}
+export declare const RatingInput: import('react').NamedExoticComponent<RatingInputProps>;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './RatingField';
+export * from './RatingInput';
+export * from './typings';

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

@@ -0,0 +1,4 @@
+import { BaseSerializedField } from '../BaseField';
+export interface SerializedRatingField extends BaseSerializedField<"rating"> {
+    maxRating: number;
+}