@overmap-ai/forms 1.1.4 → 1.1.5-field-schema-improvements.0

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;
+    duplicate(id: string): 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,26 +1,25 @@
+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;
-    description: string | null;
+    label?: string;
+    description?: string;
     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;
+    duplicate(id: string): FieldSection;
     setOptions(options: Partial<FieldSectionOptions>): void;
     getErrors(values: FieldValues): Record<string, string>;
     private fieldObserver;
@@ -31,13 +30,13 @@ export declare class FieldSection extends BaseFormElement<"section", FieldSectio
     removeField(field: Field): void;
     private conditionObserver;
     private initConditions;
-    getConditions(identifier: string): Condition[];
-    addCondition(identifier: string, condition: Condition): void;
-    addConditions(identifier: string, conditions: Condition[]): void;
-    removeCondition(identifier: string, condition: Condition): void;
-    removeConditions(identifier: string, conditions: Condition[]): void;
+    getConditions(id: string): Condition[];
+    addCondition(id: string, condition: Condition): void;
+    addConditions(id: string, conditions: Condition[]): void;
+    removeCondition(id: string, condition: Condition): void;
+    removeConditions(id: string, conditions: Condition[]): void;
     getConditionals(): Set<string>;
-    addConditional(identifier: string): void;
-    removeConditional(identifier: string): void;
+    addConditional(id: string): void;
+    removeConditional(id: string): void;
     render(): ReactNode;
 }

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

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

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;
+    description?: string;
+    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;
-    description?: string | null;
-    conditions: SerializedFieldSectionConditions;
-    fields: SerializedOnlyField[];
+export interface FieldSectionOptions extends BaseFieldElementOptions {
+    label?: string;
+    description?: string;
+    conditions?: FieldSectionConditions;
+    fields: Field[];
 }

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;
+    duplicate(id: 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;
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
     constructor(options: MultiStringFieldOptions);
     render(): ReactNode;
-    serialize(): SerializedMultiStringField;
+    serialize(): JSONMultiStringField;
+    config(): MultiStringFieldConfig;
     getOptions(): MultiStringFieldOptions;
-    duplicate(identifier: string): MultiStringField;
+    duplicate(id: 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"> {
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
+}
+export interface MultiStringFieldOptions extends BaseFieldOptions {
+    minLength?: number;
+    maxLength?: 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;
+    duplicate(id: 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,30 +1,26 @@
+import { JSONOTPField } 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;
-    validationType: OTPFieldValidationType;
     constructor(options: OTPFieldOptions);
-    static getFieldCreationSchema(parentPath?: string): ({
+    static getFieldCreationSchema(parentPath?: string): {
         field: NumberField;
         showDirectly: boolean;
-    } | {
-        field: SelectField;
-        showDirectly: boolean;
-    })[];
+    }[];
     getFieldValidators(): FieldValidator<string>[];
-    serialize(): SerializedOTPField;
+    serialize(): JSONOTPField;
+    config(): OTPFieldConfig;
     getOptions(): OTPFieldOptions;
-    duplicate(identifier: string): OTPField;
+    duplicate(id: 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,7 @@
-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 { BaseFieldConfig, BaseFieldOptions } from '../BaseField';
+export interface OTPFieldConfig extends BaseFieldConfig<"otp"> {
+    length: number;
+}
+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;
+    duplicate(id: 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;
+    duplicate(id: 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;
+    duplicate(id: 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;
+    duplicate(id: 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 {
 }