@overmap-ai/forms 1.0.30 → 1.0.32-condition-manager.0

package/dist/ImageViewer/context.d.ts

@@ -1,3 +1,3 @@
-import { FileViewerConfig } from './typings';
-export type ImageViewerContextType = (func: (close: () => void) => FileViewerConfig) => void;
+import { ImageViewerConfig } from './typings';
+export type ImageViewerContextType = (func: (close: () => void) => ImageViewerConfig) => void;
 export declare const ImageViewerContext: import('react').Context<ImageViewerContextType>;

package/dist/ImageViewer/typings.d.ts

@@ -1,4 +1,4 @@
-export interface FileViewerConfig {
+export interface ImageViewerConfig {
     file: File;
     onClose?: () => void;
 }

package/dist/Scanner/Scanner.d.ts

@@ -0,0 +1,7 @@
+import { Overlay } from '@overmap-ai/blocks';
+import { ComponentProps, ReactElement } from 'react';
+import { ZxingOptions } from './typings';
+export interface ScannerProps extends ComponentProps<typeof Overlay.Root>, ZxingOptions {
+    children?: ReactElement;
+}
+export declare const Scanner: import('react').NamedExoticComponent<ScannerProps>;

package/dist/Scanner/ScannerProvider.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare const ScannerProvider: import('react').MemoExoticComponent<(props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element>;

package/dist/Scanner/constants.d.ts

@@ -0,0 +1,3 @@
+import { BarcodeFormat } from '@zxing/library';
+import { DecodeHintType } from 'react-zxing';
+export declare const SCANNER_HINTS: Map<DecodeHintType, BarcodeFormat[]>;

package/dist/Scanner/context.d.ts

@@ -0,0 +1,3 @@
+import { ScannerConfig } from './typings';
+export type ScannerContextType = (func: (close: () => void) => ScannerConfig) => void;
+export declare const ScannerContext: import('react').Context<ScannerContextType>;

package/dist/Scanner/hooks.d.ts

@@ -0,0 +1 @@
+export declare const useScanner: () => import('./context').ScannerContextType;

package/dist/Scanner/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hooks';
+export * from './Scanner';
+export * from './ScannerProvider';
+export type * from './typings';

package/dist/Scanner/typings.d.ts

@@ -0,0 +1,5 @@
+import { UseZxingOptions } from 'react-zxing';
+export type ZxingOptions = Omit<UseZxingOptions, "hints">;
+export interface ScannerConfig extends ZxingOptions {
+    onClose?: () => void;
+}

package/dist/form/Observable/Observable.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class Observable<TObservable> {
+    readonly observers: Set<(observable: TObservable) => void>;
+    protected notify(observable: TObservable): void;
+    observe(callback: (observable: TObservable) => void): () => void;
+}

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

@@ -0,0 +1 @@
+export * from './Observable';

package/dist/form/UUIDFile/UUIDFile.d.ts

@@ -0,0 +1,5 @@
+export declare class UUIDFile extends File {
+    readonly uuid: string;
+    constructor(uuid: string, ...args: ConstructorParameters<typeof File>);
+    static from(uuid: string, file: File): UUIDFile;
+}

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

@@ -0,0 +1 @@
+export * from './UUIDFile';

package/dist/form/UUIDPromise/UUIDPromise.d.ts

@@ -0,0 +1,10 @@
+export declare class UUIDPromise<T> extends Promise<T> {
+    private _uuid;
+    constructor(executor: (...args: Parameters<ConstructorParameters<typeof Promise<T>>[0]>) => void, uuid: string);
+    get uuid(): string;
+    private set uuid(value);
+    static from<T>(promise: Promise<T> | PromiseLike<T>, uuid: string): UUIDPromise<T>;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): UUIDPromise<TResult1 | TResult2>;
+    catch<TResult2 = never>(onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): UUIDPromise<T | TResult2>;
+    finally(onFinally?: (() => void) | undefined | null): UUIDPromise<T>;
+}

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

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './UUIDPromise';

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

@@ -0,0 +1,4 @@
+import { UUIDFile } from '../UUIDFile';
+import { UUIDPromise } from './UUIDPromise';
+export declare function isFileAndPromiseArray(value: unknown): value is (UUIDPromise<UUIDFile> | UUIDFile)[];
+export declare function areFileAndPromiseArraysEqual(value1: (UUIDPromise<UUIDFile> | UUIDFile)[], value2: (UUIDPromise<UUIDFile> | UUIDFile)[]): boolean;

package/dist/form/builder/Root.d.ts

@@ -0,0 +1,15 @@
+import { PropsWithChildren } from 'react';
+import { SerializedFieldSection } from '../fields';
+import { FormBuilderSaveHandler } from './typings';
+export interface FormBuilderRootProps extends PropsWithChildren {
+    initialTitle?: string;
+    initialDescription?: string;
+    initialFields?: SerializedFieldSection[];
+    onSave: FormBuilderSaveHandler;
+    onCancel?: () => void;
+    hideTitle?: boolean;
+    hideDescription?: boolean;
+    enableReinitialize?: boolean;
+    disableRequiredFields?: boolean;
+}
+export declare const FormBuilderRoot: import('react').NamedExoticComponent<FormBuilderRootProps>;

package/dist/form/builder/components/FieldBuilder.d.ts

@@ -0,0 +1,8 @@
+import { Field } from '../../fields';
+import { NestedFieldPath } from '../typings';
+export interface FieldBuilderProps {
+    index: number;
+    parentPath: NestedFieldPath;
+    field: Field;
+}
+export declare const FieldBuilder: import('react').MemoExoticComponent<(props: FieldBuilderProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/components/FieldDropdownMenu.d.ts

@@ -0,0 +1,9 @@
+import { MenuRootProps, MenuVariantProps } from '@overmap-ai/blocks';
+import { ReactElement } from 'react';
+import { Field } from '../../fields';
+export interface FieldDropdownMenuProps extends MenuRootProps, MenuVariantProps {
+    children: ReactElement;
+    fields: Field[];
+    onSelectField: (field: Field) => void;
+}
+export declare const FieldDropdownMenu: import('react').NamedExoticComponent<FieldDropdownMenuProps>;

package/dist/form/builder/components/FieldSectionDropdownMenu.d.ts

@@ -0,0 +1,9 @@
+import { MenuRootProps, MenuVariantProps } from '@overmap-ai/blocks';
+import { ReactElement } from 'react';
+import { FieldSection } from '../../fields';
+export interface FieldSectionDropdownMenuProps extends MenuRootProps, MenuVariantProps {
+    children: ReactElement;
+    fieldSections: FieldSection[];
+    onSelectFieldCondition: (field: FieldSection) => void;
+}
+export declare const FieldSectionDropdownMenu: import('react').NamedExoticComponent<FieldSectionDropdownMenuProps>;

package/dist/form/builder/{FieldWithActions.d.ts → components/FieldWithActions.d.ts}

@@ -1,9 +1,10 @@
-import { ISerializedField } from '../fields';
+import { Field, FieldSection } from '../../fields';
 interface FieldWithActionsProps {
-    field: ISerializedField;
+    field: Field;
+    fieldSection: FieldSection;
     index: number;
     sectionIndex: number;
-    remove: () => void;
+    remove: (field: Field) => void;
 }
 export declare const FieldWithActions: import('react').MemoExoticComponent<(props: FieldWithActionsProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/form/builder/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './FieldBuilder';
+export * from './FieldDropdownMenu';
+export * from './FieldSectionDropdownMenu';
+export * from './FieldSettingsPopover';
+export * from './FieldWithActions';

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

@@ -1,20 +1,3 @@
-import { FieldSection } from '../fields';
 export declare const formId = "form-builder";
-export declare const fieldsToChoose: (("string" | "text")[] | ("select" | "radio" | "multi-select" | "upload" | "qr" | "checkbox-list")[] | ("number" | "boolean" | "date" | "multi-string")[])[];
-export declare const indexOfLastFieldGroup: number;
-export declare const CompleteFieldTypeToClsMapping: {
-    section: typeof FieldSection;
-    date: typeof import('..').DateField;
-    number: typeof import('..').NumberField;
-    boolean: typeof import('..').BooleanField;
-    select: typeof import('..').SelectField;
-    string: typeof import('..').StringField;
-    text: typeof import('..').TextField;
-    custom: typeof import('../fields/CustomField').CustomField;
-    upload: typeof import('..').UploadField;
-    qr: typeof import('..').ScanField;
-    "multi-string": typeof import('..').MultiStringField;
-    "multi-select": typeof import('..').MultiSelectField;
-    radio: typeof import('..').RadioField;
-    "checkbox-list": typeof import('..').CheckboxListField;
-};
+export declare const UNLABELLED_FIELD_LABEL = "Unlabelled";
+export declare const UNLABELLED_SECTION_LABEL = "Unlabelled";

package/dist/form/builder/context.d.ts

@@ -1,6 +1,8 @@
 interface IFormBuilderContext {
+    hideTitle: boolean;
+    hideDescription: boolean;
     disableRequiredFields: boolean;
-    fieldsOnly: boolean;
+    onCancel?: () => void;
 }
 export declare const FormBuilderContext: import('react').Context<IFormBuilderContext>;
 export {};

package/dist/form/builder/flow/FieldSectionConditionEdge.d.ts

@@ -0,0 +1,3 @@
+import { EdgeProps } from '@xyflow/react';
+import { FieldSectionConditionEdge } from './typings';
+export declare const FieldSectionConditionEdgeComponent: import('react').MemoExoticComponent<(props: EdgeProps<FieldSectionConditionEdge>) => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/flow/FieldSectionNode.d.ts

@@ -0,0 +1,3 @@
+import { NodeProps } from '@xyflow/react';
+import { FieldSectionNode } from './typings';
+export declare const FieldSectionNodeComponent: import('react').MemoExoticComponent<(props: NodeProps<FieldSectionNode>) => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/flow/FlowBuilder.d.ts

@@ -0,0 +1 @@
+export declare const FormBuilderFlowBuilder: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/flow/constants.d.ts

@@ -0,0 +1,3 @@
+import { EdgeTypes, NodeTypes } from '@xyflow/react';
+export declare const nodeTypes: NodeTypes;
+export declare const edgeTypes: EdgeTypes;

package/dist/form/builder/flow/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FlowBuilder';
+export { getLayoutedNodesAndEdges } from './layout';

package/dist/form/builder/flow/layout.d.ts

@@ -0,0 +1,2 @@
+import { FieldSectionConditionEdge, FieldSectionNode, LayoutDirection } from './typings';
+export declare const getLayoutedNodesAndEdges: (nodes: FieldSectionNode[], edges: FieldSectionConditionEdge[], direction: LayoutDirection) => [FieldSectionNode[], FieldSectionConditionEdge[]];

package/dist/form/builder/flow/typings.d.ts

@@ -0,0 +1,15 @@
+import { Edge, Node } from '@xyflow/react';
+import { FieldSection } from '../../fields';
+export type LayoutDirection = "LR" | "TB";
+export type FieldSectionNodeData = {
+    fieldSection: FieldSection;
+    index: number;
+    layoutDirection: LayoutDirection;
+};
+export type FieldSectionNode = Node<FieldSectionNodeData, "fieldSection">;
+export type FieldSectionConditionEdgeData = {
+    targetSection: FieldSection;
+    sourceSection: FieldSection;
+    layoutDirection: LayoutDirection;
+};
+export type FieldSectionConditionEdge = Edge<FieldSectionConditionEdgeData, "fieldSectionCondition">;

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

@@ -1,7 +1,7 @@
-import { FieldTypeIdentifier } from '../fields';
-export declare const useFieldTypeItems: (onSelect?: (type: Exclude<FieldTypeIdentifier, "section">) => void) => {
+import { FieldType } from '../fields';
+export declare const useFieldTypeItems: (onSelect?: (type: Exclude<FieldType, "section">) => void) => {
     children: string;
     icon: import("react/jsx-runtime").JSX.Element;
-    value: "string" | "number" | "boolean" | "select" | "text" | "radio" | "date" | "multi-string" | "multi-select" | "upload" | "qr" | "checkbox-list";
+    value: "string" | "number" | "boolean" | "select" | "text" | "radio" | "date" | "upload" | "checkbox-list" | "pass-fail" | "multi-select" | "multi-string" | "qr" | "otp";
     onSelect: () => void;
-}[][];
+}[];

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

@@ -1,2 +1,9 @@
 export type * from './typings';
-export * from './FormBuilder';
+export declare const FormBuilder: {
+    Root: import('react').NamedExoticComponent<import('./Root').FormBuilderRootProps>;
+    FlowBuilder: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    ListBuilder: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Preview: import('react').NamedExoticComponent<import('./preview').FormBuilderPreviewProps>;
+};
+export { createCondition } from './utils';
+export { createField } from './utils';

package/dist/form/builder/list/FieldSectionBuilder.d.ts

@@ -0,0 +1,5 @@
+import { FieldSection } from '../../fields';
+export interface FieldSectionBuilderProps {
+    fieldSection: FieldSection;
+}
+export declare const FieldSectionBuilder: import('react').MemoExoticComponent<(props: FieldSectionBuilderProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/list/FieldSectionConditionalItem.d.ts

@@ -0,0 +1,7 @@
+import { FieldSection } from '../../fields';
+interface FieldSectionConditionalItemProps {
+    sourceFieldSection: FieldSection;
+    targetFieldSection: FieldSection;
+}
+export declare const FieldSectionConditionalItem: import('react').NamedExoticComponent<FieldSectionConditionalItemProps>;
+export {};

package/dist/form/builder/list/FieldSectionWithActions.d.ts

@@ -0,0 +1,6 @@
+import { FieldSection } from '../../fields';
+export interface FieldSectionWithActionsProps {
+    fieldSection: FieldSection;
+    index: number;
+}
+export declare const FieldSectionWithActions: import('react').MemoExoticComponent<(props: FieldSectionWithActionsProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/list/ListBuilder.d.ts

@@ -0,0 +1 @@
+export declare const FormBuilderListBuilder: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/form/builder/list/index.d.ts

@@ -0,0 +1 @@
+export * from './ListBuilder';

package/dist/form/builder/preview/Preview.d.ts

@@ -0,0 +1,4 @@
+export interface FormBuilderPreviewProps {
+    showFormTitle?: boolean;
+}
+export declare const FormBuilderPreview: import('react').NamedExoticComponent<FormBuilderPreviewProps>;

package/dist/form/builder/preview/index.d.ts

@@ -0,0 +1 @@
+export * from './Preview';

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

@@ -1,24 +1,5 @@
-import { FormikHelpers } from 'formik';
-import { ISerializedField, ISerializedOnlyField } from '../fields';
-import { SerializedFieldSection } from '../fields/FieldSection/typings';
-import { DropState } from './DropDispatch';
-import { FormBuilderValues, NestedFieldPath } from './typings';
-export declare const isSection: (field: ISerializedField) => field is SerializedFieldSection;
-export declare const emptySection: (id?: string, fields?: ISerializedOnlyField[]) => SerializedFieldSection;
-export declare const wrapRootFieldsWithFieldSection: (fields: ISerializedField[]) => SerializedFieldSection[];
-export declare function reorder<T>(list: T[], source: number, destination: number): T[];
-export declare function replace<T>(list: T[], index: number, value: T): T[];
-export declare function insert<T>(list: T[] | undefined, index: number, value: T): T[];
-export declare function remove<T>(list: T[], index: number): T[];
-export declare const makeIdentifier: () => string;
-export declare const findFieldByIdentifier: (fields: ISerializedField[], identifier?: string) => ISerializedField | null;
-export declare const makeConditionalSourceFields: (sections: SerializedFieldSection[], index: number) => (import('..').SerializedTextField | import('..').SerializedBooleanField | import('..').SerializedNumberField | import('..').SerializedDateField | import('..').SerializedStringField | import('..').SerializedSelectField | import('..').SerializedMultiStringField | import('..').SerializedMultiSelectField | import('..').SerializedUploadField | import('..').SerializedScanField | import('..').SerializedRadioField | import('..').SerializedCheckboxListField)[];
-export type NewFieldInitialValues = Omit<ISerializedField, "identifier"> & {
-    label: string;
-};
-export declare const createNewField: (parentPath: NestedFieldPath, index: number, initialValues: NewFieldInitialValues, values: FormBuilderValues, setFieldValue: FormikHelpers<unknown>["setFieldValue"]) => void;
-export declare const createNewEmptySection: (index: number, values: FormBuilderValues, setFieldValue: FormikHelpers<unknown>["setFieldValue"]) => void;
-export declare const useFieldReordering: () => {
-    reorderSection: (dropState: DropState, sectionId: string, sectionIndex: number, destinationIndex: number, values: FormBuilderValues, setFieldValue: FormikHelpers<unknown>["setFieldValue"]) => void;
-    reorderField: (srcSection: SerializedFieldSection | undefined, srcSectionIndex: string | number | undefined, srcFieldIndex: number, destSection: SerializedFieldSection | undefined, destSectionIndex: string | number | undefined, destFieldIndex: number, setFieldValue: FormikHelpers<unknown>["setFieldValue"]) => void;
-};
+import { BooleanFieldCondition, CheckboxListFieldCondition, DateFieldCondition, MultiSelectFieldCondition, MultiStringFieldCondition, NumberFieldCondition, OTPFieldCondition, PassFailFieldCondition, RadioFieldCondition, ScanFieldCondition, SelectFieldCondition, StringFieldCondition, TextFieldCondition, UploadFieldCondition } from '../conditions';
+import { Field, FieldCreationSchemaObject, FieldType } from '../fields';
+export declare const createField: (type: Exclude<FieldType, "section">) => Field;
+export declare const createCondition: (field: Field) => BooleanFieldCondition | CheckboxListFieldCondition | DateFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | OTPFieldCondition | PassFailFieldCondition | RadioFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition;
+export declare const getFieldCreationSchema: (type: FieldType, path: string) => FieldCreationSchemaObject[] | undefined;

package/dist/form/components/DisplayFile.d.ts

@@ -0,0 +1,9 @@
+import { UUIDFile } from '../UUIDFile';
+import { UUIDPromise } from '../UUIDPromise';
+interface DisplayFileProps {
+    file: UUIDFile | UUIDPromise<UUIDFile>;
+    disabled?: boolean;
+    onRemove: () => void;
+}
+export declare const DisplayFile: import('react').MemoExoticComponent<(props: DisplayFileProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -0,0 +1 @@
+export * from './DisplayFile';

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

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { AnyField, TypeOfField, ValueOfField } from '../../fields';
+import { AnyConditionModifierConfig } from '../../modifiers';
+import { Observable } from '../../Observable';
+import { BaseSerializedCondition, ConditionRenderProps } from './typings';
+export interface ConditionOptions<TField, TConditionValue, TModifiers extends string> {
+    id: string;
+    field: TField;
+    conditionValue: TConditionValue | undefined;
+    conditionModifier: TModifiers;
+}
+export declare abstract class BaseCondition<TField extends AnyField, TValue, TConditionValue, TSerializedConditionValue, TModifiers extends string, This extends BaseCondition<TField, TValue, TConditionValue, TSerializedConditionValue, TModifiers, This>> extends Observable<This> {
+    readonly id: string;
+    conditionValue: TConditionValue | undefined;
+    conditionModifier: TModifiers;
+    field: TField;
+    abstract readonly defaultConditionValue: TConditionValue | undefined;
+    abstract readonly defaultConditionModifier: TModifiers;
+    abstract readonly modifiers: Record<TModifiers, AnyConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue>>;
+    protected constructor(config: ConditionOptions<TField, TConditionValue, TModifiers>);
+    serialize(): BaseSerializedCondition<TypeOfField<TField>, TSerializedConditionValue, TModifiers>;
+    getConditionValue: () => TConditionValue | undefined;
+    transformValue(value: ValueOfField<TField>): TValue;
+    setConditionValue: (conditionValue: TConditionValue | undefined) => void;
+    getConditionModifier: () => TModifiers;
+    setConditionModifier: (modifier: TModifiers) => void;
+    getConditionModifiers: () => [keyof typeof this.modifiers, AnyConditionModifierConfig<ValueOfField<TField>, TConditionValue, TSerializedConditionValue>][];
+    abstract render(props: ConditionRenderProps<this>): ReactNode;
+    apply: (value: ValueOfField<TField>) => boolean;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { AnyField } from '../../fields';
+import { BaseCondition } from './BaseCondition';
+export type AnyCondition = BaseCondition<AnyField, any, any, any, any, any>;
+export type ModifiersOfCondition<TCondition> = TCondition extends BaseCondition<infer _TField, infer _TValue, infer _TConditionValue, infer _TSerializedConditionValue, infer TConditionModifiers, infer _This> ? TConditionModifiers : never;
+export interface ConditionRenderProps<TCondition> {
+    onRemove: (condition: TCondition) => void;
+}
+export interface BaseConditionCellProps<TCondition> extends ConditionRenderProps<TCondition> {
+    condition: TCondition;
+}
+export interface BaseSerializedCondition<TIdentifier extends string, TSerializedConditionValue, TModifier extends string> {
+    id: string;
+    type: TIdentifier;
+    fieldId: string;
+    conditionValue: TSerializedConditionValue;
+    conditionModifier: TModifier;
+}
+export type AnySerializedCondition = BaseSerializedCondition<any, any, any>;

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

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { BooleanField, ValueOfField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { BooleanConditionModifiers, SerializedBooleanCondition } from './typings';
+export interface BooleanFieldConditionOptions extends ConditionOptions<BooleanField, boolean, BooleanConditionModifiers> {
+}
+export declare class BooleanFieldCondition extends BaseCondition<BooleanField, ValueOfField<BooleanField>, boolean, boolean, BooleanConditionModifiers, BooleanFieldCondition> {
+    readonly defaultConditionModifier = "equals";
+    readonly defaultConditionValue: undefined;
+    readonly modifiers: {
+        equals: import('../..').FieldConditionModifierConfig<boolean, boolean, boolean, boolean, boolean, boolean>;
+        notEquals: import('../..').FieldConditionModifierConfig<boolean, boolean, boolean, boolean, boolean, boolean>;
+    };
+    constructor(options: BooleanFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedBooleanCondition, field: BooleanField): BooleanFieldCondition;
+    render(props: ConditionRenderProps<BooleanFieldCondition>): ReactNode;
+}

package/dist/form/conditions/BooleanFieldCondition/BooleanFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { BooleanFieldCondition } from './BooleanFieldCondition';
+interface BooleanFieldConditionCellProps extends BaseConditionCellProps<BooleanFieldCondition> {
+}
+export declare const BooleanFieldConditionCell: (props: BooleanFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './BooleanFieldCondition';
+export * from './BooleanFieldConditionCell';
+export type * from './typings';

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

@@ -0,0 +1,4 @@
+import { BooleanField, TypeOfField, ValueOfField } from '../../fields';
+import { BaseSerializedCondition } from '../BaseCondition';
+export type BooleanConditionModifiers = "equals" | "notEquals";
+export type SerializedBooleanCondition = BaseSerializedCondition<TypeOfField<BooleanField>, ValueOfField<BooleanField>, BooleanConditionModifiers>;

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

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { CheckboxListField, ValueOfField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { CheckboxListConditionModifiers, SerializedCheckboxListCondition } from './typings';
+export interface CheckboxListFieldConditionOptions extends ConditionOptions<CheckboxListField, string[], CheckboxListConditionModifiers> {
+}
+export declare class CheckboxListFieldCondition extends BaseCondition<CheckboxListField, ValueOfField<CheckboxListField>, string[], string[], CheckboxListConditionModifiers, CheckboxListFieldCondition> {
+    readonly defaultConditionModifier = "equals";
+    readonly defaultConditionValue: string[] | undefined;
+    readonly modifiers: {
+        equals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        notEquals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        every: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        some: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        none: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    };
+    constructor(options: CheckboxListFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedCheckboxListCondition, field: CheckboxListField): CheckboxListFieldCondition;
+    render(props: ConditionRenderProps<CheckboxListFieldCondition>): ReactNode;
+}

package/dist/form/conditions/CheckboxListFieldCondition/CheckboxListFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { CheckboxListFieldCondition } from './CheckboxListFieldCondition';
+interface CheckboxListFieldConditionCellProps extends BaseConditionCellProps<CheckboxListFieldCondition> {
+}
+export declare const CheckboxListFieldConditionCell: (props: CheckboxListFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './CheckboxListFieldCondition';
+export * from './CheckboxListFieldConditionCell';
+export type * from './typings';

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

@@ -0,0 +1,4 @@
+import { CheckboxListField, TypeOfField } from '../../fields';
+import { BaseSerializedCondition } from '../BaseCondition';
+export type CheckboxListConditionModifiers = "equals" | "notEquals" | "every" | "some" | "none";
+export type SerializedCheckboxListCondition = BaseSerializedCondition<TypeOfField<CheckboxListField>, string[], CheckboxListConditionModifiers>;

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

@@ -0,0 +1,15 @@
+import { Observable } from '../../Observable';
+import { FieldValues } from '../../typings';
+import { Condition } from '../typings';
+export declare class ConditionManager extends Observable<ConditionManager> {
+    private conditions;
+    constructor(conditions: Condition[]);
+    private conditionObserver;
+    private initConditions;
+    getConditions(): Condition[];
+    addCondition(condition: Condition): void;
+    addConditions(conditions: Condition[]): void;
+    removeCondition(condition: Condition): void;
+    removeConditions(conditions: Condition[]): void;
+    applyConditions(values: FieldValues): boolean;
+}

package/dist/form/conditions/ConditionManager/hooks.d.ts

@@ -0,0 +1,4 @@
+import { Condition } from '../typings';
+import { ConditionManager } from './ConditionManager';
+import { ConditionsChangeEventHandler } from './typings';
+export declare const useConditionManager: (conditions: Condition[], onConditionsChange: ConditionsChangeEventHandler) => ConditionManager;

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

@@ -0,0 +1,3 @@
+export * from './ConditionManager';
+export * from './hooks';
+export type * from './typings';

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

@@ -0,0 +1,2 @@
+import { Condition } from '../typings';
+export type ConditionsChangeEventHandler = (conditions: Condition[]) => void;

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

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { DateRange } from 'react-day-picker';
+import { DateField, SerializedDateRange, ValueOfField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { DateConditionModifiers, SerializedDateCondition } from './typings';
+export interface DateFieldConditionOptions extends ConditionOptions<DateField, Date | DateRange, DateConditionModifiers> {
+}
+export declare class DateFieldCondition extends BaseCondition<DateField, ValueOfField<DateField>, Date | DateRange, string | SerializedDateRange, DateConditionModifiers, DateFieldCondition> {
+    readonly defaultConditionModifier = "equals";
+    readonly defaultConditionValue: undefined;
+    readonly modifiers: {
+        equals: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, Date, string>;
+        notEquals: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, Date, string>;
+        before: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, Date, string>;
+        after: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, Date, string>;
+        in: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, DateRange, SerializedDateRange>;
+        notIn: import('../..').FieldConditionModifierConfig<Date | null, Date | DateRange, string | SerializedDateRange, Date, DateRange, SerializedDateRange>;
+    };
+    constructor(options: DateFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedDateCondition, field: DateField): DateFieldCondition;
+    render(props: ConditionRenderProps<DateFieldCondition>): ReactNode;
+}

package/dist/form/conditions/DateFieldCondition/DateFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { DateFieldCondition } from './DateFieldCondition';
+interface DateFieldConditionCellProps extends BaseConditionCellProps<DateFieldCondition> {
+}
+export declare const DateFieldConditionCell: (props: DateFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,3 @@
+export * from './DateFieldCondition';
+export * from './DateFieldConditionCell';
+export type * from './typings';

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

@@ -0,0 +1,4 @@
+import { DateField, SerializedDateRange, TypeOfField } from '../../fields';
+import { BaseSerializedCondition } from '../BaseCondition';
+export type DateConditionModifiers = "equals" | "notEquals" | "before" | "after" | "in" | "notIn";
+export type SerializedDateCondition = BaseSerializedCondition<TypeOfField<DateField>, string | SerializedDateRange, DateConditionModifiers>;

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

@@ -0,0 +1,28 @@
+import { ReactNode } from 'react';
+import { MultiSelectField, ValueOfField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { MultiSelectConditionModifiers, SerializedMultiSelectCondition } from './typings';
+declare const modifiers: {
+    equals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    notEquals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    every: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    some: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    none: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+};
+export interface MultiSelectFieldConditionOptions extends ConditionOptions<MultiSelectField, string[], MultiSelectConditionModifiers> {
+}
+export declare class MultiSelectFieldCondition extends BaseCondition<MultiSelectField, ValueOfField<MultiSelectField>, string[], string[], MultiSelectConditionModifiers, MultiSelectFieldCondition> {
+    readonly defaultConditionValue: string[] | undefined;
+    readonly defaultConditionModifier: keyof typeof modifiers;
+    readonly modifiers: {
+        equals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        notEquals: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        every: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        some: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+        none: import('../..').FieldConditionModifierConfig<string[], string[], string[], string[], string[], string[]>;
+    };
+    constructor(options: MultiSelectFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedMultiSelectCondition, field: MultiSelectField): MultiSelectFieldCondition;
+    render(props: ConditionRenderProps<MultiSelectFieldCondition>): ReactNode;
+}
+export {};