@overmap-ai/forms 1.0.39-react-hook-form.1 → 1.0.39

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

@@ -1,7 +1,6 @@
 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 {
     minimum_length?: number;
     maximum_length?: number;
@@ -9,13 +8,11 @@ export interface MultiStringFieldOptions extends FieldOptions {
 }
 export declare class MultiStringField extends BaseField<"multi-string", string[], string[], MultiStringField> {
     readonly type = "multi-string";
-    static readonly fieldTypeName = "Multi-string";
-    static readonly fieldTypeDescription = "Allows the user to provide multiple unique strings.";
     minLength: number;
     maxLength: number;
     placeholder: string;
     constructor(options: MultiStringFieldOptions);
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     serialize(): SerializedMultiStringField;
     getOptions(): MultiStringFieldOptions;
     duplicate(identifier: string): MultiStringField;

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

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

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

@@ -1,8 +1,7 @@
 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;
@@ -15,8 +14,6 @@ export interface NumberFieldOptions extends FieldOptions {
 }
 export declare class NumberField extends BaseField<"number", number | null, number | null, NumberField> {
     readonly type = "number";
-    static readonly fieldTypeName = "Number";
-    static readonly fieldTypeDescription = "Allows specifying a number within a given range.";
     minimum: number | undefined;
     maximum: number | undefined;
     integers: boolean;
@@ -37,7 +34,7 @@ export declare class NumberField extends BaseField<"number", number | null, numb
     static deserialize(data: SerializedNumberField): NumberField;
     serializeValue(value: number | null): number | null;
     deserializeValue(value: number | null): number | null;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is number;
     isValue(value: unknown): value is number | null;
     areValuesEqual(value1: number | null, value2: number | null): boolean;

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

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

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

@@ -1,17 +1,14 @@
 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 {
     length: number;
     validationType: OTPFieldValidationType;
 }
 export declare class OTPField extends BaseField<"otp", string, string, OTPField> {
     readonly type = "otp";
-    static readonly fieldTypeName = "OTP";
-    static readonly fieldTypeDescription = "Allows specifying a number within a given range.";
     length: number;
     validationType: OTPFieldValidationType;
     constructor(options: OTPFieldOptions);
@@ -30,7 +27,7 @@ export declare class OTPField extends BaseField<"otp", string, string, OTPField>
     static deserialize(data: SerializedOTPField): OTPField;
     serializeValue(value: string): string;
     deserializeValue(value: string): string;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string;
     isValue(value: unknown): value is string;
     blankValue(): string;

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

@@ -1,5 +1,5 @@
-import { ComponentProps } from 'react';
 import { OneTimePasswordField } from '@overmap-ai/blocks';
+import { ComponentProps } from 'react';
 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

@@ -1,14 +1,11 @@
 import { ReactNode } from 'react';
-import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailField, SerializedPassFailFieldValue } from './typings';
 import { BaseField, FieldCreationSchemaObject, FieldOptions, FieldValidator } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
+import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailField, SerializedPassFailFieldValue } from './typings';
 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.";
     showNotesAndFilesOn: PassFailFieldStatus[];
     constructor(options: PassFailFieldOptions);
     static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];
@@ -20,7 +17,7 @@ export declare class PassFailField extends BaseField<"pass-fail", PassFailFieldV
     static deserialize(data: SerializedPassFailField): PassFailField;
     serializeValue(value: PassFailFieldValue): SerializedPassFailFieldValue;
     deserializeValue(value: SerializedPassFailFieldValue): PassFailFieldValue;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is SerializedPassFailFieldValue;
     isValue(value: unknown): value is PassFailFieldValue;
     areValuesEqual(value1: PassFailFieldValue, value2: PassFailFieldValue): boolean;

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

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

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

@@ -1,6 +1,6 @@
+import { UUIDFile } from '../../UUIDFile';
 import { UUIDPromise } from '../../UUIDPromise';
 import { BaseSerializedField } from '../BaseField';
-import { UUIDFile } from '../../UUIDFile';
 export type PassFailFieldStatus = "pass" | "fail" | "na";
 export interface PassFailFieldValue {
     status: PassFailFieldStatus | null;

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

@@ -1,13 +1,10 @@
 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 {
 }
 export declare class RadioField extends BaseOptionsField<"radio", string | null, string | null, RadioField> {
     readonly type = "radio";
-    static readonly fieldTypeName = "Option list";
-    static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
     constructor(options: RadioFieldOptions);
     serialize(): SerializedRadioField;
     getOptions(): RadioFieldOptions;
@@ -16,7 +13,7 @@ export declare class RadioField extends BaseOptionsField<"radio", string | null,
     static deserialize(data: SerializedRadioField): RadioField;
     serializeValue(value: string | null): string | null;
     deserializeValue(value: string | null): string | null;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string | null;
     isValue(value: unknown): value is string | null;
     blankValue(): string | null;

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

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

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

@@ -1,15 +1,12 @@
 import { ReactNode } from 'react';
-import { SerializedRatingField } from './typings';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
 import { NumberField } from '../NumberField';
+import { SerializedRatingField } from './typings';
 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): {
@@ -24,7 +21,7 @@ export declare class RatingField extends BaseField<"rating", number | null, numb
     static deserialize(data: SerializedRatingField): RatingField;
     serializeValue(value: number | null): number | null;
     deserializeValue(value: number | null): number | null;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is number | null;
     isValue(value: unknown): value is number | null;
     areValuesEqual(value1: number | null, value2: number | null): boolean;

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

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

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

@@ -1,13 +1,10 @@
 import { ReactNode } from 'react';
-import { SerializedScanField } from './typings';
 import { BaseField, FieldOptions } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
+import { SerializedScanField } from './typings';
 export interface ScanFieldOptions extends FieldOptions {
 }
 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.";
     constructor(options: ScanFieldOptions);
     serialize(): SerializedScanField;
     getOptions(): ScanFieldOptions;
@@ -16,7 +13,7 @@ export declare class ScanField extends BaseField<"qr", string, string, ScanField
     static deserialize(data: SerializedScanField): ScanField;
     serializeValue(value: string): string;
     deserializeValue(value: string): string;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string;
     isValue(value: unknown): value is string;
     blankValue(): string;

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

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

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

@@ -1,14 +1,11 @@
 import { ReactNode } from 'react';
-import { SerializedSelectField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
+import { SerializedSelectField } from './typings';
 export type SelectFieldOptions = BaseOptionsFieldOptions & {
     placeholder?: string;
 };
 export declare class SelectField extends BaseOptionsField<"select", string | null, string | null, SelectField> {
     readonly type = "select";
-    static readonly fieldTypeName = "Dropdown";
-    static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
     placeholder?: string;
     constructor(options: SelectFieldOptions);
     serialize(): SerializedSelectField;
@@ -18,7 +15,7 @@ export declare class SelectField extends BaseOptionsField<"select", string | nul
     static deserialize(data: SerializedSelectField): SelectField;
     serializeValue(value: string | null): string | null;
     deserializeValue(value: string | null): string | null;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string | null;
     isValue(value: unknown): value is string | null;
     blankValue(): string | null;

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

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

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

@@ -1,18 +1,15 @@
 import { ReactNode } from 'react';
-import { SerializedStringField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
+import { SerializedStringField } from './typings';
 export interface StringFieldOptions extends BaseStringFieldOptions {
 }
 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.";
     constructor(options: StringFieldOptions);
     serialize(): SerializedStringField;
     getOptions(): StringFieldOptions;
     duplicate(identifier: string): StringField;
     setOptions(options: Partial<StringFieldOptions>): void;
     static deserialize(data: SerializedStringField): StringField;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
 }

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

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

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

@@ -1,17 +1,14 @@
 import { ReactNode } from 'react';
-import { SerializedTextField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
+import { SerializedTextField } from './typings';
 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.";
     constructor(options: TextFieldOptions);
     serialize(): SerializedTextField;
     getOptions(): TextFieldOptions;
     duplicate(identifier: string): TextField;
     setOptions(options: Partial<TextFieldOptions>): void;
     static deserialize(data: SerializedTextField): TextField;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
 }

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

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

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

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { BaseField, FieldOptions } from '../BaseField';
+import { SerializedTimeField, Time } from './typings';
+export type TimeFieldOptions = FieldOptions;
+export declare class TimeField extends BaseField<"time", Time | null, Time | null, TimeField> {
+    readonly type = "time";
+    constructor(config: TimeFieldOptions);
+    static deserialize(data: SerializedTimeField): TimeField;
+    getOptions(): TimeFieldOptions;
+    duplicate(identifier: string): TimeField;
+    setOptions(options: Partial<TimeFieldOptions>): void;
+    serializeValue(value: Time | null): Time | null;
+    deserializeValue(value: Time | null): Time | null;
+    render(): ReactNode;
+    isSerializedValue(value: unknown): value is Time | null;
+    isValue(value: unknown): value is Time | null;
+    blankValue(): Time | null;
+    blankSerializedValue(): Time | null;
+    areSerializedValuesEqual(value1: Time | null, value2: Time | null): boolean;
+    areValuesEqual(value1: Time | null, value2: Time | null): boolean;
+}

package/dist/form/fields/TimeField/TimeField.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/form/fields/TimeField/TimeFieldControl.d.ts

@@ -0,0 +1,13 @@
+import { InputSize } from '@overmap-ai/blocks';
+import { Time } from './typings';
+export interface TimeFieldControlProps {
+    value?: Time | null;
+    onChange: (value: Time | null) => void;
+    onBlur?: () => void;
+    disabled?: boolean;
+    size?: InputSize;
+    id?: string;
+    name?: string;
+    compact?: boolean;
+}
+export declare const TimeFieldControl: import('react').NamedExoticComponent<TimeFieldControlProps>;

package/dist/form/fields/TimeField/TimeFieldInput.d.ts

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

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

@@ -0,0 +1,2 @@
+export declare const UTC_OFFSETS: (`+${string}:${string}` | `-${string}:${string}`)[];
+export declare const UTC_OFFSETS_SET: Set<`+${string}:${string}` | `-${string}:${string}`>;

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

@@ -0,0 +1,6 @@
+export * from './TimeField';
+export * from './TimeFieldControl';
+export * from './TimeFieldInput';
+export type * from './typings';
+export * from './utils';
+export * from './constants';

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

@@ -0,0 +1,11 @@
+import { BaseSerializedField } from '../BaseField';
+export interface SerializedTimeField extends BaseSerializedField<"time"> {
+}
+export type UTCOffsetSign = "+" | "-";
+export type UTCOffsetTime = `${string}:${string}`;
+export type UTCOffset = `${UTCOffsetSign}${UTCOffsetTime}`;
+export type Time = `T${UTCOffsetTime}:00${UTCOffset}`;
+export interface TimeRange {
+    from: Time | null;
+    to: Time | null;
+}

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

@@ -0,0 +1,16 @@
+import { Time, TimeRange, UTCOffset } from './typings';
+export declare const isUTCOffset: (value: unknown) => value is UTCOffset;
+export declare const getCurrentUTCOffset: () => UTCOffset;
+export declare function getUTCOffsetMinutes(offset: UTCOffset): number;
+export declare const parseTime: (value: string) => {
+    hours: number;
+    minutes: number;
+    utcOffset: `+${string}:${string}` | `-${string}:${string}`;
+} | null;
+export declare const isTime: (value: unknown) => value is Time;
+export declare const createTime: (hours: number, minutes: number, utcOffset?: UTCOffset) => Time;
+export declare const formatUTCOffset: (offset: UTCOffset) => string;
+export declare const getUTCMinuteOfDay: (value: Time) => number;
+export declare const formatTime: (value: Time, offset?: boolean) => string;
+export declare const isTimeRange: (value: Time | TimeRange) => value is TimeRange;
+export declare const isTimeInRange: (value: Time, range: TimeRange) => boolean;

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

@@ -1,14 +1,11 @@
 import { ReactNode } from 'react';
-import { SerializedURLField } from './typings';
 import { BaseField, FieldOptions } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
+import { SerializedURLField } from './typings';
 export interface URLFieldOptions extends FieldOptions {
     placeholder?: string;
 }
 export declare class URLField extends BaseField<"url", URL | null, string | null, URLField> {
     readonly type = "url";
-    static readonly fieldTypeName = "URL";
-    static readonly fieldTypeDescription = "Allows users to enter a URL.";
     placeholder: string;
     constructor(options: URLFieldOptions);
     serialize(): SerializedURLField;
@@ -24,5 +21,5 @@ export declare class URLField extends BaseField<"url", URL | null, string | null
     blankSerializedValue(): string | null;
     areSerializedValuesEqual(value1: string | null, value2: string | null): boolean;
     areValuesEqual(value1: URL | null, value2: URL | null): boolean;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
 }

package/dist/form/fields/URLField/URLFieldInput.d.ts

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

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

@@ -1,11 +1,10 @@
 import { ReactNode } from 'react';
-import { SerializedUploadField } from './typings';
 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 { SerializedUploadField } from './typings';
 export interface UploadFieldOptions extends FieldOptions {
     extensions?: string[];
     maximum_size?: number | string;
@@ -13,8 +12,6 @@ export interface UploadFieldOptions extends FieldOptions {
 }
 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.";
     extensions?: string[];
     maxFileSize: number | undefined;
     maxFiles: number;
@@ -34,7 +31,7 @@ export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFi
     static deserialize(data: SerializedUploadField): UploadField;
     serializeValue(_value: (UUIDPromise<UUIDFile> | UUIDFile)[]): never[];
     deserializeValue(_value: never[]): (UUIDPromise<UUIDFile> | UUIDFile)[];
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is never[];
     isValue(value: unknown): value is (UUIDPromise<UUIDFile> | UUIDFile)[];
     areValuesEqual(value1: (UUIDPromise<UUIDFile> | UUIDFile)[], value2: (UUIDPromise<UUIDFile> | UUIDFile)[]): boolean;

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

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

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

@@ -1,40 +1,17 @@
 import { IconComponent } from '@overmap-ai/blocks';
-import { FieldType } from './typings';
-import { BooleanField } from './BooleanField';
-import { CheckboxListField } from './CheckboxListField';
-import { DateField } from './DateField';
-import { MultiSelectField } from './MultiSelectField';
-import { MultiStringField } from './MultiStringField';
-import { NumberField } from './NumberField';
-import { OTPField } from './OTPField';
-import { PassFailField } from './PassFailField';
-import { RadioField } from './RadioField';
-import { RatingField } from './RatingField';
-import { ScanField } from './ScanField';
-import { SelectField } from './SelectField';
-import { StringField } from './StringField';
-import { TextField } from './TextField';
-import { UploadField } from './UploadField';
-import { URLField } from './URLField';
-export declare const FieldTypeToClsMapping: {
-    date: typeof DateField;
-    number: typeof NumberField;
-    boolean: typeof BooleanField;
-    select: typeof SelectField;
-    string: typeof StringField;
-    url: typeof URLField;
-    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;
-    rating: typeof RatingField;
-};
-export declare const fieldIcons: Record<FieldType, IconComponent>;
+import { FieldTypeGroup } from './enums';
+import { FieldClass, FieldType } from './typings';
+export declare const FieldTypeToClsMapping: Record<Exclude<FieldType, "section">, FieldClass>;
+export declare const FIELD_TYPES: Exclude<FieldType, "section">[];
+export declare const fieldDataMapping: Record<Exclude<FieldType, "section">, {
+    icon: IconComponent;
+    name: string;
+    description: string;
+    group: FieldTypeGroup;
+}>;
+export declare const fieldTypeGroupDataMapping: Record<FieldTypeGroup, {
+    name: string;
+}>;
 export declare const maxFileSizeMB = 50;
 export declare const maxFileSizeKB: number;
 export declare const maxFileSizeB: number;

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

@@ -0,0 +1,9 @@
+export declare enum FieldTypeGroup {
+    Text = "text",
+    Selection = "selection",
+    Numeric = "numeric",
+    Temporal = "temporal",
+    Capture = "capture",
+    Assessment = "assessment",
+    Verification = "verification"
+}

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

@@ -1,13 +1,15 @@
 import { ReactNode } from 'react';
-import { AnyField, AnyFormElement, ValueOfField } from './typings';
-import { FieldRenderProps } from './BaseFormElement';
-export declare const useFieldInputs: (fields: AnyFormElement[], props: Omit<FieldRenderProps, "index">) => ReactNode;
+import { FieldSection } from './FieldSection';
+import { AnyField, ValueOfField } from './typings';
+export declare const useFieldSectionInputs: (fieldSections: FieldSection[]) => import("react/jsx-runtime").JSX.Element[];
+export declare const useFieldInputs: (fields: AnyField[]) => ReactNode;
 export interface useFieldInputProps<TField extends AnyField> {
     field: TField;
 }
 export declare const useFieldInput: <TField extends AnyField>(props: useFieldInputProps<TField>) => {
     value: ValueOfField<TField>;
     name: TField["identifier"];
+    disabled: boolean | undefined;
     isTouched: boolean;
     error: string;
     onChange: (value: ValueOfField<TField>) => void;

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

@@ -21,7 +21,9 @@ export * from './ScanField';
 export * from './SelectField';
 export * from './StringField';
 export * from './TextField';
+export * from './TimeField';
 export type * from './typings';
 export * from './UploadField';
 export * from './URLField';
 export * from './utils';
+export * from './enums';

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

@@ -15,6 +15,7 @@ import { ScanField, SerializedScanField } from './ScanField';
 import { SelectField, SerializedSelectField } from './SelectField';
 import { SerializedStringField, StringField } from './StringField';
 import { SerializedTextField, TextField } from './TextField';
+import { SerializedTimeField, TimeField } from './TimeField';
 import { SerializedUploadField, UploadField } from './UploadField';
 import { SerializedURLField, URLField } from './URLField';
 export type AnyFormElement = BaseFormElement<any, any>;
@@ -22,13 +23,13 @@ export type AnyField = BaseField<any, any, any, any>;
 export type TypeOfField<TField extends AnyFormElement> = TField extends BaseFormElement<infer TType, infer _TThis> ? TType : never;
 export type ValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer TValue, infer _TSerializedValue, infer _TThis> ? TValue : never;
 export type SerializedValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer _TValue, infer TSerializedValue, infer _TThis> ? TSerializedValue : never;
-export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | RatingField | ScanField | SelectField | StringField | TextField | UploadField | URLField | OTPField;
-export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof RatingField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof URLField | typeof OTPField;
+export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | RatingField | ScanField | SelectField | StringField | TextField | UploadField | URLField | OTPField | TimeField;
+export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof RatingField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof URLField | typeof OTPField | typeof TimeField;
 export type FieldType = TypeOfField<Field> | TypeOfField<FieldSection>;
 export type FieldValue = ValueOfField<Field>;
 export type FieldError = string;
 export type SerializedFieldValue = SerializedValueOfField<Field>;
-export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedURLField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedRatingField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField;
+export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedURLField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedRatingField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField | SerializedTimeField;
 export type SerializedOnlyField = Exclude<SerializedField, SerializedFieldSection>;
 export interface FieldsManager {
     readonly fields: Field[];