@overmap-ai/forms 1.1.4 → 1.1.5-conditions-v2.0

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;
+    duplicate(id: 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;
+    duplicate(id: 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,13 +1,17 @@
+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;
+    duplicate(id: string): TimeField;
     setOptions(options: Partial<TimeFieldOptions>): void;
     serializeValue(value: Time | null): Time | null;
     deserializeValue(value: Time | null): Time | null;

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;

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { Time, TimeRange, UTCOffset } from './typings';
+import { Time, TimeRange, UTCOffset } from '@adrekic/fieldsjson';
 export declare const isUTCOffset: (value: unknown) => value is UTCOffset;
 export declare const getCurrentUTCOffset: () => UTCOffset;
 export declare function getUTCOffsetMinutes(offset: UTCOffset): number;

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

@@ -1,18 +1,20 @@
+import { JSONURLField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
-import { BaseField, FieldOptions } from '../BaseField';
-import { SerializedURLField } from './typings';
-export interface URLFieldOptions extends FieldOptions {
-    placeholder?: string;
-}
+import { BaseField } from '../BaseField';
+import { URLFieldConfig, URLFieldOptions } from './typings';
 export declare class URLField extends BaseField<"url", URL | null, string | null, URLField> {
     readonly type = "url";
-    placeholder: string;
+    placeholder?: string;
     constructor(options: URLFieldOptions);
-    serialize(): SerializedURLField;
+    serialize(): JSONURLField;
+    config(): URLFieldConfig;
     getOptions(): URLFieldOptions;
-    duplicate(identifier: string): URLField;
+    duplicate(id: string): URLField;
     setOptions(options: Partial<URLFieldOptions>): void;
-    static deserialize(data: SerializedURLField): URLField;
+    static deserialize(data: JSONURLField): URLField;
+    static fromConfig(config: URLFieldConfig): URLField;
+    static deserializeConfig(data: JSONURLField): URLFieldConfig;
+    static serializeConfig(data: URLFieldConfig): JSONURLField;
     serializeValue(value: URL | null): string | null;
     deserializeValue(value: string | null): URL | null;
     isSerializedValue(value: unknown): value is string | null;

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

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

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

@@ -1,4 +1,7 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedURLField extends BaseSerializedField<"url"> {
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface URLFieldConfig extends BaseFieldConfig<"url"> {
+    placeholder?: string;
+}
+export interface URLFieldOptions extends BaseFieldOptions {
     placeholder?: string;
 }

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

@@ -1,20 +1,16 @@
+import { JSONUploadField } from '@adrekic/fieldsjson';
 import { ReactNode } from 'react';
 import { UUIDFile } from '../../UUIDFile';
 import { UUIDPromise } from '../../UUIDPromise';
-import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { BaseField, FieldValidator } from '../BaseField';
 import { MultiSelectField } from '../MultiSelectField';
 import { NumberField } from '../NumberField';
-import { SerializedUploadField } from './typings';
-export interface UploadFieldOptions extends FieldOptions {
-    extensions?: string[];
-    maximum_size?: number | string;
-    maximum_files?: number | string;
-}
+import { UploadFieldConfig, UploadFieldOptions } from './typings';
 export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFile> | UUIDFile)[], never[], UploadField> {
     readonly type = "upload";
     extensions?: string[];
-    maxFileSize: number | undefined;
-    maxFiles: number;
+    maxSize?: number;
+    maxFiles?: number;
     constructor(options: UploadFieldOptions);
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
@@ -24,11 +20,15 @@ export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFi
         showDirectly: boolean;
     })[];
     getFieldValidators(): FieldValidator<(UUIDPromise<UUIDFile> | UUIDFile)[]>[];
-    serialize(): SerializedUploadField;
+    serialize(): JSONUploadField;
+    config(): UploadFieldConfig;
     getOptions(): UploadFieldOptions;
-    duplicate(identifier: string): UploadField;
+    duplicate(id: string): UploadField;
     setOptions(options: Partial<UploadFieldOptions>): void;
-    static deserialize(data: SerializedUploadField): UploadField;
+    static deserialize(data: JSONUploadField): UploadField;
+    static fromConfig(config: UploadFieldConfig): UploadField;
+    static deserializeConfig(data: JSONUploadField): UploadFieldConfig;
+    static serializeConfig(data: UploadFieldConfig): JSONUploadField;
     serializeValue(_value: (UUIDPromise<UUIDFile> | UUIDFile)[]): never[];
     deserializeValue(_value: never[]): (UUIDPromise<UUIDFile> | UUIDFile)[];
     render(): ReactNode;

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

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

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

@@ -1,11 +1,11 @@
-import { BaseSerializedField } from '../BaseField';
-export interface SerializedUploadField extends BaseSerializedField<"upload"> {
-    /** @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept */
+import { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface UploadFieldConfig extends BaseFieldConfig<"upload"> {
     extensions?: string[];
-    /** in bytes */
-    maximum_size?: number;
-    /** how many files the user can upload to this field
-     * @default 1
-     */
-    maximum_files?: number;
+    maxSize?: number;
+    maxFiles?: number;
+}
+export interface UploadFieldOptions extends BaseFieldOptions {
+    extensions?: string[];
+    maxSize?: number;
+    maxFiles?: number;
 }

package/dist/form/fields/components/InputWithLabel.d.ts

@@ -3,10 +3,10 @@ import { FieldsRendererSize } from '../../renderer';
 export interface InputWithLabelProps {
     size: FieldsRendererSize;
     inputId: string;
-    label: string;
-    required: boolean;
-    description?: string | null;
-    image: File | Promise<File> | undefined;
+    label?: string;
+    required?: boolean;
+    description?: string;
+    image?: File | Promise<File>;
     children: ReactNode;
     error: string;
 }

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

@@ -1,9 +1,44 @@
 import { IconComponent } from '@overmap-ai/blocks';
+import { BooleanField } from './BooleanField';
+import { CheckboxListField } from './CheckboxListField';
+import { DateField } from './DateField';
 import { FieldTypeGroup } from './enums';
-import { FieldClass, FieldType } from './typings';
-export declare const FieldTypeToClsMapping: Record<Exclude<FieldType, "section">, FieldClass>;
-export declare const FIELD_TYPES: Exclude<FieldType, "section">[];
-export declare const fieldDataMapping: Record<Exclude<FieldType, "section">, {
+import { MultiSelectField } from './MultiSelectField';
+import { MultiStringField } from './MultiStringField';
+import { NumberField } from './NumberField';
+import { OTPField } from './OTPField';
+import { PassFailField } from './PassFailField';
+import { RadioField } from './RadioField';
+import { RatingField } from './RatingField';
+import { ScanField } from './ScanField';
+import { SelectField } from './SelectField';
+import { StringField } from './StringField';
+import { TextField } from './TextField';
+import { TimeField } from './TimeField';
+import { FieldType } from './typings';
+import { UploadField } from './UploadField';
+import { URLField } from './URLField';
+export declare const FieldTypeToClsMapping: {
+    date: typeof DateField;
+    time: typeof TimeField;
+    number: typeof NumberField;
+    boolean: typeof BooleanField;
+    select: typeof SelectField;
+    string: typeof StringField;
+    url: typeof URLField;
+    text: typeof TextField;
+    upload: typeof UploadField;
+    qr: typeof ScanField;
+    "multi-string": typeof MultiStringField;
+    "multi-select": typeof MultiSelectField;
+    radio: typeof RadioField;
+    "checkbox-list": typeof CheckboxListField;
+    "pass-fail": typeof PassFailField;
+    otp: typeof OTPField;
+    rating: typeof RatingField;
+};
+export declare const FIELD_TYPES: FieldType[];
+export declare const fieldDataMapping: Record<FieldType, {
     icon: IconComponent;
     name: string;
     description: string;
@@ -12,8 +47,5 @@ export declare const fieldDataMapping: Record<Exclude<FieldType, "section">, {
 export declare const fieldTypeGroupDataMapping: Record<FieldTypeGroup, {
     name: string;
 }>;
-export declare const maxFileSizeMB = 50;
-export declare const maxFileSizeKB: number;
-export declare const maxFileSizeB: number;
 export declare const UNLABELLED_FIELD_LABEL = "Unlabelled";
 export declare const UNLABELLED_SECTION_LABEL = "Unlabelled";

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

@@ -8,7 +8,7 @@ export interface useFieldInputProps<TField extends AnyField> {
 }
 export declare const useFieldInput: <TField extends AnyField>(props: useFieldInputProps<TField>) => {
     value: ValueOfField<TField>;
-    name: TField["identifier"];
+    name: TField["id"];
     disabled: boolean | undefined;
     isTouched: boolean;
     error: string;

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

@@ -1,36 +1,41 @@
 import { BaseField } from './BaseField';
 import { BaseFormElement } from './BaseFormElement';
-import { BooleanField, SerializedBooleanField } from './BooleanField';
-import { CheckboxListField, SerializedCheckboxListField } from './CheckboxListField';
-import { DateField, SerializedDateField } from './DateField';
-import { FieldSection, SerializedFieldSection } from './FieldSection';
-import { MultiSelectField, SerializedMultiSelectField } from './MultiSelectField';
-import { MultiStringField, SerializedMultiStringField } from './MultiStringField';
-import { NumberField, SerializedNumberField } from './NumberField';
-import { OTPField, SerializedOTPField } from './OTPField';
-import { PassFailField, SerializedPassFailField } from './PassFailField';
-import { RadioField, SerializedRadioField } from './RadioField';
-import { RatingField, SerializedRatingField } from './RatingField';
-import { ScanField, SerializedScanField } from './ScanField';
-import { SelectField, SerializedSelectField } from './SelectField';
-import { SerializedStringField, StringField } from './StringField';
-import { SerializedTextField, TextField } from './TextField';
-import { SerializedTimeField, TimeField } from './TimeField';
-import { SerializedUploadField, UploadField } from './UploadField';
-import { SerializedURLField, URLField } from './URLField';
+import { BooleanField, BooleanFieldConfig } from './BooleanField';
+import { CheckboxListField, CheckboxListFieldConfig } from './CheckboxListField';
+import { DateField, DateFieldConfig } from './DateField';
+import { FieldSection, FieldSectionConfig } from './FieldSection';
+import { MultiSelectField, MultiSelectFieldConfig } from './MultiSelectField';
+import { MultiStringField, MultiStringFieldConfig } from './MultiStringField';
+import { NumberField, NumberFieldConfig } from './NumberField';
+import { OTPField, OTPFieldConfig } from './OTPField';
+import { PassFailField, PassFailFieldConfig } from './PassFailField';
+import { RadioField, RadioFieldConfig } from './RadioField';
+import { RatingField, RatingFieldConfig } from './RatingField';
+import { ScanField, ScanFieldConfig } from './ScanField';
+import { SelectField, SelectFieldConfig } from './SelectField';
+import { StringField, StringFieldConfig } from './StringField';
+import { TextField, TextFieldConfig } from './TextField';
+import { TimeField, TimeFieldConfig } from './TimeField';
+import { UploadField, UploadFieldConfig } from './UploadField';
+import { URLField, URLFieldConfig } from './URLField';
 export type AnyFormElement = BaseFormElement<any, any>;
 export type AnyField = BaseField<any, any, any, any>;
 export type TypeOfField<TField extends AnyFormElement> = TField extends BaseFormElement<infer TType, infer _TThis> ? TType : never;
 export type ValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer TValue, infer _TSerializedValue, infer _TThis> ? TValue : never;
 export type SerializedValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer _TValue, infer TSerializedValue, infer _TThis> ? TSerializedValue : never;
+export type FieldType = TypeOfField<Field>;
+export type FieldConfig = BooleanFieldConfig | CheckboxListFieldConfig | PassFailFieldConfig | DateFieldConfig | MultiSelectFieldConfig | MultiStringFieldConfig | NumberFieldConfig | RadioFieldConfig | RatingFieldConfig | ScanFieldConfig | SelectFieldConfig | StringFieldConfig | TextFieldConfig | UploadFieldConfig | URLFieldConfig | OTPFieldConfig | TimeFieldConfig;
 export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | RatingField | ScanField | SelectField | StringField | TextField | UploadField | URLField | OTPField | TimeField;
 export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof RatingField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof URLField | typeof OTPField | typeof TimeField;
-export type FieldType = TypeOfField<Field> | TypeOfField<FieldSection>;
+export type ExtractByType<T, TType extends string> = Extract<T, {
+    type: TType;
+}>;
+export type FieldElementType = TypeOfField<FieldElement>;
+export type FieldElementConfig = FieldConfig | FieldSectionConfig;
+export type FieldElement = Field | FieldSection;
+export type FieldElementClass = FieldClass | typeof FieldSection;
 export type FieldValue = ValueOfField<Field>;
 export type FieldError = string;
-export type SerializedFieldValue = SerializedValueOfField<Field>;
-export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedURLField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedRatingField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField | SerializedTimeField;
-export type SerializedOnlyField = Exclude<SerializedField, SerializedFieldSection>;
 export interface FieldsManager {
     readonly fields: Field[];
     getFields(): Field[];

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

@@ -1,16 +1,27 @@
-import { FieldFilesAndPromises, FieldValues, SerializedFieldValues } from '../typings';
-import { FieldSection } from './FieldSection';
-import { Field, SerializedField, SerializedOnlyField } from './typings';
-export declare const deserializeField: (serializedField: SerializedOnlyField) => Field;
-export declare function deserializeFields(fields: SerializedField[]): (Field | FieldSection)[];
-export declare const deserialize: (serialized: SerializedField) => Field | FieldSection;
-export declare function deserializeOnlyFields(fields: SerializedOnlyField[]): Field[];
-export declare function flattenFields(fields: (Field | FieldSection)[]): Field[];
-export declare function getFieldsMapping(fields: Field[]): Record<Field["identifier"], Field>;
-export declare function serializeFieldValues(fields: Field[], values: FieldValues, clean?: boolean): SerializedFieldValues;
-export declare function deserializeFieldValues(fields: Field[], values: SerializedFieldValues, clean?: boolean): FieldValues;
+import { JSONField, JSONFieldElement, JSONFieldValues } from '@adrekic/fieldsjson';
+import { FieldFilesAndPromises, FieldValues } from '../typings';
+import { ExtractByType, Field, FieldConfig, FieldElement, FieldElementConfig } from './typings';
+export declare const deserializeField: <T extends JSONField>(serializedField: T) => ExtractByType<Field, T["type"]>;
+export declare function deserializeFields<T extends JSONField>(fields: T[]): ExtractByType<Field, T["type"]>[];
+export declare function deserializeFieldElement<T extends JSONFieldElement>(serialized: T): ExtractByType<FieldElement, T["type"]>;
+export declare const deserializeFieldElements: <T extends JSONFieldElement>(serialized: T[]) => ExtractByType<FieldElement, T["type"]>[];
+export declare const fieldFromConfig: <T extends FieldConfig>(fieldConfig: T) => ExtractByType<Field, T["type"]>;
+export declare const fieldsFromConfigs: <T extends FieldConfig>(fieldConfigs: T[]) => ExtractByType<Field, T["type"]>[];
+export declare const fieldElementFromConfig: <T extends FieldElementConfig>(fieldElementConfig: T) => ExtractByType<FieldElement, T["type"]>;
+export declare const fieldElementsFromConfigs: <T extends FieldElementConfig>(fieldElementConfigs: T[]) => ExtractByType<FieldElement, T["type"]>[];
+export declare const deserializeFieldConfig: <T extends JSONField>(serialized: T) => ExtractByType<FieldConfig, T["type"]>;
+export declare const deserializeFieldConfigs: <T extends JSONField>(serialized: T[]) => ExtractByType<FieldConfig, T["type"]>[];
+export declare const deserializeFieldElementConfig: <T extends JSONFieldElement>(serialized: T) => ExtractByType<FieldElementConfig, T["type"]>;
+export declare const deserializeFieldElementConfigs: <T extends JSONFieldElement>(serialized: T[]) => ExtractByType<FieldElementConfig, T["type"]>[];
+export declare const serializeFieldConfig: <T extends FieldConfig>(config: T) => ExtractByType<JSONField, T["type"]>;
+export declare const serializeFieldConfigs: <T extends FieldConfig>(config: T[]) => ExtractByType<JSONField, T["type"]>[];
+export declare const serializeFieldElementConfig: <T extends FieldElementConfig>(config: T) => ExtractByType<JSONFieldElement, T["type"]>;
+export declare const serializeFieldElementConfigs: <T extends FieldElementConfig>(config: T[]) => ExtractByType<JSONFieldElement, T["type"]>[];
+export declare function getFieldsMapping(fields: Field[]): Record<Field["id"], Field>;
+export declare function serializeFieldValues(fields: Field[], values: FieldValues, clean?: boolean): JSONFieldValues;
+export declare function deserializeFieldValues(fields: Field[], values: JSONFieldValues, clean?: boolean): FieldValues;
 export declare function cleanFieldValues(fields: Field[], values: FieldValues): FieldValues;
-export declare function cleanSerializedFieldValues(fields: Field[], values: SerializedFieldValues): SerializedFieldValues;
+export declare function cleanSerializedFieldValues(fields: Field[], values: JSONFieldValues): JSONFieldValues;
 export declare function extractFilesAndPromisesFromFieldValues(fields: Field[], values: FieldValues): readonly [FieldValues, FieldFilesAndPromises];
 export declare function insertFilesAndPromisesToFieldValues(fields: Field[], values: FieldValues, filesAndPromises: FieldFilesAndPromises): FieldValues;
 export declare const initializeFieldValues: (fields: Field[], values: FieldValues) => FieldValues;

package/dist/form/index.d.ts

@@ -1,7 +1,6 @@
 export * from './builder';
 export * from './conditions';
 export * from './fields';
-export * from './modifiers';
 export * from './Observable';
 export * from './renderer';
 export * from './schema';

package/dist/form/schema/FieldSchema.d.ts

@@ -1,15 +1,21 @@
+import { JSONCondition, JSONFieldSchema, JSONFieldSection, JSONFieldValues } from '@adrekic/fieldsjson';
 import { DirectedGraph } from 'graphology';
 import { ReseedOptions } from '../builder/list/sectionSerialization';
-import { Condition, SerializedCondition } from '../conditions';
-import { Field, FieldSection, FieldSectionManager, SerializedFieldSection } from '../fields';
+import { Condition } from '../conditions';
+import { Field, FieldSection, FieldSectionManager } from '../fields';
 import { Observable } from '../Observable';
-import { FieldFilesAndPromises, FieldValues, SerializedFieldValues } from '../typings';
+import { FieldFilesAndPromises, FieldValues } from '../typings';
+import { FieldSchemaConfig, FieldSchemaOptions } from './typings';
 export declare class FieldSchema extends Observable<FieldSchema> implements FieldSectionManager {
     fieldSections: FieldSection[];
-    constructor(fields: FieldSection[]);
-    serialize(): SerializedFieldSection[];
-    static deserialize(serializedSections: SerializedFieldSection[]): FieldSchema;
-    static reseedFieldSections(serializedSections: SerializedFieldSection[], options?: ReseedOptions): SerializedFieldSection[];
+    constructor(fields: FieldSchemaOptions);
+    serialize(): JSONFieldSection[];
+    config(): import('..').FieldSectionConfig[];
+    static deserialize(serialized: JSONFieldSchema): FieldSchema;
+    static fromConfig(config: FieldSchemaConfig): FieldSchema;
+    static serializeConfig(config: FieldSchemaConfig): JSONFieldSchema;
+    static deserializeConfig(serialized: JSONFieldSchema): FieldSchemaConfig;
+    static reseedFieldSections(serializedSections: JSONFieldSection[], options?: ReseedOptions): JSONFieldSection[];
     private fieldObserver;
     private initFields;
     getFields(): Field[];
@@ -18,18 +24,18 @@ export declare class FieldSchema extends Observable<FieldSchema> implements Fiel
     removeFieldSection(fieldSection: FieldSection): void;
     moveFieldSection(sourceIndex: number, targetIndex: number): void;
     getSectionDependencyGraph(): DirectedGraph<import('graphology-types').Attributes, import('graphology-types').Attributes, import('graphology-types').Attributes>;
-    getDependenciesOfSection(fieldSectionId: FieldSection["identifier"]): FieldSection[];
+    getDependenciesOfSection(fieldSectionId: FieldSection["id"]): FieldSection[];
     cleanValues(values: FieldValues): FieldValues;
-    cleanSerializedValues(values: SerializedFieldValues): SerializedFieldValues;
-    deserializeValues(values: SerializedFieldValues, clean?: boolean): FieldValues;
-    serializeValues(values: FieldValues, clean?: boolean): SerializedFieldValues;
+    cleanSerializedValues(values: JSONFieldValues): JSONFieldValues;
+    deserializeValues(values: JSONFieldValues, clean?: boolean): FieldValues;
+    serializeValues(values: FieldValues, clean?: boolean): JSONFieldValues;
     initializeValues(values: FieldValues): FieldValues;
     validateValues(values: FieldValues): import('..').FieldErrors;
     areValuesValid(values: FieldValues): boolean;
-    deserializeConditions(serializedConditions: SerializedCondition[]): Condition[];
+    deserializeConditions(serializedConditions: JSONCondition[]): Condition[];
     cleanConditions(conditions: Condition[]): Condition[];
-    serializeConditions(conditions: Condition[]): SerializedCondition[];
-    cleanSerializedConditions(serializedConditions: SerializedCondition[]): SerializedCondition[];
+    serializeConditions(conditions: Condition[]): JSONCondition[];
+    cleanSerializedConditions(serializedConditions: JSONCondition[]): JSONCondition[];
     changedFieldValues(values1: FieldValues, values2: FieldValues): FieldValues;
     unchangedFieldValues(values1: FieldValues, values2: FieldValues): FieldValues;
     areValuesEqual(values1: FieldValues, values2: FieldValues): boolean;

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

@@ -1 +1,2 @@
 export * from './FieldSchema';
+export type * from './typings';

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

@@ -0,0 +1,3 @@
+import { FieldSection, FieldSectionConfig } from '../fields';
+export type FieldSchemaConfig = FieldSectionConfig[];
+export type FieldSchemaOptions = FieldSection[];

package/dist/form/typings.d.ts

@@ -1,10 +1,9 @@
-import { Field, FieldError, FieldValue, SerializedFieldValue } from './fields';
+import { Field, FieldError, FieldValue } from './fields';
 import { UUIDFile } from './UUIDFile';
 import { UUIDPromise } from './UUIDPromise';
-export type FieldValues = Record<Field["identifier"], FieldValue>;
+export type FieldValues = Record<Field["id"], FieldValue>;
 export type FieldErrors = {
-    [identifier: Field["identifier"]]: FieldError | FieldErrors;
+    [id: Field["id"]]: FieldError | FieldErrors;
 };
-export type FieldFilesAndPromises = Record<Field["identifier"], (UUIDFile | UUIDPromise<UUIDFile>)[]>;
-export type FieldFiles = Record<Field["identifier"], UUIDFile[]>;
-export type SerializedFieldValues = Record<Field["identifier"], SerializedFieldValue>;
+export type FieldFilesAndPromises = Record<Field["id"], (UUIDFile | UUIDPromise<UUIDFile>)[]>;
+export type FieldFiles = Record<Field["id"], UUIDFile[]>;

package/dist/form/utils.d.ts

@@ -1,8 +1,6 @@
-import { AnyFormElement, SerializedFieldSection } from './fields';
+import { AnyFormElement } from './fields';
+import { FieldSchemaConfig } from './schema';
 import { FieldErrors, FieldFiles, FieldFilesAndPromises, FieldValues } from './typings';
 export declare const validateFieldValues: (fields: AnyFormElement[], values: FieldValues) => FieldErrors;
-export declare const separateImagesFromFields: (fields: SerializedFieldSection[]) => Promise<{
-    fields: SerializedFieldSection[];
-    images: Record<string, File>;
-}>;
+export declare const getImagesFromFields: (fields: FieldSchemaConfig) => Promise<Record<string, File>>;
 export declare function awaitFilesAndPromises(values: FieldFilesAndPromises): Promise<FieldFiles>;