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

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

@@ -1,40 +1,32 @@
 import { ReactNode } from 'react';
-import { RiListCheck } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { GetInputProps, InputFieldLevelValidator, ISerializedField } from '../typings';
+import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
 import { SerializedMultiStringField } from './typings';
-type MultiStringFieldOptions = ChildFieldOptions<string[]> & {
+export interface MultiStringFieldOptions extends FieldOptions<string[]> {
     minimum_length?: number;
     maximum_length?: number;
     placeholder?: string;
-};
-export declare const emptyMultiStringField: {
-    type: string;
-    minimum_length: number;
-    maximum_length: null;
-    label: string;
-    description: string;
-    required: boolean;
-};
-/**
- * A field that lets the user input multiple strings. Each string must be unique. Useful for things like:
- * - Specifying the options of a SelectField (used in `SelectField.getFieldCreationSchema`
- * - Listing serial numbers and similar
- */
-export declare class MultiStringField extends BaseField<string[], "multi-string"> {
+}
+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.";
-    readonly minLength: number;
-    readonly maxLength: number;
+    minLength: number;
+    maxLength: number;
+    placeholder: string;
     readonly onlyValidateAfterTouched = false;
-    readonly placeholder: string;
-    static Icon: typeof RiListCheck;
     constructor(options: MultiStringFieldOptions);
-    getInput(props: GetInputProps<this>): ReactNode;
+    render(props: FieldRenderProps): ReactNode;
     serialize(): SerializedMultiStringField;
-    protected isBlank(value: string[] | undefined): boolean;
-    isEqual(value1: string[] | undefined, value2: string[] | undefined): boolean;
-    getFieldValidators(): InputFieldLevelValidator<string[]>[];
-    static deserialize(data: ISerializedField): MultiStringField;
+    getOptions(): MultiStringFieldOptions;
+    duplicate(identifier: string): MultiStringField;
+    setOptions(options: Partial<MultiStringFieldOptions>): void;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    getFieldValidators(): FieldValidator<string[]>[];
+    static deserialize(data: SerializedMultiStringField): MultiStringField;
+    isSerializedValueValid(value: unknown): value is string[];
+    isValueValid(value: unknown): value is string[];
+    blankValue(): string[];
+    areValuesEqual(value1: string[], value2: string[]): boolean;
 }
-export {};

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

@@ -1,7 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { MultiStringField } from './MultiStringField';
-/**
- * Allows the user to create an array of unique strings and customize the order.
- * User to generate options for the Select field.
- */
-export declare const MultiStringInput: import('react').MemoExoticComponent<(props: ComponentProps<MultiStringField>) => import("react/jsx-runtime").JSX.Element>;
+interface MultiStringInputProps extends FieldRenderProps {
+    field: MultiStringField;
+}
+export declare const MultiStringInput: import('react').NamedExoticComponent<MultiStringInputProps>;
+export {};

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

@@ -1,4 +1,6 @@
-import { BaseSerializedStringField } from '../StringOrTextField';
-export interface SerializedMultiStringField extends BaseSerializedStringField {
-    type: "multi-string";
+import { BaseSerializedField } from '../BaseField';
+export interface SerializedMultiStringField extends BaseSerializedField<"multi-string"> {
+    minimum_length?: number;
+    maximum_length: number;
+    placeholder?: string;
 }

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

@@ -1,35 +1,27 @@
 import { ReactNode } from 'react';
-import { RiHashtag } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
+import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
 import { BooleanField } from '../BooleanField';
-import { GetInputProps, InputFieldLevelValidator, InputValidator, ISerializedField } from '../typings';
 import { SerializedNumberField } from './typings';
-export declare const emptyNumberField: {
-    type: string;
-    minimum: number;
-    maximum: number;
-    integers: boolean;
-    label: string;
-    description: string;
-    required: boolean;
+export type NumberRange = {
+    to: number | null;
+    from: number | null;
 };
-export interface NumberFieldOptions extends ChildFieldOptions<number> {
+export interface NumberFieldOptions extends FieldOptions<number | null> {
     maximum?: number;
     minimum?: number;
     integers?: boolean;
     placeholder?: string;
 }
-export declare class NumberField extends BaseField<number, "number"> {
+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.";
-    readonly minimum: number | undefined;
-    readonly maximum: number | undefined;
-    readonly integers: boolean;
-    readonly placeholder: string;
-    static Icon: typeof RiHashtag;
+    minimum: number | undefined;
+    maximum: number | undefined;
+    integers: boolean;
+    placeholder?: string;
     constructor(options: NumberFieldOptions);
-    static _validateMin: (path: string) => InputValidator<number>;
-    static _validateMax: (path: string) => InputValidator<number>;
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
         showDirectly: boolean;
@@ -37,8 +29,17 @@ export declare class NumberField extends BaseField<number, "number"> {
         field: BooleanField;
         showDirectly: boolean;
     })[];
-    getFieldValidators(): InputFieldLevelValidator<number>[];
+    getFieldValidators(): FieldValidator<number | null>[];
     serialize(): SerializedNumberField;
-    static deserialize(data: ISerializedField): NumberField;
-    getInput(props: GetInputProps<this>): ReactNode;
+    getOptions(): NumberFieldOptions;
+    duplicate(identifier: string): NumberField;
+    setOptions(options: Partial<NumberFieldOptions>): void;
+    static deserialize(data: SerializedNumberField): NumberField;
+    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/NumberField/NumberInput.d.ts

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

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

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

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

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+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> {
+    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);
+    static getFieldCreationSchema(parentPath?: string): ({
+        field: NumberField;
+        showDirectly: boolean;
+    } | {
+        field: SelectField;
+        showDirectly: boolean;
+    })[];
+    getFieldValidators(): FieldValidator<string>[];
+    serialize(): SerializedOTPField;
+    getOptions(): OTPFieldOptions;
+    duplicate(identifier: string): OTPField;
+    setOptions(options: Partial<OTPFieldOptions>): void;
+    static deserialize(data: SerializedOTPField): OTPField;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string;
+    isValueValid(value: unknown): value is string;
+    blankValue(): string;
+    areValuesEqual(value1: string, value2: string): boolean;
+}

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

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

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

@@ -0,0 +1,3 @@
+export * from './OTPField';
+export * from './OTPInput';
+export type * from './typings';

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

@@ -0,0 +1,8 @@
+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"> {
+    length: number;
+    validationType: OTPFieldValidationType;
+}

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

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { BaseField, FieldCreationSchemaObject, FieldOptions, FieldValidator } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
+import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailField, SerializedPassFailFieldValue } from './typings';
+export interface PassFailFieldOptions extends FieldOptions<PassFailFieldValue> {
+    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 { FieldRenderProps } from '../BaseFormElement';
+import { PassFailField } from './PassFailField';
+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 { IconType } from '@overmap-ai/blocks';
+import { PassFailFieldStatus } from './typings';
+export declare const passFailFieldStatusMapping: Record<PassFailFieldStatus, {
+    label: string;
+    icon: IconType;
+}>;
+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 { UUIDFile } from '../../UUIDFile';
+import { UUIDPromise } from '../../UUIDPromise';
+import { BaseSerializedField } from '../BaseField';
+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,31 +1,25 @@
-import { RiRadioButtonFill } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-import { MultiStringField } from '../MultiStringField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { ReactNode } from 'react';
+import { FieldRenderProps } from '../BaseFormElement';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
 import { SerializedRadioField } from './typings';
-export declare const emptyRadioField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
-};
-export interface RadioFieldConfig extends ChildFieldOptions<string> {
-    options: SelectFieldOption[];
+export interface RadioFieldOptions extends BaseOptionsFieldOptions<string | null> {
 }
-export declare class RadioField extends BaseField<string, "radio"> {
-    readonly options: SelectFieldOption[];
+export declare class RadioField extends BaseOptionsField<"radio", string | null, string | null, RadioField> {
+    readonly type = "radio";
     readonly onlyValidateAfterTouched = false;
     static readonly fieldTypeName = "Option list";
     static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
-    static Icon: typeof RiRadioButtonFill;
-    constructor(config: RadioFieldConfig);
+    constructor(options: RadioFieldOptions);
     serialize(): SerializedRadioField;
-    static deserialize(data: ISerializedField): RadioField;
-    static getFieldCreationSchema(parentPath?: string): {
-        field: MultiStringField;
-        showDirectly: boolean;
-    }[];
-    getInput(props: GetInputProps<this>): React.ReactNode;
+    getOptions(): RadioFieldOptions;
+    duplicate(identifier: string): RadioField;
+    setOptions(options: Partial<RadioFieldOptions>): void;
+    static deserialize(data: SerializedRadioField): RadioField;
+    serializeValue(value: string | null): string | null;
+    deserializeValue(value: string | null): string | null;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string | null;
+    isValueValid(value: unknown): value is string | null;
+    blankValue(): string | null;
+    areValuesEqual(value1: string | null, value2: string | null): boolean;
 }

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

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

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

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

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

@@ -1,21 +1,25 @@
 import { ReactNode } from 'react';
-import { RiFullscreenLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { ComponentProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
 import { SerializedScanField } from './typings';
-export declare const emptyScanField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class ScanField extends BaseField<string, "qr"> {
+export interface ScanFieldOptions extends FieldOptions<string> {
+}
+export declare class ScanField extends BaseField<"qr", string, string, ScanField> {
+    readonly type = "qr";
     static readonly fieldTypeName = "Scan";
     static readonly fieldTypeDescription = "Used for scanning/reading QR and barcodes.";
     readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiFullscreenLine;
-    constructor(options: ChildFieldOptions<string>);
+    constructor(options: ScanFieldOptions);
     serialize(): SerializedScanField;
-    static deserialize(data: ISerializedField): ScanField;
-    getInput(props: ComponentProps<ScanField>): ReactNode;
+    getOptions(): ScanFieldOptions;
+    duplicate(identifier: string): ScanField;
+    setOptions(options: Partial<ScanFieldOptions>): void;
+    static deserialize(data: SerializedScanField): ScanField;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string;
+    isValueValid(value: unknown): value is string;
+    blankValue(): string;
+    areValuesEqual(value1: string, value2: string): boolean;
 }

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

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

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

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

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

@@ -1,25 +1,26 @@
 import { ReactNode } from 'react';
-import { RiMenuFoldLine } from 'react-icons/ri';
-import { BaseSelectField, BaseSelectFieldOptions, SelectFieldOptionValue } from '../BaseSelectField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
 import { SerializedSelectField } from './typings';
-/**
- * The options passed to the constructor of SelectField.
- */
-export type SelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue, "select">, "type">;
-export declare const emptySelectField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
+export type SelectFieldOptions = BaseOptionsFieldOptions<string | null> & {
+    placeholder?: string;
 };
-export declare class SelectField extends BaseSelectField<SelectFieldOptionValue, "select"> {
+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.";
-    static Icon: typeof RiMenuFoldLine;
+    placeholder?: string;
     constructor(options: SelectFieldOptions);
     serialize(): SerializedSelectField;
-    static deserialize(data: ISerializedField): SelectField;
-    getInput(props: GetInputProps<this>): ReactNode;
+    getOptions(): SelectFieldOptions;
+    duplicate(identifier: string): SelectField;
+    setOptions(options: Partial<SelectFieldOptions>): void;
+    static deserialize(data: SerializedSelectField): SelectField;
+    serializeValue(value: string | null): string | null;
+    deserializeValue(value: string | null): string | null;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string | null;
+    isValueValid(value: unknown): value is string | null;
+    blankValue(): string | null;
+    areValuesEqual(value1: string | null, value2: string | null): boolean;
 }

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

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

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

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

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

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

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

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

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

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

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

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