@overmap-ai/forms 1.1.4 → 1.1.5-fields-json-types.1

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

@@ -1,18 +1,20 @@
+import { JSONMultiSelectField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedMultiSelectField } from './typings';
-export type MultiSelectFieldOptions = BaseOptionsFieldOptions & {
-    placeholder?: string;
-};
+import { BaseOptionsField } from '../BaseOptionsField';
+import { MultiSelectFieldConfig, MultiSelectFieldOptions } from './typings';
 export declare class MultiSelectField extends BaseOptionsField<"multi-select", string[], string[], MultiSelectField> {
     readonly type = "multi-select";
     placeholder?: string;
     constructor(options: MultiSelectFieldOptions);
-    serialize(): SerializedMultiSelectField;
+    serialize(): JSONMultiSelectField;
+    config(): MultiSelectFieldConfig;
     getOptions(): MultiSelectFieldOptions;
     duplicate(identifier: string): MultiSelectField;
     setOptions(options: Partial<MultiSelectFieldOptions>): void;
-    static deserialize(data: SerializedMultiSelectField): MultiSelectField;
+    static deserialize(data: JSONMultiSelectField): MultiSelectField;
+    static fromConfig(config: MultiSelectFieldConfig): MultiSelectField;
+    static deserializeConfig(data: JSONMultiSelectField): MultiSelectFieldConfig;
+    static serializeConfig(data: MultiSelectFieldConfig): JSONMultiSelectField;
     serializeValue(value: string[]): string[];
     deserializeValue(value: string[]): string[];
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './MultiSelectField';
-export * from './MultiSelectFieldInput';
 export type * from './typings';

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

@@ -1,4 +1,7 @@
-import { BaseSerializedOptionsField } from '../BaseOptionsField';
-export interface SerializedMultiSelectField extends BaseSerializedOptionsField<"multi-select"> {
+import { BaseOptionsFieldConfig, BaseOptionsFieldOptions } from '../BaseOptionsField';
+export interface MultiSelectFieldConfig extends BaseOptionsFieldConfig<"multi-select"> {
     placeholder?: string;
 }
+export type MultiSelectFieldOptions = BaseOptionsFieldOptions & {
+    placeholder?: string;
+};

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

@@ -1,26 +1,26 @@
+import { JSONMultiStringField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
-import { SerializedMultiStringField } from './typings';
-export interface MultiStringFieldOptions extends FieldOptions {
-    minimum_length?: number;
-    maximum_length?: number;
-    placeholder?: string;
-}
+import { BaseField, FieldValidator } from '../BaseField';
+import { MultiStringFieldConfig, MultiStringFieldOptions } from './typings';
 export declare class MultiStringField extends BaseField<"multi-string", string[], string[], MultiStringField> {
     readonly type = "multi-string";
-    minLength: number;
-    maxLength: number;
-    placeholder: string;
+    minimumLength?: number;
+    maximumLength?: number;
+    placeholder?: string;
     constructor(options: MultiStringFieldOptions);
     render(): ReactNode;
-    serialize(): SerializedMultiStringField;
+    serialize(): JSONMultiStringField;
+    config(): MultiStringFieldConfig;
     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;
+    static deserialize(data: JSONMultiStringField): MultiStringField;
+    static fromConfig(config: MultiStringFieldConfig): MultiStringField;
+    static deserializeConfig(data: JSONMultiStringField): MultiStringFieldConfig;
+    static serializeConfig(data: MultiStringFieldConfig): JSONMultiStringField;
     isSerializedValue(value: unknown): value is string[];
     isValue(value: unknown): value is string[];
     blankValue(): string[];

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

@@ -1,3 +1,2 @@
 export * from './MultiStringField';
-export * from './MultiStringFieldInput';
 export type * from './typings';

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

@@ -1,6 +1,11 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedMultiStringField extends BaseSerializedField<"multi-string"> {
-    minimum_length?: number;
-    maximum_length: number;
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface MultiStringFieldConfig extends BaseFieldConfig<"multi-string"> {
+    minimumLength?: number;
+    maximumLength?: number;
+    placeholder?: string;
+}
+export interface MultiStringFieldOptions extends BaseFieldOptions {
+    minimumLength?: number;
+    maximumLength?: number;
     placeholder?: string;
 }

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

@@ -1,22 +1,17 @@
+import { JSONNumberField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { BaseField, FieldValidator } from '../BaseField';
 import { BooleanField } from '../BooleanField';
-import { SerializedNumberField } from './typings';
+import { NumberFieldConfig, NumberFieldOptions } from './typings';
 export type NumberRange = {
     to: number | null;
     from: number | null;
 };
-export interface NumberFieldOptions extends FieldOptions {
-    maximum?: number;
-    minimum?: number;
-    integers?: boolean;
-    placeholder?: string;
-}
 export declare class NumberField extends BaseField<"number", number | null, number | null, NumberField> {
     readonly type = "number";
-    minimum: number | undefined;
-    maximum: number | undefined;
-    integers: boolean;
+    minimum?: number;
+    maximum?: number;
+    integers?: boolean;
     placeholder?: string;
     constructor(options: NumberFieldOptions);
     static getFieldCreationSchema(parentPath?: string): ({
@@ -27,11 +22,15 @@ export declare class NumberField extends BaseField<"number", number | null, numb
         showDirectly: boolean;
     })[];
     getFieldValidators(): FieldValidator<number | null>[];
-    serialize(): SerializedNumberField;
+    serialize(): JSONNumberField;
+    config(): NumberFieldConfig;
     getOptions(): NumberFieldOptions;
     duplicate(identifier: string): NumberField;
     setOptions(options: Partial<NumberFieldOptions>): void;
-    static deserialize(data: SerializedNumberField): NumberField;
+    static deserialize(data: JSONNumberField): NumberField;
+    static fromConfig(config: NumberFieldConfig): NumberField;
+    static deserializeConfig(data: JSONNumberField): NumberFieldConfig;
+    static serializeConfig(data: NumberFieldConfig): JSONNumberField;
     serializeValue(value: number | null): number | null;
     deserializeValue(value: number | null): number | null;
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './NumberField';
-export * from './NumberFieldInput';
 export type * from './typings';

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

@@ -1,7 +1,13 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedNumberField extends BaseSerializedField<"number"> {
-    minimum: number | undefined;
-    maximum: number | undefined;
-    integers: boolean;
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface NumberFieldConfig extends BaseFieldConfig<"number"> {
+    maximum?: number;
+    minimum?: number;
+    integers?: boolean;
+    placeholder?: string;
+}
+export interface NumberFieldOptions extends BaseFieldOptions {
+    maximum?: number;
+    minimum?: number;
+    integers?: boolean;
     placeholder?: string;
 }

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

@@ -1,12 +1,9 @@
+import { JSONOTPField, OTPFieldValidationType } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { BaseField, FieldValidator } from '../BaseField';
 import { NumberField } from '../NumberField';
 import { SelectField } from '../SelectField';
-import { OTPFieldValidationType, SerializedOTPField } from './typings';
-export interface OTPFieldOptions extends FieldOptions {
-    length: number;
-    validationType: OTPFieldValidationType;
-}
+import { OTPFieldConfig, OTPFieldOptions } from './typings';
 export declare class OTPField extends BaseField<"otp", string, string, OTPField> {
     readonly type = "otp";
     length: number;
@@ -20,11 +17,15 @@ export declare class OTPField extends BaseField<"otp", string, string, OTPField>
         showDirectly: boolean;
     })[];
     getFieldValidators(): FieldValidator<string>[];
-    serialize(): SerializedOTPField;
+    serialize(): JSONOTPField;
+    config(): OTPFieldConfig;
     getOptions(): OTPFieldOptions;
     duplicate(identifier: string): OTPField;
     setOptions(options: Partial<OTPFieldOptions>): void;
-    static deserialize(data: SerializedOTPField): OTPField;
+    static deserialize(data: JSONOTPField): OTPField;
+    static fromConfig(config: OTPFieldConfig): OTPField;
+    static deserializeConfig(data: JSONOTPField): OTPFieldConfig;
+    static serializeConfig(data: OTPFieldConfig): JSONOTPField;
     serializeValue(value: string): string;
     deserializeValue(value: string): string;
     render(): ReactNode;

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

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

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

@@ -1,8 +1,10 @@
-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"> {
+import { OTPFieldValidationType } from '@adrekic/fieldsjson';
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface OTPFieldConfig extends BaseFieldConfig<"otp"> {
+    length: number;
+    validationType: OTPFieldValidationType;
+}
+export interface OTPFieldOptions extends BaseFieldOptions {
     length: number;
     validationType: OTPFieldValidationType;
 }

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

@@ -1,29 +1,31 @@
+import { JSONPassFailField, JSONPassFailFieldValue, PassFailFieldStatus } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldCreationSchemaObject, FieldOptions, FieldValidator } from '../BaseField';
-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> {
+import { BaseField, FieldCreationSchemaObject, FieldValidator } from '../BaseField';
+import { PassFailFieldConfig, PassFailFieldOptions, PassFailFieldValue } from './typings';
+export declare class PassFailField extends BaseField<"pass-fail", PassFailFieldValue, JSONPassFailFieldValue, PassFailField> {
     readonly type = "pass-fail";
     showNotesAndFilesOn: PassFailFieldStatus[];
     constructor(options: PassFailFieldOptions);
     static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];
-    serialize(): SerializedPassFailField;
+    serialize(): JSONPassFailField;
+    config(): PassFailFieldConfig;
     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;
+    static deserialize(data: JSONPassFailField): PassFailField;
+    static fromConfig(config: PassFailFieldConfig): PassFailField;
+    static deserializeConfig(data: JSONPassFailField): PassFailFieldConfig;
+    static serializeConfig(data: PassFailFieldConfig): JSONPassFailField;
+    serializeValue(value: PassFailFieldValue): JSONPassFailFieldValue;
+    deserializeValue(value: JSONPassFailFieldValue): PassFailFieldValue;
     render(): ReactNode;
-    isSerializedValue(value: unknown): value is SerializedPassFailFieldValue;
+    isSerializedValue(value: unknown): value is JSONPassFailFieldValue;
     isValue(value: unknown): value is PassFailFieldValue;
     areValuesEqual(value1: PassFailFieldValue, value2: PassFailFieldValue): boolean;
     blankValue(): PassFailFieldValue;
     cleanValue(value: PassFailFieldValue): PassFailFieldValue;
-    cleanSerializedValue(value: SerializedPassFailFieldValue): SerializedPassFailFieldValue;
-    blankSerializedValue(): SerializedPassFailFieldValue;
-    areSerializedValuesEqual(value1: SerializedPassFailFieldValue, value2: SerializedPassFailFieldValue): boolean;
+    cleanSerializedValue(value: JSONPassFailFieldValue): JSONPassFailFieldValue;
+    blankSerializedValue(): JSONPassFailFieldValue;
+    areSerializedValuesEqual(value1: JSONPassFailFieldValue, value2: JSONPassFailFieldValue): boolean;
 }

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

@@ -1,5 +1,5 @@
+import { PassFailFieldStatus } from '@adrekic/fieldsjson';
 import { IconComponent } from '@overmap-ai/blocks';
-import { PassFailFieldStatus } from './typings';
 export declare const passFailFieldStatusMapping: Record<PassFailFieldStatus, {
     label: string;
     icon: IconComponent;

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

@@ -1,5 +1,4 @@
 export * from './constants';
 export * from './PassFailField';
-export * from './PassFailFieldInput';
 export type * from './typings';
 export * from './utils';

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

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

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

@@ -1,8 +1,9 @@
-import { PassFailFieldStatus, PassFailFieldValue, SerializedPassFailFieldValue } from './typings';
+import { JSONPassFailFieldValue, PassFailFieldStatus } from '@adrekic/fieldsjson';
+import { PassFailFieldValue } from './typings';
 export declare const isPassFailFieldStatus: (value: unknown) => value is PassFailFieldStatus;
-export declare const isSerializedPassFailFieldValue: (value: unknown) => value is SerializedPassFailFieldValue;
+export declare const isJSONPassFailFieldValue: (value: unknown) => value is JSONPassFailFieldValue;
 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 serializePassFailFieldValue: (value: PassFailFieldValue) => JSONPassFailFieldValue;
+export declare const deserializePassFailFieldValue: (value: JSONPassFailFieldValue) => PassFailFieldValue;
 export declare const arePassFieldValuesEqual: (value1: PassFailFieldValue, value2: PassFailFieldValue) => boolean;
-export declare const areSerializedPassFailFieldValuesEqual: (value1: SerializedPassFailFieldValue, value2: SerializedPassFailFieldValue) => boolean;
+export declare const areJSONPassFailFieldValuesEqual: (value1: JSONPassFailFieldValue, value2: JSONPassFailFieldValue) => boolean;

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

@@ -1,16 +1,19 @@
+import { JSONRadioField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedRadioField } from './typings';
-export interface RadioFieldOptions extends BaseOptionsFieldOptions {
-}
+import { BaseOptionsField } from '../BaseOptionsField';
+import { RadioFieldConfig, RadioFieldOptions } from './typings';
 export declare class RadioField extends BaseOptionsField<"radio", string | null, string | null, RadioField> {
     readonly type = "radio";
     constructor(options: RadioFieldOptions);
-    serialize(): SerializedRadioField;
+    serialize(): JSONRadioField;
+    config(): RadioFieldConfig;
     getOptions(): RadioFieldOptions;
     duplicate(identifier: string): RadioField;
     setOptions(options: Partial<RadioFieldOptions>): void;
-    static deserialize(data: SerializedRadioField): RadioField;
+    static deserialize(data: JSONRadioField): RadioField;
+    static fromConfig(config: RadioFieldConfig): RadioField;
+    static deserializeConfig(data: JSONRadioField): RadioFieldConfig;
+    static serializeConfig(data: RadioFieldConfig): JSONRadioField;
     serializeValue(value: string | null): string | null;
     deserializeValue(value: string | null): string | null;
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './RadioField';
-export * from './RadioFieldInput';
 export type * from './typings';

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

@@ -1,3 +1,5 @@
-import { BaseSerializedOptionsField } from '../BaseOptionsField';
-export interface SerializedRadioField extends BaseSerializedOptionsField<"radio"> {
+import { BaseOptionsFieldConfig, BaseOptionsFieldOptions } from '../BaseOptionsField';
+export interface RadioFieldConfig extends BaseOptionsFieldConfig<"radio"> {
+}
+export interface RadioFieldOptions extends BaseOptionsFieldOptions {
 }

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

@@ -1,10 +1,8 @@
+import { JSONRatingField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { BaseField, FieldValidator } from '../BaseField';
 import { NumberField } from '../NumberField';
-import { SerializedRatingField } from './typings';
-export interface RatingFieldOptions extends FieldOptions {
-    maxRating: number;
-}
+import { RatingFieldConfig, RatingFieldOptions } from './typings';
 export declare class RatingField extends BaseField<"rating", number | null, number | null, RatingField> {
     readonly type = "rating";
     maxRating: number;
@@ -14,11 +12,15 @@ export declare class RatingField extends BaseField<"rating", number | null, numb
         showDirectly: boolean;
     }[];
     getFieldValidators(): FieldValidator<number | null>[];
-    serialize(): SerializedRatingField;
+    serialize(): JSONRatingField;
+    config(): RatingFieldConfig;
     getOptions(): RatingFieldOptions;
     duplicate(identifier: string): RatingField;
     setOptions(options: Partial<RatingFieldOptions>): void;
-    static deserialize(data: SerializedRatingField): RatingField;
+    static deserialize(data: JSONRatingField): RatingField;
+    static fromConfig(config: RatingFieldConfig): RatingField;
+    static deserializeConfig(data: JSONRatingField): RatingFieldConfig;
+    static serializeConfig(data: RatingFieldConfig): JSONRatingField;
     serializeValue(value: number | null): number | null;
     deserializeValue(value: number | null): number | null;
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './RatingField';
-export * from './RatingFieldInput';
 export type * from './typings';

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

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

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

@@ -1,16 +1,19 @@
+import { JSONScanField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions } from '../BaseField';
-import { SerializedScanField } from './typings';
-export interface ScanFieldOptions extends FieldOptions {
-}
+import { BaseField } from '../BaseField';
+import { ScanFieldConfig, ScanFieldOptions } from './typings';
 export declare class ScanField extends BaseField<"qr", string, string, ScanField> {
     readonly type = "qr";
     constructor(options: ScanFieldOptions);
-    serialize(): SerializedScanField;
+    serialize(): JSONScanField;
+    config(): ScanFieldConfig;
     getOptions(): ScanFieldOptions;
     duplicate(identifier: string): ScanField;
     setOptions(options: Partial<ScanFieldOptions>): void;
-    static deserialize(data: SerializedScanField): ScanField;
+    static deserialize(data: JSONScanField): ScanField;
+    static fromConfig(config: ScanFieldConfig): ScanField;
+    static deserializeConfig(data: JSONScanField): ScanFieldConfig;
+    static serializeConfig(data: ScanFieldConfig): JSONScanField;
     serializeValue(value: string): string;
     deserializeValue(value: string): string;
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './ScanField';
-export * from './ScanFieldInput';
 export type * from './typings';

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

@@ -1,3 +1,5 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedScanField extends BaseSerializedField<"qr"> {
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface ScanFieldConfig extends BaseFieldConfig<"qr"> {
+}
+export interface ScanFieldOptions extends BaseFieldOptions {
 }

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

@@ -1,18 +1,20 @@
+import { JSONSelectField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedSelectField } from './typings';
-export type SelectFieldOptions = BaseOptionsFieldOptions & {
-    placeholder?: string;
-};
+import { BaseOptionsField } from '../BaseOptionsField';
+import { SelectFieldConfig, SelectFieldOptions } from './typings';
 export declare class SelectField extends BaseOptionsField<"select", string | null, string | null, SelectField> {
     readonly type = "select";
     placeholder?: string;
     constructor(options: SelectFieldOptions);
-    serialize(): SerializedSelectField;
+    serialize(): JSONSelectField;
+    config(): SelectFieldConfig;
     getOptions(): SelectFieldOptions;
     duplicate(identifier: string): SelectField;
     setOptions(options: Partial<SelectFieldOptions>): void;
-    static deserialize(data: SerializedSelectField): SelectField;
+    static deserialize(data: JSONSelectField): SelectField;
+    static fromConfig(config: SelectFieldConfig): SelectField;
+    static deserializeConfig(data: JSONSelectField): SelectFieldConfig;
+    static serializeConfig(data: SelectFieldConfig): JSONSelectField;
     serializeValue(value: string | null): string | null;
     deserializeValue(value: string | null): string | null;
     render(): ReactNode;

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

@@ -1,3 +1,2 @@
 export * from './SelectField';
-export * from './SelectFieldInput';
 export type * from './typings';

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

@@ -1,4 +1,7 @@
-import { BaseSerializedOptionsField } from '../BaseOptionsField';
-export interface SerializedSelectField extends BaseSerializedOptionsField<"select"> {
+import { BaseOptionsFieldConfig, BaseOptionsFieldOptions } from '../BaseOptionsField';
+export interface SelectFieldConfig extends BaseOptionsFieldConfig<"select"> {
     placeholder?: string;
 }
+export type SelectFieldOptions = BaseOptionsFieldOptions & {
+    placeholder?: string;
+};

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

@@ -1,15 +1,18 @@
+import { JSONStringField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
-import { SerializedStringField } from './typings';
-export interface StringFieldOptions extends BaseStringFieldOptions {
-}
+import { BaseStringField } from '../BaseStringField';
+import { StringFieldConfig, StringFieldOptions } from './typings';
 export declare class StringField extends BaseStringField<"string", StringField> {
     readonly type = "string";
     constructor(options: StringFieldOptions);
-    serialize(): SerializedStringField;
+    serialize(): JSONStringField;
+    config(): StringFieldConfig;
     getOptions(): StringFieldOptions;
     duplicate(identifier: string): StringField;
     setOptions(options: Partial<StringFieldOptions>): void;
-    static deserialize(data: SerializedStringField): StringField;
+    static deserialize(data: JSONStringField): StringField;
+    static fromConfig(config: StringFieldConfig): StringField;
+    static deserializeConfig(data: JSONStringField): StringFieldConfig;
+    static serializeConfig(data: StringFieldConfig): JSONStringField;
     render(): ReactNode;
 }

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

@@ -1,4 +1,2 @@
-export * from './constants';
 export * from './StringField';
-export * from './StringFieldInput';
 export type * from './typings';

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

@@ -1,3 +1,5 @@
-import { BaseSerializedStringField } from '../BaseStringField';
-export interface SerializedStringField extends BaseSerializedStringField<"string"> {
+import { BaseStringFieldConfig, BaseStringFieldOptions } from '../BaseStringField';
+export interface StringFieldConfig extends BaseStringFieldConfig<"string"> {
+}
+export interface StringFieldOptions extends BaseStringFieldOptions {
 }

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

@@ -1,14 +1,18 @@
+import { JSONTextField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
-import { SerializedTextField } from './typings';
-export type TextFieldOptions = BaseStringFieldOptions;
+import { BaseStringField } from '../BaseStringField';
+import { TextFieldConfig, TextFieldOptions } from './typings';
 export declare class TextField extends BaseStringField<"text", TextField> {
     readonly type = "text";
     constructor(options: TextFieldOptions);
-    serialize(): SerializedTextField;
+    serialize(): JSONTextField;
+    config(): TextFieldConfig;
     getOptions(): TextFieldOptions;
     duplicate(identifier: string): TextField;
     setOptions(options: Partial<TextFieldOptions>): void;
-    static deserialize(data: SerializedTextField): TextField;
+    static deserialize(data: JSONTextField): TextField;
+    static fromConfig(config: TextFieldConfig): TextField;
+    static deserializeConfig(data: JSONTextField): TextFieldConfig;
+    static serializeConfig(data: TextFieldConfig): JSONTextField;
     render(): ReactNode;
 }

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

@@ -1,4 +1,2 @@
-export * from './constants';
 export * from './TextField';
-export * from './TextFieldInput';
 export type * from './typings';

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

@@ -1,3 +1,4 @@
-import { BaseSerializedStringField } from '../BaseStringField';
-export interface SerializedTextField extends BaseSerializedStringField<"text"> {
+import { BaseStringFieldConfig, BaseStringFieldOptions } from '../BaseStringField';
+export interface TextFieldConfig extends BaseStringFieldConfig<"text"> {
 }
+export type TextFieldOptions = BaseStringFieldOptions;

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

@@ -1,11 +1,15 @@
+import { JSONTimeField, Time } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions } from '../BaseField';
-import { SerializedTimeField, Time } from './typings';
-export type TimeFieldOptions = FieldOptions;
+import { BaseField } from '../BaseField';
+import { TimeFieldConfig, TimeFieldOptions } from './typings';
 export declare class TimeField extends BaseField<"time", Time | null, Time | null, TimeField> {
     readonly type = "time";
     constructor(config: TimeFieldOptions);
-    static deserialize(data: SerializedTimeField): TimeField;
+    static deserialize(data: JSONTimeField): TimeField;
+    static fromConfig(config: TimeFieldConfig): TimeField;
+    static deserializeConfig(data: JSONTimeField): TimeFieldConfig;
+    static serializeConfig(data: TimeFieldConfig): JSONTimeField;
+    config(): TimeFieldConfig;
     getOptions(): TimeFieldOptions;
     duplicate(identifier: string): TimeField;
     setOptions(options: Partial<TimeFieldOptions>): void;

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

@@ -1,5 +1,5 @@
+import { Time } from '@adrekic/fieldsjson';
 import { InputSize } from '@overmap-ai/blocks';
-import { Time } from './typings';
 export interface TimeFieldControlProps {
     value?: Time | null;
     onChange: (value: Time | null) => void;