@overmap-ai/forms 1.0.32-react-flow-david.1 → 1.0.32-react-flow-david-fixes.1

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

@@ -0,0 +1,2 @@
+export * from './BaseFormElement';
+export * from './typings';

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

@@ -0,0 +1,9 @@
+import { BaseFormElement } from './BaseFormElement';
+export type AnyFormElement = BaseFormElement<any, any>;
+export interface FormElementOptions {
+    identifier: string;
+}
+export interface BaseSerializedObject<TIdentifier extends string> {
+    identifier: string;
+    type: TIdentifier;
+}

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

@@ -0,0 +1,18 @@
+import { BaseField, FieldOptions } from '../BaseField';
+import { MultiStringField } from '../MultiStringField';
+import { BaseSerializedSelectField, SelectFieldOption } from './typings';
+export interface BaseOptionsFieldOptions<TValue> extends FieldOptions<TValue> {
+    options: string[] | SelectFieldOption[];
+}
+export declare abstract class BaseOptionsField<TIdentifier extends string, TValue, TSerializedValue, This extends BaseOptionsField<TIdentifier, TValue, TSerializedValue, This>> extends BaseField<TIdentifier, TValue, TSerializedValue, This> {
+    options: SelectFieldOption[];
+    readonly onlyValidateAfterTouched = false;
+    protected constructor(options: BaseOptionsFieldOptions<TValue>);
+    serialize(): BaseSerializedSelectField<TIdentifier>;
+    getOptions(): BaseOptionsFieldOptions<TValue>;
+    setOptions(options: Partial<BaseOptionsFieldOptions<TValue>>): void;
+    static getFieldCreationSchema(parentPath?: string): {
+        field: MultiStringField;
+        showDirectly: boolean;
+    }[];
+}

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

@@ -0,0 +1,2 @@
+export * from './BaseOptionsField';
+export * from './typings';

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

@@ -0,0 +1,9 @@
+import { BaseSerializedField } from '../BaseField';
+export interface SelectFieldOption {
+    value: string;
+    label: string;
+}
+export interface BaseSerializedSelectField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
+    type: TIdentifier;
+    options: SelectFieldOption[];
+}

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

@@ -0,0 +1,25 @@
+import { BaseField, FieldOptions } from '../BaseField';
+import { NumberField } from '../NumberField';
+import { FieldValidator } from '../typings';
+import { BaseSerializedStringField } from './typings';
+export interface BaseStringFieldOptions extends FieldOptions<string> {
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
+}
+export declare abstract class BaseStringField<TIdentifier extends string, This extends BaseStringField<TIdentifier, This>> extends BaseField<TIdentifier, string, string, This> {
+    minLength?: number;
+    maxLength: number;
+    placeholder?: string;
+    protected constructor(options: BaseStringFieldOptions);
+    static getFieldCreationSchema(parentPath?: string): {
+        field: NumberField;
+        showDirectly: boolean;
+    }[];
+    getFieldValidators(): FieldValidator<string>[];
+    serialize(): BaseSerializedStringField<TIdentifier>;
+    getOptions(): BaseStringFieldOptions;
+    setOptions(options: Partial<BaseStringFieldOptions>): void;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+}

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

@@ -0,0 +1,2 @@
+export * from './BaseStringField';
+export * from './typings';

package/dist/form/fields/{StringOrTextField → BaseStringField}/typings.d.ts

@@ -1,5 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-export interface BaseSerializedStringField extends BaseSerializedField {
+export interface BaseSerializedStringField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
     minimum_length?: number;
     maximum_length: number;
     placeholder?: string;

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

@@ -1,29 +1,21 @@
 import { ReactNode } from 'react';
-import { RiCheckboxCircleLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { ComponentProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { ComponentProps, SerializedField } from '../typings';
 import { SerializedBooleanField } from './typings';
-export declare const emptyBooleanField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class BooleanField extends BaseField<"boolean", boolean, boolean, boolean> {
+export type BooleanFieldOptions = FieldOptions<boolean>;
+export declare class BooleanField extends BaseField<"boolean", boolean, boolean, BooleanField> {
+    readonly type = "boolean";
     static readonly fieldTypeName = "Checkbox";
     static readonly fieldTypeDescription = "Perfect for both optional and required yes/no questions.";
-    readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiCheckboxCircleLine;
-    readonly defaultConditionValue: boolean | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<boolean, boolean, unknown, boolean, boolean, boolean>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<boolean, boolean, unknown, boolean, boolean, boolean>;
-    };
-    constructor(options: ChildFieldOptions<boolean>);
-    protected isBlank(value: boolean | undefined): boolean;
+    readonly onlyValidateAfterTouched: boolean;
+    constructor(options: BooleanFieldOptions);
+    isBlank(value: boolean | undefined): boolean;
     serialize(): SerializedBooleanField;
-    static deserialize(data: ISerializedField): BooleanField;
-    getInput(props: ComponentProps<BooleanField>): ReactNode;
-    renderCondition(props: ConditionRenderProps<BooleanField>): ReactNode;
+    getOptions(): BooleanFieldOptions;
+    setOptions(options: Partial<BooleanFieldOptions>): void;
+    duplicate(identifier: string): BooleanField;
+    static deserialize(data: SerializedField): BooleanField;
+    serializeValue(value: boolean): boolean;
+    deserializeValue(value: boolean): boolean;
+    render(props: ComponentProps): ReactNode;
 }

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

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

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

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

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

@@ -1,41 +1,20 @@
 import { ReactNode } from 'react';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-import { MultiStringField } from '../MultiStringField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
+import { ComponentProps } from '../typings';
 import { SerializedCheckboxListField } from './typings';
-export declare const emptyCheckboxListField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
-};
-export interface CheckboxListFieldConfig extends ChildFieldOptions<string[]> {
-    options: SelectFieldOption[];
+export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions<string[]> {
 }
-export declare class CheckboxListField extends BaseField<"checkbox-list", string[], string[], string[]> {
-    readonly options: SelectFieldOption[];
+export declare class CheckboxListField extends BaseOptionsField<"checkbox-list", string[], string[], CheckboxListField> {
+    readonly type = "checkbox-list";
     readonly onlyValidateAfterTouched = false;
     static readonly fieldTypeName = "Checkbox list";
     static readonly fieldTypeDescription = "Allows the user to select a multiple options from a list.";
-    static Icon: import('react-icons').IconType;
-    readonly defaultConditionValue: string[] | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        every: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        some: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        none: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-    };
-    constructor(config: CheckboxListFieldConfig);
+    constructor(options: CheckboxListFieldOptions);
     serialize(): SerializedCheckboxListField;
-    static deserialize(data: ISerializedField): CheckboxListField;
-    static getFieldCreationSchema(parentPath?: string): {
-        field: MultiStringField;
-        showDirectly: boolean;
-    }[];
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<CheckboxListField>): ReactNode;
+    getOptions(): CheckboxListFieldOptions;
+    duplicate(identifier: string): CheckboxListField;
+    static deserialize(data: SerializedCheckboxListField): CheckboxListField;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    render(props: ComponentProps): ReactNode;
 }

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

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

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

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

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

@@ -1,30 +1,26 @@
 import { ReactNode } from 'react';
-import { RiCalendarLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { ComponentProps } from '../typings';
 import { SerializedDateField } from './typings';
-export declare const emptyDateField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
+export type SerializedDateRange = {
+    to: string | null;
+    from: string | null;
 };
-export declare class DateField extends BaseField<"date", Date, Date, string> {
+export interface DateFieldOptions extends FieldOptions<Date> {
+}
+export declare class DateField extends BaseField<"date", Date, string, DateField> {
+    readonly type = "date";
     static readonly fieldTypeName = "Date";
     static readonly fieldTypeDescription = "Allows specifying a date.";
-    readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiCalendarLine;
-    readonly defaultConditionValue: Date | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<Date, Date, unknown, Date, Date, string>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<Date, Date, unknown, Date, Date, string>;
-        before: import('../../conditions/typings').FieldConditionModifierConfig<Date, Date, unknown, Date, Date, string>;
-        after: import('../../conditions/typings').FieldConditionModifierConfig<Date, Date, unknown, Date, Date, string>;
-    };
-    constructor(options: ChildFieldOptions<Date>);
+    readonly onlyValidateAfterTouched: boolean;
+    constructor(options: DateFieldOptions);
     serialize(): SerializedDateField;
-    static deserialize(data: ISerializedField): DateField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<DateField>): ReactNode;
+    getOptions(): DateFieldOptions;
+    duplicate(identifier: string): DateField;
+    static deserialize(data: SerializedDateField): DateField;
+    setOptions(options: Partial<DateFieldOptions>): void;
+    serializeValue(value: Date): string;
+    deserializeValue(value: string): Date;
+    isEqual(value1: Date | undefined, value2: Date | undefined): boolean;
+    render(props: ComponentProps): ReactNode;
 }

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

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

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

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

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

@@ -1,31 +1,48 @@
 import { ReactNode } from 'react';
 import { FormBuilderValues } from '../../builder';
-import { AnyCondition, AnySerializedCondition } from '../../conditions/condition/typings';
-import { FormValues } from '../../typings';
-import { BaseFormElement, BaseSerializedObject } from '../BaseField';
-import { AnyField, GetInputProps, ISerializedField } from '../typings';
-import { SerializedFieldSection } from './typings';
-export type FieldSectionConditions = Record<string, AnySerializedCondition[]>;
-interface FieldSectionOptions extends Omit<BaseSerializedObject, "type"> {
+import { Condition, ConditionManager } from '../../conditions/typings';
+import { FieldValues } from '../../typings';
+import { BaseFormElement, FormElementOptions } from '../BaseFormElement';
+import { ComponentProps, Field, FieldsManagerInterface } from '../typings';
+import { FieldSectionConditions, SerializedFieldSection } from './typings';
+export interface FieldSectionOptions extends FormElementOptions {
     label?: string | null;
+    description?: string | null;
     conditions?: FieldSectionConditions;
-    fields: AnyField[];
+    fields: Field[];
 }
-export declare class FieldSection extends BaseFormElement<"section"> {
+export declare class FieldSection extends BaseFormElement<"section", FieldSection> implements ConditionManager<Condition>, FieldsManagerInterface<Field> {
     static readonly fieldTypeName = "Section";
     static readonly fieldTypeDescription = "Sections can be useful for grouping fields together. They can also be conditionally shown or hidden.";
-    readonly label: string | null;
-    readonly fields: AnyField[];
-    readonly conditions: FieldSectionConditions;
+    readonly type = "section";
+    label: string | null;
+    description: string | null;
+    conditions: FieldSectionConditions;
+    fields: Field[];
     constructor(options: FieldSectionOptions);
-    static deserialize(data: ISerializedField): FieldSection;
-    conditional(): this is {
-        conditions: FieldSectionConditions;
-    };
     serialize(): SerializedFieldSection;
-    getErrors(allValues: FormValues | FormBuilderValues): Record<string, string>;
-    getInput(props: GetInputProps<this>): ReactNode;
-    serializeConditions: (conditions: AnyCondition[]) => AnySerializedCondition[];
-    deserializeConditions: (conditions: AnySerializedCondition[]) => AnyCondition[];
+    static deserialize(data: SerializedFieldSection): FieldSection;
+    getOptions(): FieldSectionOptions;
+    duplicate(identifier: string): FieldSection;
+    setOptions(options: Partial<FieldSectionOptions>): void;
+    getErrors(allValues: FieldValues | FormBuilderValues): Record<string, string>;
+    private fieldObserver;
+    private initFields;
+    getFields(): Field[];
+    addField(field: Field): void;
+    addFields(fields: Field[]): void;
+    moveField(sourceIndex: number, targetIndex: number): void;
+    removeField(field: Field): void;
+    removeFields(fields: 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;
+    getConditionals(): Set<string>;
+    addConditional(identifier: string): void;
+    removeConditional(identifier: string): void;
+    render(props: ComponentProps): ReactNode;
 }
-export {};

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

@@ -1,6 +1,7 @@
 import { ComponentProps } from '../typings';
 import { FieldSection } from './FieldSection';
-/**
- * Used by FieldSection to render a section of fields.
- */
-export declare const FieldSectionLayout: import('react').MemoExoticComponent<(props: ComponentProps<FieldSection>) => import("react/jsx-runtime").JSX.Element | null>;
+interface FieldSectionLayoutProps extends ComponentProps {
+    fieldSection: FieldSection;
+}
+export declare const FieldSectionLayout: import('react').NamedExoticComponent<FieldSectionLayoutProps>;
+export {};

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

@@ -1,9 +1,11 @@
-import { BaseSerializedObject } from '../BaseField';
-import { ISerializedField } from '../typings';
-import { FieldSectionConditions } from './FieldSection';
-export interface SerializedFieldSection extends BaseSerializedObject {
+import { Condition, ISerializedCondition } from '../../conditions/typings';
+import { BaseSerializedObject } from '../BaseFormElement';
+import { SerializedOnlyField } from '../typings';
+export type FieldSectionConditions = Record<string, Condition[]>;
+export type SerializedFieldSectionConditions = Record<string, ISerializedCondition[]>;
+export interface SerializedFieldSection extends BaseSerializedObject<"section"> {
     label: string | null;
-    type: "section";
-    conditions: FieldSectionConditions;
-    fields: Exclude<ISerializedField, SerializedFieldSection>[];
+    description?: string | null;
+    conditions: SerializedFieldSectionConditions;
+    fields: SerializedOnlyField[];
 }

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

@@ -1,38 +1,24 @@
 import { ReactNode } from 'react';
-import { RiCheckboxLine } from 'react-icons/ri';
-import { ConditionRenderProps } from '../BaseField';
-import { BaseSelectField, BaseSelectFieldOptions } from '../BaseSelectField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
+import { ComponentProps } from '../typings';
 import { SerializedMultiSelectField } from './typings';
-/**
- * The options passed to the constructor of MultiSelectField.
- */
-export type MultiSelectFieldOptions = Omit<BaseSelectFieldOptions<string[], "multi-select">, "type">;
-export declare const emptyMultiSelectField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
+export type MultiSelectFieldOptions = BaseOptionsFieldOptions<string[]> & {
+    placeholder?: string;
 };
-export declare class MultiSelectField extends BaseSelectField<"multi-select", string[], string[], string[]> {
+export declare class MultiSelectField extends BaseOptionsField<"multi-select", string[], string[], MultiSelectField> {
+    readonly type = "multi-select";
     static readonly fieldTypeName = "Multi-select";
     static readonly fieldTypeDescription = "Allows the user to select a multiple options from a list of options.";
-    static Icon: typeof RiCheckboxLine;
-    readonly defaultConditionValue: string[] | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        every: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        some: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        none: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-    };
+    placeholder?: string;
     constructor(options: MultiSelectFieldOptions);
-    protected isBlank(value: string[] | undefined): boolean;
+    isBlank(value: string[] | undefined): boolean;
     isEqual(value1: string[] | undefined, value2: string[] | undefined): boolean;
     serialize(): SerializedMultiSelectField;
-    static deserialize(data: ISerializedField): MultiSelectField;
-    getInput(props: GetInputProps<this>): ReactNode;
-    renderCondition(props: ConditionRenderProps<MultiSelectField>): ReactNode;
+    getOptions(): MultiSelectFieldOptions;
+    duplicate(identifier: string): MultiSelectField;
+    setOptions(options: Partial<MultiSelectFieldOptions>): void;
+    static deserialize(data: SerializedMultiSelectField): MultiSelectField;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    render(props: ComponentProps): ReactNode;
 }

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

@@ -1,3 +1,6 @@
 import { ComponentProps } from '../typings';
 import { MultiSelectField } from './MultiSelectField';
-export declare const MultiSelectInput: import('react').MemoExoticComponent<(props: ComponentProps<MultiSelectField>) => import("react/jsx-runtime").JSX.Element>;
+export interface MultiSelectInputProps extends ComponentProps {
+    field: MultiSelectField;
+}
+export declare const MultiSelectInput: import('react').MemoExoticComponent<(props: MultiSelectInputProps) => import("react/jsx-runtime").JSX.Element>;

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

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

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

@@ -1,50 +1,30 @@
 import { ReactNode } from 'react';
-import { RiListCheck } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions, ConditionRenderProps } from '../BaseField';
-import { GetInputProps, InputFieldLevelValidator, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { ComponentProps, FieldValidator } from '../typings';
 import { SerializedMultiStringField } from './typings';
-type MultiStringFieldOptions = ChildFieldOptions<string[]> & {
+export interface MultiStringFieldOptions extends FieldOptions<string[]> {
     minimum_length?: number;
     maximum_length?: number;
     placeholder?: string;
-};
-export declare const emptyMultiStringField: {
-    type: string;
-    minimum_length: number;
-    maximum_length: null;
-    label: string;
-    description: string;
-    required: boolean;
-};
-/**
- * A field that lets the user input multiple strings. Each string must be unique. Useful for things like:
- * - Specifying the options of a SelectField (used in `SelectField.getFieldCreationSchema`
- * - Listing serial numbers and similar
- */
-export declare class MultiStringField extends BaseField<"multi-string", string[], string[], string[]> {
+}
+export declare class MultiStringField extends BaseField<"multi-string", string[], string[], MultiStringField> {
+    readonly type = "multi-string";
     static readonly fieldTypeName = "Multi-string";
     static readonly fieldTypeDescription = "Allows the user to provide multiple unique strings.";
-    readonly minLength: number;
-    readonly maxLength: number;
+    minLength: number;
+    maxLength: number;
+    placeholder: string;
     readonly onlyValidateAfterTouched = false;
-    readonly placeholder: string;
-    static Icon: typeof RiListCheck;
-    readonly defaultConditionValue: string[] | undefined;
-    readonly defaultConditionModifier: keyof typeof this.modifiers;
-    readonly modifiers: {
-        equals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        notEquals: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        every: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        some: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-        none: import('../../conditions/typings').FieldConditionModifierConfig<string[], string[], unknown, string[], string[], string[]>;
-    };
     constructor(options: MultiStringFieldOptions);
-    getInput(props: GetInputProps<this>): ReactNode;
+    render(props: ComponentProps): ReactNode;
     serialize(): SerializedMultiStringField;
-    protected isBlank(value: string[] | undefined): boolean;
+    getOptions(): MultiStringFieldOptions;
+    duplicate(identifier: string): MultiStringField;
+    setOptions(options: Partial<MultiStringFieldOptions>): void;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    isBlank(value: string[] | undefined): boolean;
     isEqual(value1: string[] | undefined, value2: string[] | undefined): boolean;
-    getFieldValidators(): InputFieldLevelValidator<string[]>[];
-    static deserialize(data: ISerializedField): MultiStringField;
-    renderCondition(props: ConditionRenderProps<MultiStringField>): ReactNode;
+    getFieldValidators(): FieldValidator<string[]>[];
+    static deserialize(data: SerializedMultiStringField): MultiStringField;
 }
-export {};

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

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

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

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