@bolttech/form-engine 0.14.3 → 3.0.0-beta.2

package/src/core/types/index.d.ts

@@ -1,937 +0,0 @@
-/// <reference types="react" />
-import { ICustomValidationValue } from '@core/apis/validations';
-import { EEVents } from '@core/constants';
-import { TEventInformation } from '@core/events';
-import Field from "@core/managers/Field";
-export declare type TObserverData<T> = {
-    data: any;
-    event: TEventsKeys;
-    namespace: string;
-    payload: T;
-};
-export declare type TObservable = (data: any, unsubscribe: () => void) => any;
-export declare type TEvents = Record<string, TObservable[]>;
-export interface IObservable {
-    events: TEvents;
-}
-export declare type TScopeNamespaces = 'global' | 'api' | 'hooks' | 'fields' | 'configs';
-export declare type TSetGlobalScope = {
-    namespace: TScopeNamespaces;
-    key?: string;
-    data: any;
-    merge?: boolean;
-};
-export declare type TScope = {
-    global?: any;
-    api?: any;
-    hooks?: any;
-    configs?: TConfigs & {
-        disable?: boolean;
-        enableLogging?: boolean;
-    };
-    fields?: any;
-};
-export declare type TFactoryOptions = {
-    schema?: TSchema;
-    initialScope?: TScope;
-    initialValues?: Record<string, any>;
-    newInstance?: boolean;
-    group?: string;
-};
-export declare type TMapper = Record<string, Record<string, unknown>>;
-export declare type TMaskGeneric = {
-    to: number;
-    from: number;
-    mask: string;
-}[];
-declare type TCurrencyMask = {
-    locale: string;
-    currency: string;
-};
-export declare type TComponentMasks = {
-    generic?: TMaskGeneric;
-    cardNumber?: boolean;
-    hideCardNumber?: boolean;
-    cardMask?: boolean;
-    cardDate?: boolean;
-    currencyMask?: TCurrencyMask;
-    feinMask?: boolean;
-    replaceAll?: string | number;
-    callback?(value: string | number): string | number;
-};
-declare type TFormMessages = Record<string, {
-    name: string;
-    value?: any;
-    values?: string[];
-    required?: boolean;
-}>;
-export declare type TChildrenOptions = {
-    childrenScope?: string[];
-    blurredChildren?: string[];
-    changedChildren?: string[];
-    scopeBlurredChildren?: boolean;
-    scopeChangedChildren?: boolean;
-};
-export declare type TFieldData = Record<string, TField>;
-export declare type TFields = {
-    [x in string]: Field;
-};
-export declare type TSubmitValueData = Record<string, {
-    value?: unknown;
-    props?: Record<string, unknown>;
-}>;
-export declare type TFormRefActions = {
-    submit(): void;
-    step(index: number | string): TFormValues;
-    stepForward(index?: number | string): TFormValues;
-    stepBack(index?: number | string): TFormValues;
-    validateForm(opts?: TChildrenOptions): Promise<TFormValues>;
-    bindFields(payload: TSubmitValueData): void;
-    values(opts: Pick<TChildrenOptions, 'scopeBlurredChildren' | 'scopeChangedChildren' | 'childrenScope'>): TFormValues;
-};
-export declare type THookPayload = {
-    setScope(data: TSetGlobalScope): void;
-};
-export declare type THooks = {
-    preMount?: () => Record<string, unknown>;
-    preUnmount?: () => Record<string, unknown>;
-    preSubmit?: (formData: TFormValues) => Record<string, unknown>;
-    posSubmit?: (formData: TFormValues) => Record<string, unknown>;
-};
-export declare type TIVars = Record<string, unknown>;
-export declare type TEventsKeys = keyof typeof EEVents;
-export declare enum TAvailableHooks {
-    'preMount' = "preMount",
-    'preUnmount' = "preUnmount",
-    'preSubmit' = "preSubmit",
-    'postSubmit' = "postSubmit"
-}
-export declare type TField = {
-    value?: string | number | boolean;
-    errors?: TErrors;
-    visible?: boolean;
-    failedErrorMessages?: string[];
-    mask?: string;
-    changed?: boolean;
-    keyup?: boolean;
-    keydown?: boolean;
-    blured?: boolean;
-    focused?: boolean;
-    name: string;
-    mounted: boolean;
-    metadata?: any;
-    ignore?: boolean;
-    schemaLocation?: {
-        step: number;
-        depth: number;
-        index: number;
-    };
-};
-declare type TPathError = Omit<TSchemaValidation, 'path'> & {
-    path?: string;
-    paths?: string[];
-    preventUnMountValidation?: boolean;
-};
-export declare type TValidationDateFormats = 'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD' | 'YYYYDDMM' | 'timestamp';
-export declare type TValidationDateOperators = '<' | '>' | '===' | '>=' | '<=' | '!==' | '!!origin';
-export declare type TVAvailableValidationConditionsSet = {
-    forceDefinedOrigin?: boolean;
-    forceDefinedTarget?: boolean;
-    origin?: string | number | boolean;
-    condition: TValidationDateOperators;
-    target?: string | number | boolean;
-};
-export declare type TVAvailableValidationConditions = {
-    rule: 'and' | 'or';
-    set: TVAvailableValidationConditionsSet[];
-    conditions?: TVAvailableValidationConditions;
-};
-export declare type TVAvailableValidationMultipleValidations = {
-    rule: 'AND' | 'OR' | 'NOT';
-    validations: TVAvailableValidations;
-};
-export declare type TVAvailableValidations = {
-    /**
-     * The bool function is a validation function that checks if a given value indicating whether the validation has failed or not.
-     *
-     * @example - in a test environment
-     * ```
-     * const result = bool({
-     *   validationValue: false,
-     * });
-     * console.log(result); // { fail: false }
-     * ```
-     *
-     * @example - real json usage with field value
-     * ```
-     * {
-     *   validations: {
-     *      bool: '${fields.input.value}'
-     *   },
-     * },
-     * ```
-     *
-     * @example - real json usage with iVar value
-     * ```
-     * {
-     *   validations: {
-     *      bool: '${global.validation}'
-     *   },
-     * },
-     * ```
-     */
-    bool?: string | boolean;
-    /**
-     * Validation based on conditions
-     *
-     * @example - Compare own field to two. Origin and target default to field value
-     * ```
-     * conditions: {
-     *   rule: 'and',
-     *   set: [
-     *     {
-     *       condition: '===',
-     *       target: '2',
-     *     },
-     *     {
-     *       origin: '2',
-     *       condition: '===',
-     *     },
-     *   ],
-     * },
-     * ```
-     * @example - Binded to Postcode field value. Must be greater than or equal two
-     * ```
-     * conditions: {
-     *   rule: 'or',
-     *   set: [
-     *     {
-     *       origin: '${fields.postcode.value}',
-     *       condition: '>',
-     *       target: '2',
-     *     },
-     *     {
-     *       origin: '${fields.postcode.value}',
-     *       condition: '===',
-     *       target: '2',
-     *     },
-     *   ],
-     * },
-     * ```
-     * @example - Binded to Postcode field value. Must be equal to two
-     * ```
-     * conditions: {
-     *   rule: 'or',
-     *   set: [
-     *     {
-     *       origin: '${fields.postcode.value}',
-     *       condition: '===',
-     *       target: '2',
-     *     },
-     *   ],
-     * },
-     * ```
-     */
-    conditions?: TVAvailableValidationConditions;
-    /**
-     * Applies multiple validations on the given value based on the specified truth table rule.
-     *
-     * @param {Object} TVAvailableValidationMultipleValidations - The multiple validations object param.
-     * @param {'AND' | 'OR' | 'NOT'} TVAvailableValidationMultipleValidations.rule - The rule to be applied based of truth table ('AND', 'OR', or 'NOT').
-     * @param {Object} TVAvailableValidationMultipleValidations.validations - Object containing validation rules.
-     *
-     * @example - Validating with the expression AND where current field must have a value of 'yes' and input 2 must have a value of 'no'
-     * ```
-     * multipleValidations: {
-     *   rule: 'AND',
-     *   validations: {
-     *      value: 'yes',
-     *      conditions: {
-     *        rule: 'and',
-     *        set: [
-     *          {
-     *            origin: '${fields.input2.value}',
-     *            condition: '===',
-     *            target: 'no'
-     *          },
-     *        ],
-     *      },
-     *   },
-     * },
-     * ```
-     * @example - Validating with the expression OR where current field must have a value of '1995-12-12' or be a valid date with regex
-     * ```
-     * multipleValidations: {
-     *   rule: 'OR',
-     *   validations: {
-     *      value: '1995-12-12',
-     *      regex: '^\d{4}-\d{2}-\d{2}$',
-     *   },
-     * },
-     * ```
-     * @example - Validating with the expression NOT where current field doesn't have a value of '1995-12-12' and not be a valid date with regex
-     * ```
-     * multipleValidations: {
-     *   rule: 'NOT',
-     *   validations: {
-     *      value: '1995-12-12',
-     *      regex: '^\d{4}-\d{2}-\d{2}$',
-     *   },
-     * },
-     * ```
-     */
-    multipleValidations?: TVAvailableValidationMultipleValidations;
-    /**
-     * Between validations
-     *
-     * @example - Between ages
-     * ```    type teste = Pick<TVAvailableValidations, 'date'>
-     * between: {
-     *   dates: [
-     *     {
-     *       operator: '>=',
-     *       origin: {
-     *         format: 'YYYYMMDD',
-     *         intervals: {
-     *           years: 18,
-     *         },
-     *       },
-     *     },
-     *     {
-     *       operator: '<=',
-     *       origin: {
-     *         format: 'YYYYMMDD',
-     *         intervals: {
-     *           years: 75,
-     *         },
-     *       },
-     *     }
-     *   ]
-     * }
-     * ```
-     *
-     * @example - Between numbers
-     * ```
-     *  between: {
-     *    start: '3',
-     *    end: '4',
-     *    isIncludedBoundaries: true
-     *  },
-     *  ```
-     *
-     */
-    between?: {
-        /**
-         * Array of date validations. To make it possible, ensure that the conditions is > and < in both date validations.
-         */
-        dates?: TVAvailableValidations['date'][];
-        /**
-         * The first number of the validation. If the current value is grater than this number, the validation will pass.
-         */
-        start?: number;
-        /**
-         * The second number of the validation. If the current value is lower than this number, the validation will pass.
-         */
-        end?: number;
-        /**
-         * If it's true, the comparision is transformed to >= and <=. So, the numbers that were passed are included in the validation.
-         */
-        isIncludedBoundaries?: boolean;
-    };
-    /**
-     * Dates validations
-     *
-     * @example - Dates should be different
-     * ```
-     * date: {
-     *   operator: '!==',
-     *   origin: {
-     *     format: 'DDMMYYYY',
-     *   },
-     *   target: {
-     *     format: 'DDMMYYYY',
-     *     value: '10/10/2001',
-     *   },
-     * },*
-     * ```
-     *
-     * @example - Compare only valid dates using intervals
-     * ```
-     *  date: {
-     *    onlyValidDate: true,
-     *    operator: '<',
-     *    origin: {
-     *      format: 'DD/MM/YYYY',
-     *      intervals: {
-     *        years: 1,
-     *      },
-     *    },
-     *  },
-     *  ```
-     *
-     * @example - Should have at max 85 years
-     * ```
-     * {
-     *    operator: '>',
-     *    origin: {
-     *      format: 'DDMMYYYY',
-     *      value: eightyFiveYearsDate,
-     *      intervals: {
-     *        years: 85,
-     *      },
-     *    },
-     *  }
-     * }
-     *
-     * ```
-     */
-    date?: {
-        /**
-         * Flag to force only valid dates. Valid dates must be of min length of 8
-         */
-        onlyValidDate?: boolean;
-        /**
-         * List of operations you can do
-         * - between origin and target dates
-         * - between origin and intervals
-         */
-        operator: TValidationDateOperators;
-        /**
-         *  The origin configurations
-         */
-        origin: {
-            /**
-             * Origin date value
-             */
-            value?: string | number;
-            /**
-             * The available date formats
-             */
-            format: TValidationDateFormats;
-            /**
-             * Intervals to compare with the original date.
-             *
-             * It will use todays date for comparison.
-             *
-             * @example
-             *
-             * origin date = 10/10/2022
-             * interval.year = 1
-             * operator = '==='
-             *
-             * It will compare (10/10/2022 + 1) with the current date and check if they are the same
-             */
-            intervals?: {
-                years?: number;
-                months?: number;
-                days?: number;
-            };
-        };
-        target?: {
-            value: string | number;
-            format: TValidationDateFormats;
-        };
-    };
-    /**
-     * Allow to validate if the input string is a valid date format
-     */
-    validDate?: TValidationDateFormats;
-    /**
-     * Allow to define a maximum length for the input to have no error
-     */
-    length?: number;
-    /**
-     * Will look into the input length and send an error if is not greater than this value
-     */
-    greaterThan?: number | string;
-    /**
-     * Specifies a regular expression pattern that the value should match.
-     */
-    regex?: string;
-    /**
-     * Specifies the maximum length of the value (if it's a string).
-     */
-    maxLength?: number;
-    /**
-     * Specifies the minimum length of the value (if it's a string).
-     */
-    minLength?: number;
-    /**
-     * Specifies whether the field is required.
-     */
-    required?: boolean;
-    /**
-     * Specifies that the value should contain only letters.
-     */
-    onlyLetters?: boolean;
-    /**
-     * Specifies a value that the field should match.
-     */
-    value?: string | number | boolean;
-    /**
-     * Specifies that the field should not be empty.
-     */
-    notEmpty?: boolean;
-    /**
-     * A callback function that performs custom validation on the value.
-     * @param value - The value to be validated.
-     * @returns An object with validation results.
-     */
-    callback?(value: string | number): {
-        fail: boolean;
-        errorMessage?: string;
-    };
-    /**
-     * Specifies a numeric range for the value.
-     */
-    numericRange?: {
-        start: number | string;
-        end: number | string;
-    };
-    /**
-     * Specifies whether the value should be a number.
-     */
-    isNumber?: boolean;
-    /**
-     * Specifies that the field should not have extra spaces.
-     */
-    hasNoExtraSpaces?: boolean;
-    /**
-     * Specifies that the value should be an email address.
-     */
-    email?: boolean;
-    /**
-     * Specifies that the value should be less than a given number or string.
-     */
-    lessThan?: number | string;
-    /**
-     * Specifies that the value should be a sequential number.
-     */
-    sequentialNumber?: boolean;
-    /**
-     * Specifies that the value should not contain repeated numbers.
-     */
-    repeatedNumbers?: boolean;
-    /**
-     * Specifies that the value should be a URL.
-     */
-    url?: boolean;
-    /**
-     * Specifies a path error type.
-     */
-    path?: TPathError;
-    /**
-     * Specifies that the value should be a valid credit card number.
-     */
-    isCreditCard?: string[];
-    /**
-     * Specifies that the value should be a valid credit card number with a specific length.
-     */
-    isCreditCardAndLength?: string[];
-    /**
-     * Specifies that the value should match a credit card code with available options.
-     */
-    isCreditCodeMatch?: {
-        numberCard: string;
-        availableOptions: string[];
-    };
-    /**
-     * Specifies custom validation options for the field.
-     */
-    customValidation?: ICustomValidationValue[];
-    /**
-     * Specifies that spaces are not allowed in the field.
-     */
-    notAllowSpaces?: true;
-    /**
-     * Specifies that the value should be in a predefined list of values.
-     */
-    isInTheList?: string[] | number[] | string;
-    /**
-     * Specifies field validation rules for nested fields.
-     */
-    fields?: {
-        /**
-         * The rule for validating nested fields (e.g., 'every').
-         */
-        rule: 'every';
-        /**
-         * An array of nested field validation configurations.
-         */
-        set: {
-            /**
-             * The binding for the nested field.
-             */
-            bind: string;
-            /**
-             * The field name for the nested field.
-             */
-            fieldName: string;
-            /**
-             * Validation options for the nested field, excluding the 'fields' property.
-             */
-            validations: Omit<TVAvailableValidations, 'fields'>;
-        }[];
-    };
-    /**
-     * Specifies that the value should be existed.
-     */
-    exists?: string | number;
-};
-export declare type TGenericValidationRule = {
-    [key: string]: TVAvailableValidations;
-};
-export declare type TSchemaValidation = TVAvailableValidations | TGenericValidationRule;
-export declare type TStepData = {
-    navigated: boolean;
-    index: number;
-    data: Record<number, Pick<TFormValues, 'fields' | 'erroredFields' | 'formatted' | 'filteredFields'>>;
-    currentStepSchema?: TComponent;
-    isValid: boolean;
-    numSteps?: number;
-};
-export declare type TFormValues = {
-    predictableErroredFields: string[];
-    erroredFields: string[];
-    fields: TFieldData;
-    formatted: Record<string, unknown>;
-    filteredFields?: Record<string, unknown>;
-    form: {
-        steps: TStepData;
-        isValid: boolean;
-        messages: string[];
-        scope: TScope;
-    };
-};
-export declare type TError = {
-    value: unknown;
-    message?: string;
-    fail: boolean;
-};
-export declare type TErrors = Record<string, TError> | undefined;
-export declare type TErrorMessages = Record<string, string>;
-export declare type TSchemaValidations = TSchemaHandler<TSchemaValidation>;
-declare type TFormLevelSchemaHandler<T> = Partial<Record<EEVents.AFTER_FIELD_API_CALL | EEVents.ON_FIELD_CHANGE | EEVents.ON_FIELD_KEYUP | EEVents.ON_FIELD_KEYDOWN | EEVents.ON_FORM_REHYDRATE | EEVents.ON_FORM_MOUNT | EEVents.ON_SCOPE_CHANGE, T>>;
-declare type TSchemaHandler<T> = Partial<Record<EEVents.AFTER_FIELD_API_CALL | EEVents.ON_FIELD_REHYDRATE | EEVents.ON_FIELD_CLEARED | EEVents.ON_FIELD_BINDED | EEVents.ON_FIELD_CHANGE | EEVents.ON_FIELD_KEYUP | EEVents.ON_FIELD_KEYDOWN | EEVents.ON_FIELD_BLUR | EEVents.ON_FIELD_MOUNT | EEVents.ON_FIELD_FOCUS | EEVents.ON_FIELD_CLICK, T>>;
-export declare type TSchemaVisibilityConditions = {
-    /**
-     * Enables visibility of fields only if any or all validation conditions are positive.
-     *
-     * The default is false, so if all validations are false, the field will display, if any are positive,
-     * the field will hide, as well as if all are positive.
-     */
-    showOnlyIfTrue?: boolean;
-    /**
-     * Allows you to choose the type of chain for validations.
-     *
-     * The default is OR, where at least one validation needs to be true to work. In the case of AND,
-     * all validations must be true.
-     */
-    rule?: 'or' | 'and';
-    /**
-     * The validations that will say if the target field will be visible or not
-     *
-     * Those validations will run against your field (the one that has this directive)
-     */
-    validations: TSchemaValidation;
-    /**
-     * Target field that will have the visibility toggled
-     */
-    fieldName?: string;
-    /**
-     * Target fields that will have the visibility toggled
-     */
-    fieldNames?: string[];
-}[];
-export declare type TClearFieldValue = string | number | boolean;
-export declare type TClearField = {
-    /**
-     * The clearValues runs validations on the target field and not on the field it is declaring.
-     * Therefore, set this prop with true if you want validations to be performed on the current field.
-     */
-    useCurrentFieldValidation?: boolean;
-    /**
-     * Validations to run for the target field
-     */
-    validations?: TSchemaValidation | TSchemaValidation[];
-    /**
-     * target fields that will be used in the validation specified
-     */
-    fields: string[];
-    /**
-     * The cleared values on the fields in case they do not pass the validation
-     */
-    clearedValue: TClearFieldValue | TClearFieldValue[];
-    /**
-     * The cleared props from each component field on target fields array
-     */
-    clearedProps?: Record<string, unknown> | Record<string, unknown>[];
-    /**
-     * The cleared values on the fields in case they do pass the validation
-     */
-    defaultClearedValue?: TClearFieldValue | TClearFieldValue[];
-    /**
-     * The cleared props from each component field on target fields array if they pass validation
-     */
-    defaultClearedProps?: Record<string, unknown> | Record<string, unknown>[];
-};
-export declare type TSchemaClearFields = TClearField[];
-export declare type TSchemaApi = {
-    /**
-     * Specify a debounce time in miliseconds for your call
-     */
-    debounceTime?: number;
-    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
-    url: string;
-    headers?: HeadersInit | undefined;
-    body?: Record<string, any>;
-    fieldValueAsParams?: Record<string, string>;
-    fieldValueAsPathParams?: string[];
-    scope?: string;
-    blockRequestWhenInvalid?: boolean;
-    preConditions?: TSchemaValidation;
-}[];
-export declare type TSchemaMasks = {
-    cleanMask?: boolean;
-} & TComponentMasks;
-export declare type TFormEventDirectives = {
-    visibilityConditions: TSchemaVisibilityConditions;
-};
-export declare type TComponent = {
-    /**
-     * This name will be used later to correlate the field with the value, and you will be able to read it.
-     *
-     * You can also mount here complex objects like
-     *
-     * name={a.b.c}
-     *
-     * that will result in
-     * a: {
-     *  b: {
-     *    c: 'field_value'
-     *  }
-     * }
-     */
-    name: string;
-    /**
-     * A component name that should map to the one you gave in the form mappings
-     *
-     * @example - For React
-     * ```
-     *  const mappings: TMapper = {
-     *     input: { component: Input },
-     *     formGroup: { component: FormGroup },
-     *   };
-     * ```
-     *
-     * The component name for the Input element will be "input" ending up like
-     * ```
-     * {
-     *  component: 'input'
-     * }
-     * ```
-     */
-    component: string;
-    /**
-     * You can attach metadata to your component that will be forwarded to you after on your frontend
-     * callback methods link `onData`, `onBlur` etc
-     */
-    metadata?: Record<string, any>;
-    /**
-     * This property allows you to specify a virtual fieldName that can be in several fields
-     *
-     * USAGE - You have two fields but you want to have the value stored only under one name
-     *
-     */
-    group?: string;
-    wrapper?: new () => React.Component;
-    children?: TComponent[];
-    /**
-     * Field error messages in case any validation fails
-     *
-     * @example - Set a default error message for all the validations
-     *
-     * ```
-     * {
-     *  errorMessages: {
-     *    default: 'default error message'
-     *  }
-     * }
-     * ```
-     *
-     * @example - Set error message for a given validation
-     *
-     * ```
-     * {
-     *  validations: {
-     *    ON_FIELD_CHANGE: {
-     *      required: true
-     *    }
-     *  },
-     *  errorMessages: {
-     *    required: 'This field is required'
-     *  }
-     * }
-     * ```
-     *
-     */
-    errorMessages?: TErrorMessages;
-    type?: 'text' | 'number' | string;
-    /**
-     * Allow you to set a initial state for this field
-     */
-    state?: {
-        /**
-         * Hide the field
-         */
-        hidden?: boolean;
-        /**
-         * Ignore value from field
-         */
-        ignoreValue?: boolean;
-    };
-    /**
-     * This key lets you inject props directly into the component
-     */
-    props?: Record<string, unknown>;
-    /**
-     * Setup validations to be used in the field.
-     *
-     * You can setup validations in several life-cycle methods
-     *
-     * @example - Required validation
-     * ```
-     * validations: {
-     ON_FIELD_CHANGE: {
-     required: true,
-     },
-     },
-     * ```
-     */
-    validations?: TSchemaHandler<Pick<TEventReducedSchema, 'validations'>['validations']>;
-    /**
-     * Filters the component value based on a validation.
-     */
-    filter?: Pick<TEventReducedSchema, 'validations'>['validations'];
-    /**
-     * Allows you to specify the conditions a given field will be visible
-     * what will run when this field meets the specified life-cycle
-     */
-    visibilityConditions?: Omit<TSchemaHandler<Pick<TEventReducedSchema, 'visibilityConditions'>['visibilityConditions']>, 'ON_FIELD_REHYDRATE' | 'ON_FIELD_CLEARED' | 'ON_FIELD_FOCUS'>;
-    /**
-     * Will clear target fields in case they do not pass with the specified validations
-     */
-    clearFields?: Omit<TSchemaHandler<Pick<TEventReducedSchema, 'clearFields'>['clearFields']>, 'ON_FIELD_REHYDRATE' | 'ON_FIELD_CLEARED' | 'ON_FIELD_FOCUS'>;
-    /**
-     * Allows you to make api calls using events emitted by the component.
-     */
-    api?: Omit<TSchemaHandler<Pick<TEventReducedSchema, 'api'>['api']>, 'ON_FIELD_REHYDRATE' | 'ON_FIELD_FOCUS' | 'AFTER_FIELD_API_CALL'>;
-    /**
-    * Allows you to display the value of the masked component by events
-    */
-    masks?: Partial<Record<EEVents.ON_FIELD_BLUR | EEVents.ON_FIELD_MOUNT | EEVents.ON_FIELD_FOCUS | EEVents.ON_FIELD_CHANGE | EEVents.ON_FIELD_KEYUP | EEVents.ON_FIELD_KEYDOWN, Pick<TEventReducedSchema, 'masks'>['masks']>>;
-    /**
-     * Allows you to format the value that the field will receive for each event issuance
-     */
-    formatters?: Omit<TSchemaHandler<Pick<TEventReducedSchema, 'formatters'>['formatters']>, 'ON_FIELD_REHYDRATE' | 'ON_FIELD_FOCUS'>;
-};
-export declare type TEventReducedSchema = {
-    api: TSchemaApi;
-    clearFields: TSchemaClearFields;
-    formatters: TSchemaFormatters;
-    masks: TSchemaMasks;
-    validations: TSchemaValidation;
-    visibilityConditions: TSchemaVisibilityConditions;
-};
-export declare type TStep = {
-    component: string;
-    name: string;
-    children: TComponent[];
-    props?: Record<string, string>;
-};
-export declare type TComponentPropsMapping = {
-    getValue?: string;
-    setValue?: string;
-    onBlur?: string;
-    onClick?: string;
-    onFocus?: string;
-    onKeyUp?: string;
-    onKeyDown?: string;
-    setErrorMessage?: string;
-    setErrorState?: string;
-};
-export declare type TPropsMapping = Record<string, TComponentPropsMapping>;
-export declare type TSchema = {
-    /**
-     * Used to disable form submit input and prevent to submit form using enter event.
-     * Default is false.
-     */
-    disableFormSubmit?: boolean;
-    action?: string;
-    method?: string;
-    /**
-     * Give some configurations to the form
-     */
-    configs?: TConfigs;
-    /**
-     * Allows you to expose some messages to the outside world when something happen
-     */
-    messages?: TFormMessages;
-    /**
-     * Specify some static field defaults before rendereing the form.
-     *
-     * If you have initialValues in the frontend setted, those will ovewride this
-     */
-    formattedDataDefaults?: Record<string, unknown>;
-    /**
-     * Form level props mapping
-     */
-    propsMapping?: TPropsMapping;
-    visibilityConditions?: TFormLevelSchemaHandler<TSchemaVisibilityConditions>;
-    /**
-     * Entry point for the form should be a step (even if you have only one)
-     */
-    components: TStep[];
-    /**
-     * You can have many fields in the form, but be interested only in some
-     *
-     * You can put here the fields you want to read onSubmit for example
-     *
-     * You will receive those in TFormValues.filteredFields
-     */
-    filteredFields?: string[];
-    /**
-     * Schema level iVars.
-     *
-     * These iVars will go to the global scope namespace
-     */
-    iVars?: TIVars;
-};
-export declare type TSplitterFormatterValue = {
-    value: string;
-    position: number;
-}[];
-export declare type TSchemaFormatters = {
-    splitter?: TSplitterFormatterValue;
-    capitalize?: boolean;
-    upperCase?: boolean;
-    gapsCreditCard?: string[];
-    onlyNumbers?: boolean;
-    onlyLetters?: boolean;
-    regex?: string;
-    callback?(value: string | number): string | number;
-};
-export declare type TConfigs = {
-    observables?: {
-        templates?: {
-            exclude?: string[];
-        };
-    };
-};
-export declare type TFlowType = {
-    [x: string]: {
-        events: (component?: TComponent) => EEVents[];
-        handler: (args: TEventInformation<unknown>) => void;
-    }[];
-};
-export {};