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

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

@@ -1,11 +1,9 @@
+import { JSONTextCondition, JSONTextConditionModifier } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { TextField, ValueOfField } from '../../fields';
-import { BaseCondition, BaseConditionOptions, ConditionRenderProps } from '../BaseCondition';
-import { SerializedTextCondition, TextConditionModifiers } from './typings';
-export interface TextFieldConditionOptions extends BaseConditionOptions<TextField, string, TextConditionModifiers> {
-    field: TextField;
-}
-export declare class TextFieldCondition extends BaseCondition<TextField, ValueOfField<TextField>, string, string, TextConditionModifiers, TextFieldCondition> {
+import { BaseCondition, ConditionRenderProps } from '../BaseCondition';
+import { TextFieldConditionOptions } from './typings';
+export declare class TextFieldCondition extends BaseCondition<TextField, ValueOfField<TextField>, string, string, JSONTextConditionModifier, TextFieldCondition> {
     readonly modifiers: {
         equals: import('../..').FieldConditionModifierConfig<string, string, string, string, string, string>;
         notEquals: import('../..').FieldConditionModifierConfig<string, string, string, string, string, string>;
@@ -13,6 +11,6 @@ export declare class TextFieldCondition extends BaseCondition<TextField, ValueOf
         excludes: import('../..').FieldConditionModifierConfig<string, string, string, string, string, string>;
     };
     constructor(options: TextFieldConditionOptions);
-    static deserialize(serializedCondition: SerializedTextCondition, field: TextField): TextFieldCondition;
+    static deserialize(serializedCondition: JSONTextCondition, field: TextField): TextFieldCondition;
     render(props: ConditionRenderProps<TextFieldCondition>): ReactNode;
 }

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

@@ -1,4 +1,6 @@
-import { TextField, TypeOfField } from '../../fields';
-import { BaseSerializedCondition } from '../BaseCondition';
-export type TextConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
-export type SerializedTextCondition = BaseSerializedCondition<TypeOfField<TextField>, string, TextConditionModifiers>;
+import { JSONTextConditionModifier } from '@adrekic/fieldsjson';
+import { TextField } from '../../fields';
+import { BaseConditionOptions } from '../BaseCondition';
+export interface TextFieldConditionOptions extends BaseConditionOptions<TextField, string, JSONTextConditionModifier> {
+    field: TextField;
+}

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

@@ -1,10 +1,9 @@
+import { JSONTimeCondition, JSONTimeConditionModifier, Time, TimeRange } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { Time, TimeField, TimeRange, ValueOfField } from '../../fields';
-import { BaseCondition, BaseConditionOptions, ConditionRenderProps } from '../BaseCondition';
-import { SerializedTimeCondition, TimeConditionModifiers } from './typings';
-export interface TimeFieldConditionOptions extends BaseConditionOptions<TimeField, Time | TimeRange, TimeConditionModifiers> {
-}
-export declare class TimeFieldCondition extends BaseCondition<TimeField, ValueOfField<TimeField>, Time | TimeRange, Time | TimeRange, TimeConditionModifiers, TimeFieldCondition> {
+import { TimeField, ValueOfField } from '../../fields';
+import { BaseCondition, ConditionRenderProps } from '../BaseCondition';
+import { TimeFieldConditionOptions } from './typings';
+export declare class TimeFieldCondition extends BaseCondition<TimeField, ValueOfField<TimeField>, Time | TimeRange, Time | TimeRange, JSONTimeConditionModifier, TimeFieldCondition> {
     readonly modifiers: {
         equals: import('../..').FieldConditionModifierConfig<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange | null, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`>;
         notEquals: import('../..').FieldConditionModifierConfig<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`>;
@@ -14,6 +13,6 @@ export declare class TimeFieldCondition extends BaseCondition<TimeField, ValueOf
         notIn: import('../..').FieldConditionModifierConfig<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | TimeRange, `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, TimeRange, TimeRange>;
     };
     constructor(options: TimeFieldConditionOptions);
-    static deserialize(serializedCondition: SerializedTimeCondition, field: TimeField): TimeFieldCondition;
+    static deserialize(serializedCondition: JSONTimeCondition, field: TimeField): TimeFieldCondition;
     render(props: ConditionRenderProps<TimeFieldCondition>): ReactNode;
 }

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

@@ -1,4 +1,5 @@
-import { Time, TimeField, TimeRange, TypeOfField } from '../../fields';
-import { BaseSerializedCondition } from '../BaseCondition';
-export type TimeConditionModifiers = "equals" | "notEquals" | "before" | "after" | "in" | "notIn";
-export type SerializedTimeCondition = BaseSerializedCondition<TypeOfField<TimeField>, Time | TimeRange, TimeConditionModifiers>;
+import { JSONTimeConditionModifier, Time, TimeRange } from '@adrekic/fieldsjson';
+import { TimeField } from '../../fields';
+import { BaseConditionOptions } from '../BaseCondition';
+export interface TimeFieldConditionOptions extends BaseConditionOptions<TimeField, Time | TimeRange, JSONTimeConditionModifier> {
+}

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

@@ -1,10 +1,9 @@
+import { JSONURLCondition, JSONURLConditionModifier } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { URLField, ValueOfField } from '../../fields';
-import { BaseCondition, BaseConditionOptions, ConditionRenderProps } from '../BaseCondition';
-import { SerializedURLCondition, URLConditionModifiers } from './typings';
-export interface URLFieldConditionOptions extends BaseConditionOptions<URLField, string, URLConditionModifiers> {
-}
-export declare class URLFieldCondition extends BaseCondition<URLField, string, string, string, URLConditionModifiers, URLFieldCondition> {
+import { BaseCondition, ConditionRenderProps } from '../BaseCondition';
+import { URLFieldConditionOptions } from './typings';
+export declare class URLFieldCondition extends BaseCondition<URLField, string, string, string, JSONURLConditionModifier, URLFieldCondition> {
     readonly modifiers: {
         equals: import('../..').FieldConditionModifierConfig<string, string, string, string, string, string>;
         notEquals: import('../..').FieldConditionModifierConfig<string, string, string, string, string, string>;
@@ -13,6 +12,6 @@ export declare class URLFieldCondition extends BaseCondition<URLField, string, s
     };
     constructor(options: URLFieldConditionOptions);
     transformValue(value: ValueOfField<URLField>): string;
-    static deserialize(serializedCondition: SerializedURLCondition, field: URLField): URLFieldCondition;
+    static deserialize(serializedCondition: JSONURLCondition, field: URLField): URLFieldCondition;
     render(props: ConditionRenderProps<URLFieldCondition>): ReactNode;
 }

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

@@ -1,4 +1,5 @@
-import { TypeOfField, URLField } from '../../fields';
-import { BaseSerializedCondition } from '../BaseCondition';
-export type URLConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
-export type SerializedURLCondition = BaseSerializedCondition<TypeOfField<URLField>, string, URLConditionModifiers>;
+import { JSONURLConditionModifier } from '@adrekic/fieldsjson';
+import { URLField } from '../../fields';
+import { BaseConditionOptions } from '../BaseCondition';
+export interface URLFieldConditionOptions extends BaseConditionOptions<URLField, string, JSONURLConditionModifier> {
+}

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

@@ -1,17 +1,16 @@
+import { JSONUploadCondition, JSONUploadConditionModifier } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { UploadField, ValueOfField } from '../../fields';
 import { UUIDFile } from '../../UUIDFile';
 import { UUIDPromise } from '../../UUIDPromise';
-import { BaseCondition, BaseConditionOptions, ConditionRenderProps } from '../BaseCondition';
-import { SerializedUploadCondition, UploadConditionModifiers } from './typings';
-export interface UploadFieldConditionOptions extends BaseConditionOptions<UploadField, boolean, UploadConditionModifiers> {
-}
-export declare class UploadFieldCondition extends BaseCondition<UploadField, ValueOfField<UploadField>, boolean, boolean, UploadConditionModifiers, UploadFieldCondition> {
+import { BaseCondition, ConditionRenderProps } from '../BaseCondition';
+import { UploadFieldConditionOptions } from './typings';
+export declare class UploadFieldCondition extends BaseCondition<UploadField, ValueOfField<UploadField>, boolean, boolean, JSONUploadConditionModifier, UploadFieldCondition> {
     readonly modifiers: {
         equals: import('../..').FieldConditionModifierConfig<(UUIDFile | UUIDPromise<UUIDFile>)[], boolean, boolean, UUIDFile[], boolean, boolean>;
         notEquals: import('../..').FieldConditionModifierConfig<(UUIDFile | UUIDPromise<UUIDFile>)[], boolean, boolean, UUIDFile[], boolean, boolean>;
     };
     constructor(options: UploadFieldConditionOptions);
-    static deserialize(serializedCondition: SerializedUploadCondition, field: UploadField): UploadFieldCondition;
+    static deserialize(serializedCondition: JSONUploadCondition, field: UploadField): UploadFieldCondition;
     render(props: ConditionRenderProps<UploadFieldCondition>): ReactNode;
 }

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

@@ -1,3 +1,3 @@
-export type * from './typings';
 export * from './UploadFieldCondition';
 export * from './UploadFieldConditionCell';
+export type * from './typings';

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

@@ -1,4 +1,5 @@
-import { TypeOfField, UploadField } from '../../fields';
-import { BaseSerializedCondition } from '../BaseCondition';
-export type UploadConditionModifiers = "equals" | "notEquals";
-export type SerializedUploadCondition = BaseSerializedCondition<TypeOfField<UploadField>, boolean, UploadConditionModifiers>;
+import { JSONUploadConditionModifier } from '@adrekic/fieldsjson';
+import { UploadField } from '../../fields';
+import { BaseConditionOptions } from '../BaseCondition';
+export interface UploadFieldConditionOptions extends BaseConditionOptions<UploadField, boolean, JSONUploadConditionModifier> {
+}

package/dist/form/conditions/components/SelectFieldOptionMultiSelectGroup.d.ts

@@ -1,5 +1,5 @@
+import { SelectFieldOption } from '@adrekic/fieldsjson';
 import { MenuMultiSelectGroupProps } from '@overmap-ai/blocks';
-import { SelectFieldOption } from '../../fields';
 export interface SelectFieldOptionMultiSelectGroupProps extends MenuMultiSelectGroupProps<string> {
     selectFieldOptions: SelectFieldOption[];
 }

package/dist/form/conditions/components/SelectFieldOptionSelectGroup.d.ts

@@ -1,5 +1,5 @@
+import { SelectFieldOption } from '@adrekic/fieldsjson';
 import { MenuSelectGroupProps } from '@overmap-ai/blocks';
-import { SelectFieldOption } from '../../fields';
 export type SelectFieldOptionSelectGroupProps = MenuSelectGroupProps<string> & {
     selectFieldOptions: SelectFieldOption[];
 };

package/dist/form/conditions/components/TimeInputPopover.d.ts

@@ -1,6 +1,6 @@
+import { Time } from '@adrekic/fieldsjson';
 import { Popover } from '@overmap-ai/blocks';
 import { ComponentPropsWithoutRef } from 'react';
-import { Time } from '../../fields';
 interface TimeInputPopoverProps extends ComponentPropsWithoutRef<typeof Popover.Root>, ComponentPropsWithoutRef<typeof Popover.Content> {
     value?: Time | null;
     onValueChange: (value: Time | null) => void;

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

@@ -1,23 +1,22 @@
 import { AnyCondition } from './BaseCondition';
-import { BooleanFieldCondition, SerializedBooleanCondition } from './BooleanFieldCondition';
-import { CheckboxListFieldCondition, SerializedCheckboxListCondition } from './CheckboxListFieldCondition';
-import { DateFieldCondition, SerializedDateCondition } from './DateFieldCondition';
-import { MultiSelectFieldCondition, SerializedMultiSelectCondition } from './MultiSelectFieldCondition';
-import { MultiStringFieldCondition, SerializedMultiStringCondition } from './MultiStringFieldCondition';
-import { NumberFieldCondition, SerializedNumberCondition } from './NumberFieldCondition';
-import { OTPFieldCondition, SerializedOTPCondition } from './OTPFieldCondition';
-import { PassFailFieldCondition, SerializedPassFailFieldCondition } from './PassFailFieldCondition';
-import { RadioFieldCondition, SerializedRadioCondition } from './RadioFieldCondition';
-import { RatingFieldCondition, SerializedRatingCondition } from './RatingFieldCondition';
-import { ScanFieldCondition, SerializedScanCondition } from './ScanFieldCondition';
-import { SelectFieldCondition, SerializedSelectCondition } from './SelectFieldCondition';
-import { SerializedStringCondition, StringFieldCondition } from './StringFieldCondition';
-import { SerializedTextCondition, TextFieldCondition } from './TextFieldCondition';
-import { SerializedTimeCondition, TimeFieldCondition } from './TimeFieldCondition';
-import { SerializedUploadCondition, UploadFieldCondition } from './UploadFieldCondition';
-import { SerializedURLCondition, URLFieldCondition } from './URLFieldCondition';
+import { BooleanFieldCondition } from './BooleanFieldCondition';
+import { CheckboxListFieldCondition } from './CheckboxListFieldCondition';
+import { DateFieldCondition } from './DateFieldCondition';
+import { MultiSelectFieldCondition } from './MultiSelectFieldCondition';
+import { MultiStringFieldCondition } from './MultiStringFieldCondition';
+import { NumberFieldCondition } from './NumberFieldCondition';
+import { OTPFieldCondition } from './OTPFieldCondition';
+import { PassFailFieldCondition } from './PassFailFieldCondition';
+import { RadioFieldCondition } from './RadioFieldCondition';
+import { RatingFieldCondition } from './RatingFieldCondition';
+import { ScanFieldCondition } from './ScanFieldCondition';
+import { SelectFieldCondition } from './SelectFieldCondition';
+import { StringFieldCondition } from './StringFieldCondition';
+import { TextFieldCondition } from './TextFieldCondition';
+import { TimeFieldCondition } from './TimeFieldCondition';
+import { UploadFieldCondition } from './UploadFieldCondition';
+import { URLFieldCondition } from './URLFieldCondition';
 export type Condition = BooleanFieldCondition | CheckboxListFieldCondition | PassFailFieldCondition | DateFieldCondition | TimeFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | RadioFieldCondition | RatingFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition | URLFieldCondition | OTPFieldCondition;
-export type SerializedCondition = SerializedTextCondition | SerializedBooleanCondition | SerializedNumberCondition | SerializedDateCondition | SerializedTimeCondition | SerializedStringCondition | SerializedURLCondition | SerializedSelectCondition | SerializedMultiStringCondition | SerializedMultiSelectCondition | SerializedUploadCondition | SerializedScanCondition | SerializedRadioCondition | SerializedRatingCondition | SerializedCheckboxListCondition | SerializedPassFailFieldCondition | SerializedOTPCondition;
 export type ConditionClass = typeof BooleanFieldCondition | typeof CheckboxListFieldCondition | typeof PassFailFieldCondition | typeof DateFieldCondition | typeof TimeFieldCondition | typeof MultiSelectFieldCondition | typeof MultiStringFieldCondition | typeof NumberFieldCondition | typeof RadioFieldCondition | typeof RatingFieldCondition | typeof ScanFieldCondition | typeof SelectFieldCondition | typeof StringFieldCondition | typeof TextFieldCondition | typeof UploadFieldCondition | typeof URLFieldCondition | typeof OTPFieldCondition;
 export interface FieldConditionManager<TCondition extends AnyCondition> {
     readonly conditions: Record<string, TCondition[]>;

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

@@ -1,7 +1,8 @@
+import { JSONCondition } from '@adrekic/fieldsjson';
 import { Field } from '../fields';
-import { Condition, SerializedCondition } from './typings';
-export declare const deserializeCondition: (field: Field, serializedCondition: SerializedCondition) => Condition;
-export declare const deserializeConditions: (fields: Field[], serializedConditions: SerializedCondition[]) => Condition[];
-export declare const serializeConditions: (fields: Field[], conditions: Condition[]) => SerializedCondition[];
-export declare const cleanSerializedConditions: (fields: Field[], serializedConditions: SerializedCondition[]) => SerializedCondition[];
+import { Condition } from './typings';
+export declare const deserializeCondition: (field: Field, serializedCondition: JSONCondition) => Condition;
+export declare const deserializeConditions: (fields: Field[], serializedConditions: JSONCondition[]) => Condition[];
+export declare const serializeConditions: (fields: Field[], conditions: Condition[]) => JSONCondition[];
+export declare const cleanSerializedConditions: (fields: Field[], serializedConditions: JSONCondition[]) => JSONCondition[];
 export declare const cleanConditions: (fields: Field[], conditions: Condition[]) => Condition[];

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

@@ -1,16 +1,20 @@
+import { BaseJSONField } from '@adrekic/fieldsjson';
 import { BaseFormElement } from '../BaseFormElement';
 import { FieldError } from '../typings';
-import { BaseSerializedField, FieldOptions, FieldValidator } from './typings';
+import { BaseFieldConfig, BaseFieldOptions, FieldValidator } from './typings';
 export declare abstract class BaseField<TType extends string, TValue, TSerializedValue, This extends BaseField<TType, TValue, TSerializedValue, This>> extends BaseFormElement<TType, This> {
     label: string;
     description: string | null;
     required: boolean;
     image: File | Promise<File> | undefined;
-    protected constructor(options: FieldOptions);
+    protected constructor(options: BaseFieldOptions);
     getError(value: TValue): FieldError | undefined;
-    serialize(): BaseSerializedField<TType>;
-    getOptions(): FieldOptions;
-    setOptions(options: Partial<FieldOptions>): void;
+    serialize(): BaseJSONField<TType>;
+    config(): BaseFieldConfig<TType>;
+    static _deserializeConfig<TType extends string>(serialized: BaseJSONField<TType>): BaseFieldConfig<TType>;
+    static _serializeConfig<TType extends string>(config: BaseFieldConfig<TType>): BaseJSONField<TType>;
+    getOptions(): BaseFieldOptions;
+    setOptions(options: Partial<BaseFieldOptions>): void;
     abstract isSerializedValue(value: unknown): value is TSerializedValue;
     abstract serializeValue(value: TValue): TSerializedValue;
     abstract isValue(value: unknown): value is TValue;

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

@@ -1,12 +1,12 @@
-import { BaseFormElementOptions, BaseSerializedFormElement } from '../BaseFormElement';
+import { BaseFieldElementConfig, BaseFieldElementOptions } from '../BaseFormElement';
 import { AnyField, FieldError } from '../typings';
-export interface BaseSerializedField<TType extends string> extends BaseSerializedFormElement<TType> {
+export interface BaseFieldConfig<TType extends string> extends BaseFieldElementConfig<TType> {
     label: string;
     description?: string | null;
     required: boolean;
     image?: File | Promise<File>;
 }
-export interface FieldOptions extends BaseFormElementOptions {
+export interface BaseFieldOptions extends BaseFieldElementOptions {
     label: string;
     description?: string | null;
     required: boolean;

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

@@ -1,13 +1,17 @@
+import { BaseJSONFieldElement } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { Observable } from '../../Observable';
-import { BaseFormElementOptions, BaseSerializedFormElement } from './typings';
+import { BaseFieldElementConfig, BaseFieldElementOptions } from './typings';
 export declare abstract class BaseFormElement<TType extends string, This extends BaseFormElement<TType, This>> extends Observable<This> {
     abstract readonly type: TType;
     identifier: string;
-    protected constructor(options: BaseFormElementOptions);
-    getOptions(): BaseFormElementOptions;
-    setOptions(options: Partial<BaseFormElementOptions>): void;
+    protected constructor(options: BaseFieldElementOptions);
+    getOptions(): BaseFieldElementOptions;
+    setOptions(options: Partial<BaseFieldElementOptions>): void;
     abstract duplicate(identifier: string): BaseFormElement<TType, This>;
-    serialize(): BaseSerializedFormElement<TType>;
+    serialize(): BaseJSONFieldElement<TType>;
+    config(): BaseFieldElementConfig<TType>;
+    static _deserializeConfig<TType extends string>(serialized: BaseJSONFieldElement<TType>): BaseFieldElementConfig<TType>;
+    static _serializeConfig<TType extends string>(config: BaseFieldElementConfig<TType>): BaseJSONFieldElement<TType>;
     abstract render(): ReactNode;
 }

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

@@ -1,9 +1,9 @@
-export interface BaseFormElementOptions {
+export interface BaseFieldElementConfig<TType extends string> {
     identifier: string;
+    type: TType;
 }
-export interface BaseSerializedFormElement<TType extends string> {
+export interface BaseFieldElementOptions {
     identifier: string;
-    type: TType;
 }
 export interface FieldRenderProps {
 }

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

@@ -1,12 +1,13 @@
-import { BaseField, FieldCreationSchemaObject, FieldOptions } from '../BaseField';
-import { BaseSerializedOptionsField, SelectFieldOption } from './typings';
-export interface BaseOptionsFieldOptions extends FieldOptions {
-    options: string[] | SelectFieldOption[];
-}
+import { BaseJSONOptionsField, SelectFieldOption } from '@adrekic/fieldsjson';
+import { BaseField, FieldCreationSchemaObject } from '../BaseField';
+import { BaseOptionsFieldConfig, BaseOptionsFieldOptions } from './typings';
 export declare abstract class BaseOptionsField<TType extends string, TValue, TSerializedValue, This extends BaseOptionsField<TType, TValue, TSerializedValue, This>> extends BaseField<TType, TValue, TSerializedValue, This> {
     options: SelectFieldOption[];
     protected constructor(options: BaseOptionsFieldOptions);
-    serialize(): BaseSerializedOptionsField<TType>;
+    serialize(): BaseJSONOptionsField<TType>;
+    config(): BaseOptionsFieldConfig<TType>;
+    static _deserializeConfig<TType extends string>(serialized: BaseJSONOptionsField<TType>): BaseOptionsFieldConfig<TType>;
+    static _serializeConfig<TType extends string>(config: BaseOptionsFieldConfig<TType>): BaseJSONOptionsField<TType>;
     getOptions(): BaseOptionsFieldOptions;
     setOptions(options: Partial<BaseOptionsFieldOptions>): void;
     static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];

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

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

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

@@ -1,9 +1,8 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SelectFieldOption {
-    value: string;
-    label: string;
+import { SelectFieldOption } from '@adrekic/fieldsjson';
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface BaseOptionsFieldConfig<TType extends string> extends BaseFieldConfig<TType> {
+    options: string[] | SelectFieldOption[];
 }
-export interface BaseSerializedOptionsField<TType extends string> extends BaseSerializedField<TType> {
-    type: TType;
-    options: SelectFieldOption[];
+export interface BaseOptionsFieldOptions extends BaseFieldOptions {
+    options: string[] | SelectFieldOption[];
 }

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

@@ -0,0 +1,3 @@
+import { SelectFieldOption } from '@adrekic/fieldsjson';
+export declare function normalizeFieldOption(option: string | SelectFieldOption): SelectFieldOption;
+export declare function normalizeFieldOptions(options: (string | SelectFieldOption)[]): SelectFieldOption[];

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

@@ -1,14 +1,10 @@
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { BaseJSONStringField } from '@adrekic/fieldsjson';
+import { BaseField, FieldValidator } from '../BaseField';
 import { NumberField } from '../NumberField';
-import { BaseSerializedStringField } from './typings';
-export interface BaseStringFieldOptions extends FieldOptions {
-    minLength?: number;
-    maxLength?: number;
-    placeholder?: string;
-}
+import { BaseStringFieldConfig, BaseStringFieldOptions } from './typings';
 export declare abstract class BaseStringField<TType extends string, This extends BaseStringField<TType, This>> extends BaseField<TType, string, string, This> {
     minLength?: number;
-    maxLength: number;
+    maxLength?: number;
     placeholder?: string;
     protected constructor(options: BaseStringFieldOptions);
     static getFieldCreationSchema(parentPath?: string): {
@@ -16,7 +12,10 @@ export declare abstract class BaseStringField<TType extends string, This extends
         showDirectly: boolean;
     }[];
     getFieldValidators(): FieldValidator<string>[];
-    serialize(): BaseSerializedStringField<TType>;
+    serialize(): BaseJSONStringField<TType>;
+    config(): BaseStringFieldConfig<TType>;
+    static _deserializeConfig<TType extends string>(serialized: BaseJSONStringField<TType>): BaseStringFieldConfig<TType>;
+    static _serializeConfig<TType extends string>(config: BaseStringFieldConfig<TType>): BaseJSONStringField<TType>;
     getOptions(): BaseStringFieldOptions;
     setOptions(options: Partial<BaseStringFieldOptions>): void;
     serializeValue(value: string): string;

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

@@ -1,6 +1,11 @@
-import { BaseSerializedField } from '../BaseField';
-export interface BaseSerializedStringField<TType extends string> extends BaseSerializedField<TType> {
-    minimum_length?: number;
-    maximum_length: number;
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface BaseStringFieldConfig<TType extends string> extends BaseFieldConfig<TType> {
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
+}
+export interface BaseStringFieldOptions extends BaseFieldOptions {
+    minLength?: number;
+    maxLength?: number;
     placeholder?: string;
 }

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

@@ -1,15 +1,19 @@
+import { JSONBooleanField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions } from '../BaseField';
-import { SerializedBooleanField } from './typings';
-export type BooleanFieldOptions = FieldOptions;
+import { BaseField } from '../BaseField';
+import { BooleanFieldConfig, BooleanFieldOptions } from './typings';
 export declare class BooleanField extends BaseField<"boolean", boolean, boolean, BooleanField> {
     readonly type = "boolean";
     constructor(options: BooleanFieldOptions);
-    serialize(): SerializedBooleanField;
+    serialize(): JSONBooleanField;
+    config(): BooleanFieldConfig;
     getOptions(): BooleanFieldOptions;
     setOptions(options: Partial<BooleanFieldOptions>): void;
     duplicate(identifier: string): BooleanField;
-    static deserialize(data: SerializedBooleanField): BooleanField;
+    static deserialize(data: JSONBooleanField): BooleanField;
+    static fromConfig(config: BooleanFieldConfig): BooleanField;
+    static deserializeConfig(data: JSONBooleanField): BooleanFieldConfig;
+    static serializeConfig(data: BooleanFieldConfig): JSONBooleanField;
     serializeValue(value: boolean): boolean;
     deserializeValue(value: boolean): boolean;
     render(): ReactNode;

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

@@ -1,3 +1,4 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedBooleanField extends BaseSerializedField<"boolean"> {
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface BooleanFieldConfig extends BaseFieldConfig<"boolean"> {
 }
+export type BooleanFieldOptions = BaseFieldOptions;

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

@@ -1,15 +1,18 @@
+import { JSONCheckboxListField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
-import { SerializedCheckboxListField } from './typings';
-export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions {
-}
+import { BaseOptionsField } from '../BaseOptionsField';
+import { CheckboxListFieldConfig, CheckboxListFieldOptions } from './typings';
 export declare class CheckboxListField extends BaseOptionsField<"checkbox-list", string[], string[], CheckboxListField> {
     readonly type = "checkbox-list";
     constructor(options: CheckboxListFieldOptions);
-    serialize(): SerializedCheckboxListField;
+    serialize(): JSONCheckboxListField;
+    config(): CheckboxListFieldConfig;
     getOptions(): CheckboxListFieldOptions;
     duplicate(identifier: string): CheckboxListField;
-    static deserialize(data: SerializedCheckboxListField): CheckboxListField;
+    static deserialize(data: JSONCheckboxListField): CheckboxListField;
+    static fromConfig(config: CheckboxListFieldConfig): CheckboxListField;
+    static deserializeConfig(data: JSONCheckboxListField): CheckboxListFieldConfig;
+    static serializeConfig(data: CheckboxListFieldConfig): JSONCheckboxListField;
     serializeValue(value: string[]): string[];
     deserializeValue(value: string[]): string[];
     render(): ReactNode;

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

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

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

@@ -1,3 +1,5 @@
-import { BaseSerializedOptionsField } from '../BaseOptionsField';
-export interface SerializedCheckboxListField extends BaseSerializedOptionsField<"checkbox-list"> {
+import { BaseOptionsFieldConfig, BaseOptionsFieldOptions } from '../BaseOptionsField';
+export interface CheckboxListFieldConfig extends BaseOptionsFieldConfig<"checkbox-list"> {
+}
+export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions {
 }

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

@@ -1,19 +1,22 @@
+import { JSONDateField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions } from '../BaseField';
-import { SerializedDateField } from './typings';
+import { BaseField } from '../BaseField';
+import { DateFieldConfig, DateFieldOptions } from './typings';
 export type SerializedDateRange = {
     to: string | null;
     from: string | null;
 };
-export interface DateFieldOptions extends FieldOptions {
-}
 export declare class DateField extends BaseField<"date", Date | null, string | null, DateField> {
     readonly type = "date";
     constructor(options: DateFieldOptions);
-    serialize(): SerializedDateField;
+    serialize(): JSONDateField;
+    config(): DateFieldConfig;
     getOptions(): DateFieldOptions;
     duplicate(identifier: string): DateField;
-    static deserialize(data: SerializedDateField): DateField;
+    static deserialize(data: JSONDateField): DateField;
+    static fromConfig(config: DateFieldConfig): DateField;
+    static deserializeConfig(data: JSONDateField): DateFieldConfig;
+    static serializeConfig(data: DateFieldConfig): JSONDateField;
     setOptions(options: Partial<DateFieldOptions>): void;
     serializeValue(value: Date | null): string | null;
     deserializeValue(value: string | null): Date | null;

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

@@ -1,3 +1,5 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedDateField extends BaseSerializedField<"date"> {
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface DateFieldConfig extends BaseFieldConfig<"date"> {
+}
+export interface DateFieldOptions extends BaseFieldOptions {
 }

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

@@ -1,15 +1,10 @@
+import { JSONFieldSection } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { Condition, FieldConditionManager } from '../../conditions';
 import { FieldValues } from '../../typings';
-import { BaseFormElement, BaseFormElementOptions } from '../BaseFormElement';
+import { BaseFormElement } from '../BaseFormElement';
 import { Field, FieldsManager } from '../typings';
-import { FieldSectionConditions, SerializedFieldSection } from './typings';
-export interface FieldSectionOptions extends BaseFormElementOptions {
-    label?: string | null;
-    description?: string | null;
-    conditions?: FieldSectionConditions;
-    fields: Field[];
-}
+import { FieldSectionConditions, FieldSectionConfig, FieldSectionOptions } from './typings';
 export declare class FieldSection extends BaseFormElement<"section", FieldSection> implements FieldConditionManager<Condition>, FieldsManager {
     readonly type = "section";
     label: string | null;
@@ -17,8 +12,12 @@ export declare class FieldSection extends BaseFormElement<"section", FieldSectio
     conditions: FieldSectionConditions;
     fields: Field[];
     constructor(options: FieldSectionOptions);
-    serialize(): SerializedFieldSection;
-    static deserialize: (data: SerializedFieldSection) => FieldSection;
+    serialize(): JSONFieldSection;
+    static deserialize: (data: JSONFieldSection) => FieldSection;
+    static fromConfig: (config: FieldSectionConfig) => FieldSection;
+    static deserializeConfig(data: JSONFieldSection): FieldSectionConfig;
+    static serializeConfig(data: FieldSectionConfig): JSONFieldSection;
+    config(): FieldSectionConfig;
     getOptions(): FieldSectionOptions;
     duplicate(identifier: string): FieldSection;
     setOptions(options: Partial<FieldSectionOptions>): void;

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

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

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

@@ -1,11 +1,17 @@
-import { Condition, SerializedCondition } from '../../conditions';
-import { BaseSerializedFormElement } from '../BaseFormElement';
-import { SerializedOnlyField } from '../typings';
+import { JSONFieldSectionConditions } from '@adrekic/fieldsjson';
+import { Condition } from '../../conditions';
+import { BaseFieldElementConfig, BaseFieldElementOptions } from '../BaseFormElement';
+import { Field, FieldConfig } from '../typings';
+export interface FieldSectionConfig extends BaseFieldElementConfig<"section"> {
+    label?: string | null;
+    description?: string | null;
+    conditions?: JSONFieldSectionConditions;
+    fields: FieldConfig[];
+}
 export type FieldSectionConditions = Record<string, Condition[]>;
-export type SerializedFieldSectionConditions = Record<string, SerializedCondition[]>;
-export interface SerializedFieldSection extends BaseSerializedFormElement<"section"> {
-    label: string | null;
+export interface FieldSectionOptions extends BaseFieldElementOptions {
+    label?: string | null;
     description?: string | null;
-    conditions: SerializedFieldSectionConditions;
-    fields: SerializedOnlyField[];
+    conditions?: FieldSectionConditions;
+    fields: Field[];
 }