@bolttech/form-engine-core 1.0.2-beta.1 → 1.0.2

package/index.d.ts

@@ -0,0 +1,2314 @@
+import * as rxjs from 'rxjs';
+import { Subject, Subscription } from 'rxjs';
+import { TCurrencyLocalCode, TCurrencyCode } from '@gaignoux/currency';
+import { OutgoingHttpHeaders } from 'http2';
+
+type AllowOnly<T, K extends keyof T> = Pick<T, K> & {
+    [P in keyof Omit<T, K>]?: never;
+};
+type OneOf<T, K = keyof T> = K extends keyof T ? AllowOnly<T, K> : never;
+type TValidationHandler = Record<string, (value: unknown, validations: TValidationMethods) => boolean>;
+
+type TComponentPropsMappingSubset = keyof (Pick<TEventPropsEnum, 'onBlur' | 'onChange' | 'onFocus' | 'onKeyDown' | 'onKeyUp' | 'onClick'> & Pick<TEventDataPropsEnum, 'onSubmit'>);
+/**
+ * @type TComponentPropsMapping
+ * Represents the mapping of component properties for various events and actions.
+ * @property {string} [getValue] - component function name to get the value.
+ * @property {string} [setValue] - component function name to set the value.
+ * @property {string} [setErrorMessage] - component function name to set the error message.
+ * @property {string} [setErrorState] - component function name to set the error state.
+ *
+ * @example
+ * ```typescript
+ * const componentProps: TComponentPropsMapping = {
+ *   getValue: 'getValueFunction',
+ *   setValue: 'setValueFunction',
+ *   onBlur: 'handleBlur',
+ *   onClick: 'handleClick',
+ *   onFocus: 'handleFocus',
+ *   onKeyUp: 'handleKeyUp',
+ *   onKeyDown: 'handleKeyDown',
+ *   setErrorMessage: 'setErrorMessageFunction',
+ *   setErrorState: 'setErrorStateFunction'
+ * };
+ * ```
+ * @interface
+ */
+type TComponentPropsMapping = Partial<Record<TComponentPropsMappingSubset, string>> & {
+    getValue?: string;
+    setValue?: string;
+    setErrorMessage?: string;
+    setErrorState?: string;
+};
+/**
+ * @type TMapper
+ * Represents the mapping of a component, including the component type,
+ * name, events, and an optional function to handle value changes.
+ *
+ * @property {ElementType} component - The component that will represent the input.
+ * * @property {ElementType} asynccomponent - The component that will represent the input but dynamically imported (suspense/lazy).
+ * @property {string} componentName - The name of the component.
+ * @property {TComponentPropsMapping} [events] - Mapping event properties for the component.
+ * @property {TValueChangeEvent} [valueChangeEvent] - Optional function to handle value changes.
+ *
+ * @example
+ * ```typescript
+ * const mappers: TMapper<ElementType>[] = [
+ *  {
+ *    component: InputElement,
+ *    componentName: 'input',
+ *    events: {
+ *      getValue: 'onChange2',
+ *      onBlur: 'onBlur2',
+ *      onFocus: 'onFocus2',
+ *    }
+ *  },
+ *  {
+ *    component: Container,
+ *    componentName: 'row',
+ *  },
+ *  {
+ *    component: Dropdown,
+ *    componentName: 'dropdown',
+ *    valueChangeEvent: (event: {
+ *      id: string;
+ *      label: string;
+ *      value: string;
+ *    }) => ({ _value: event.value, _stateValue: event.id }),
+ *  },
+ *  {
+ *    component: DatePicker,
+ *    componentName: 'datepicker',
+ *    valueChangeEvent: (event: string) => event,
+ *  },
+ * ];
+ * ```
+ * @interface
+ */
+type TMapper<T> = {
+    componentName: string;
+    events?: TComponentPropsMapping;
+    valueChangeEvent?: TValueChangeEvent;
+} & OneOf<{
+    component: T;
+    asynccomponent: T;
+}>;
+
+/**
+ * @interface IComponentSchema
+ * Represents the schema for a component within a form.
+ *
+ * @property {string} component - The type of component (e.g., 'input', 'button').
+ * @property {TProps} props - The properties of the component.
+ * @property {string} name - The name of the component.
+ * @property {string} nameToSubmit - The name of the field when submit values (optional).
+ * @property {TValidations} [validations] - The validation methods for the component.
+ * @property {TVisibility[]} [visibilityConditions] - The visibility conditions for the component.
+ * @property {TResetValueMethods[]} [resetValues] - The reset value methods for the component.
+ * @property {TApiEvent} [api] - The API configuration for the component.
+ * @property {TFormatters} [formatters] - The formatters for the component.
+ * @property {TMasks} [masks] - The masks for the component.
+ * @property {IComponentSchema[]} [children] - The child components.
+ * @property {boolean} visibility - visibility status the component will mount (to avoid SSR blinking)
+ * @property {boolean} persistValue - check this if you want the last visible value to be restored after a visiblity schema rule applied
+ *
+ * @example
+ * ```typescript
+ * const schema: IComponentSchema = {
+ *   component: 'input',
+ *   props: { type: 'text', placeholder: 'Enter your name' },
+ *   name: 'name',
+ *   nameToSubmit: 'applicant.firstName',
+ *   validations: {
+ *     methods: {
+ *       required: true,
+ *       regex: '^([0-9]+)*$',
+ *       max: 5,
+ *     },
+ *     eventMessages: {
+ *       ON_FIELD_MOUNT: ['required'],
+ *       ON_FIELD_CHANGE: ['regex', 'required'],
+ *       ON_FIELD_BLUR: ['max', 'required'],
+ *     },
+ *     messages: {
+ *       default: 'This field is required',
+ *       regex: 'Only numbers are available.',
+ *       max: 'Max of 5',
+ *     },
+ *   },
+ *   visibilityConditions: [{ conditions: { field: 'age', value: 18 } }],
+ *   resetValues: [{ field: 'age', resetTo: '' }],
+ *   api: {
+ *     defaultConfig: {
+ *       config: { method: 'POST', url: 'https://api.example.com/submit' },
+ *       events: [{ eventName: 'ON_FIELD_BLUR' }]
+ *     }
+ *   },
+ *   formatters: { capitalize: true },
+ *   masks: { currency: { align: 'left', decimal: '.', precision: 2, prefix: '$', thousands: ',' } },
+ *   children: [],
+ *   visibility: true,
+ *   persistValue: true,
+ * };
+ * ```
+ */
+interface IComponentSchema {
+    /** The type of component (e.g., 'input', 'button'). */
+    component: string;
+    /** The properties of the component. */
+    props?: TProps;
+    /** The name of the component. */
+    name: string;
+    /** The name of the field when submit values. */
+    nameToSubmit?: string;
+    /** The validation methods for the component. */
+    validations?: TValidations;
+    /** The API configuration for the component. */
+    api?: TApiEvent;
+    /** The visibility conditions for the component. */
+    visibilityConditions?: TVisibility[];
+    /** The reset value methods for the component. */
+    resetValues?: TResetValueMethods[];
+    /** The reset property values for the component. */
+    resetPropertyValues?: TResetPathMethods[];
+    /** The formatters for the component. */
+    formatters?: TFormatters;
+    /** The masks for the component. */
+    masks?: TMasks;
+    /** The child components. */
+    children?: IComponentSchema[];
+    /** Visibility status the component will mount (to avoid SSR blinking) */
+    visibility?: boolean;
+    /** Check this if you want the last visible value to be restored after a visiblity schema rule applied  */
+    persistValue?: boolean;
+}
+interface IComponentSchemaAsFormField<T> extends IComponentSchema {
+    mapper?: TMapper<T>;
+    children?: IComponentSchemaAsFormField<T>[];
+}
+/**
+ * @interface IFormSchema
+ * Represents the schema for a form.
+ *
+ * @property {string} index - The unique index or identifier for the form.
+ * @property {string} [action] - The URL to which the form data will be submitted. (experimental)
+ * @property {string} [method] - The HTTP method used to submit the form (e.g., 'POST', 'GET') (experimental).
+ * @property {Record<string, unknown>} [initialValues] - The initial values for the form fields.
+ * @property {Record<string, unknown>} [iVars] - Dynamic key value pairs that change from any external source
+ * @property {IComponentSchema[]} [components] - The list of components included in the form.
+ * @property {boolean} [stopEventsOnSubmit] - stop all the events declared as callback on useForm/Form once form is submitted
+ * @property {TSchemaFormConfig} [config] - form configurations to change event debouncers and debugging tools
+ *
+ * @example
+ * ```typescript
+ * const formSchema: IFormSchema = {
+ *   index: 'userForm',
+ *   initialValues: { name: '', email: '' },
+ *   iVars: iVarsState,
+ *   config: {
+ *     defaultLogVerbose: true
+ *   },
+ *   components: [
+ *     { component: 'input', name: 'name', props: { placeholder: 'Enter your name' } },
+ *     { component: 'input', name: 'email', props: { placeholder: 'Enter your email' } }
+ *   ]
+ * };
+ * ```
+ */
+interface IFormSchema {
+    index: string;
+    action?: string;
+    method?: string;
+    config?: TSchemaFormConfig;
+    initialValues?: Record<string, unknown>;
+    iVars?: Record<string, unknown>;
+    components?: IComponentSchema[];
+    stopEventsOnSubmit?: boolean;
+}
+
+/**
+ * @type TFormValues<T>
+ * Represents the values and state of a form. It has a generic type that allows the importer to determine which type values key will return.
+ *
+ * @property {Generic Type} values - The current values of the form fields.
+ * @property {string[]} erroredFields - A list of field names that have errors.
+ * @property {boolean} isValid - Indicates whether the form is valid.
+ *
+ * @example
+ * ```typescript
+ * const formValues: TFormValues = {
+ *   values: { name: 'John', age: 30 },
+ *   erroredFields: ['email'],
+ *   isValid: false
+ * };
+ * ```
+ */
+type TFormValues<T> = {
+    values: T;
+    metadata: unknown;
+    erroredFields: string[];
+    isValid: boolean;
+};
+/**
+ * @type TFormEntry
+ * Represents the entry configuration for a form.
+ *
+ * @property {IFormSchema} [schema] - The schema defining the structure and behavior of the form.
+ * @property {Record<string, unknown>} [initialValues] - The initial values for the form fields.
+ * @property {(data: TFormValues) => void} [onSubmit] - Callback function to handle form submission.
+ * @property {Subject<TFormDataPayload>} [dataSubject$] - data subject passed from formGroup instance
+ * @property {Subject<TFormValidationPayload>} [formValidSubject$] - formValid subject passed from formGroup instance
+ * @property {Subject<TFormSubmitPayload<unknown>>} [submitSubject$] - submit subject passed from formGroup instance
+ *
+ * @example
+ * ```typescript
+ * const formEntry: TFormEntry = {
+ *   schema: [{ component: 'input', props: {}, name: 'name' }],
+ *   initialValues: { name: 'John' },
+ *   onSubmit: (data) => { console.log(data); }
+ * };
+ * ```
+ */
+type TFormEntry = Omit<IFormSchema, 'components'> & {
+    schema?: IFormSchema;
+    mappers?: TMapper<unknown>[];
+    dataSubject$?: Subject<TFormDataPayload>;
+    formValidSubject$?: Subject<TFormValidationPayload>;
+    submitSubject$?: Subject<TFormSubmitPayload<unknown>>;
+};
+
+declare const TEMPLATE_AVALIABLE_SCOPES: readonly ["fields", "iVars", "form"];
+declare const ALLOWED_RESET_PROPS_MUTATIONS: (keyof Pick<IFormField, "api" | "apiSchema" | "props" | "validations" | "visibilityConditions" | "resetValues">)[];
+
+/** @virtual */
+
+type TAllowedResetPropsMutations = (typeof ALLOWED_RESET_PROPS_MUTATIONS)[number];
+/**
+ * @type TAllowedResetPropsMutationsEnum
+ * Represents the allowed properties to be changed on resetPropertyValues.
+ *
+ * @property {never} api - api property
+ * @property {never} apiSchema - apiSchema property
+ * @property {never} props - props property
+ * @property {never} validations - validations property
+ * @property {never} visibilityConditions - visibilityConditions property
+ * @property {never} resetValues - resetValues property
+ *
+ * @interface
+ */
+type TAllowedResetPropsMutationsEnum = Record<TAllowedResetPropsMutations, never>;
+/**
+ * @type TLengthValidation
+ * Represents the validation rules based on the length of the input.
+ *
+ * @property {'equal' | 'notEqual' | 'less' | 'lessOrEqual' | 'greater' | 'greaterOrEqual'} rule - The rule to apply.
+ * @property {number} target - The target value to compare against.
+ *
+ * @example
+ * ```typescript
+ * const lengthValidation: TLengthValidation = { rule: 'greaterOrEqual', target: 8 };
+ * ```
+ */
+type TLengthValidation = {
+    rule: 'equal' | 'notEqual' | 'less' | 'lessOrEqual' | 'greater' | 'greaterOrEqual';
+    target: number;
+};
+/**
+ * @type TCallbackValidation
+ * A custom validation function.
+ *
+ * @param {unknown} value - The value to validate.
+ * @returns {boolean} - The result of the validation.
+ *
+ * @example
+ * ```typescript
+ * const callbackValidation: TCallbackValidation = (value) => typeof value === 'string';
+ * ```
+ */
+type TCallbackValidation = (value: unknown) => boolean;
+/**
+ * @type TBetweenValidation
+ * Represents validation rules that check if a value is between a range.
+ *
+ * @property {number} start - The start of the range.
+ * @property {number} end - The end of the range.
+ *
+ * @example
+ * ```typescript
+ * const betweenValidation: TBetweenValidation = { start: 1, end: 10 };
+ * ```
+ */
+type TBetweenValidation = {
+    start: number;
+    end: number;
+};
+/**
+ * @type TCreditCardMatch
+ * Represents the options for credit card matching.
+ *
+ * @property {string} numberCard - The credit card number.
+ * @property {string[]} availableOptions - The available options for matching.
+ *
+ * @example
+ * ```typescript
+ * const creditCardMatch: TCreditCardMatch = { numberCard: '1234', availableOptions: ['Visa', 'MasterCard'] };
+ * ```
+ */
+type TCreditCardMatch = {
+    numberCard: string;
+    availableOptions: string[];
+};
+/**
+ * @type TDocumentValidation
+ * Represents validation for specific document types.
+ *
+ * @property {'NIF' | 'NIE' | 'CIF' | 'IBAN'} type - The type of document.
+ * @property {TCurrencyLocalCode} [locale] - The locale code for validation.
+ *
+ * @example
+ * ```typescript
+ * const documentValidation: TDocumentValidation = { type: 'NIF', locale: 'ES' };
+ * ```
+ */
+type TDocumentValidation = {
+    type: 'NIF' | 'NIE' | 'CIF' | 'IBAN';
+    locale?: TCurrencyLocalCode;
+};
+/**
+ * @type TDateOperatorsValidation
+ * Represents the operators used for date validation conditions.
+ *
+ * @property {'<' | '>' | '===' | '>=' | '<=' | '!==' | '!!origin'}
+ *
+ * @example
+ * ```typescript
+ * const operator: TDateOperatorsValidation = '<';
+ * ```
+ */
+type TDateOperatorsValidation = '<' | '>' | '===' | '>=' | '<=' | '!==' | '!!origin';
+/**
+ * @type TConditionsValidationSet
+ * Represents a single validation condition set.
+ *
+ * @property {boolean} [forceDefinedOrigin] - Flag to force the origin value to be defined.
+ * @property {boolean} [forceDefinedTarget] - Flag to force the target value to be defined.
+ * @property {string | number | boolean} [origin] - The origin value for the condition.
+ * @property {TDateOperatorsValidation} condition - The validation condition operator.
+ * @property {string | number | boolean} [target] - The target value for the condition.
+ *
+ * @example
+ * ```typescript
+ * const conditionSet: TConditionsValidationSet = {
+ *   forceDefinedOrigin: true,
+ *   forceDefinedTarget: true,
+ *   origin: '2023-01-01',
+ *   condition: '>',
+ *   target: '2022-01-01'
+ * };
+ * ```
+ */
+type TConditionsValidationSet = {
+    forceDefinedOrigin?: boolean;
+    forceDefinedTarget?: boolean;
+    origin?: string | number | boolean | null;
+    condition: TDateOperatorsValidation;
+    target?: string | number | boolean;
+};
+/**
+ * @type TConditionsValidation
+ * Represents a set of validation conditions.
+ *
+ * @property {'and' | 'or'} rule - The logical rule to combine the conditions (AND/OR).
+ * @property {TConditionsValidationSet[]} set - The array of validation condition sets.
+ * @property {TConditionsValidation} [conditions] - Nested conditions for more complex validation logic.
+ *
+ * @example
+ * ```typescript
+ * const conditionsValidation: TConditionsValidation = {
+ *   rule: 'and',
+ *   set: [
+ *     {
+ *       forceDefinedOrigin: true,
+ *       forceDefinedTarget: true,
+ *       origin: '2023-01-01',
+ *       condition: '>',
+ *       target: '2022-01-01'
+ *     }
+ *   ],
+ *   conditions: {
+ *     rule: 'or',
+ *     set: [
+ *       {
+ *         origin: true,
+ *         condition: '!!origin',
+ *         target: false
+ *       }
+ *     ]
+ *   }
+ * };
+ * ```
+ */
+type TConditionsValidation = {
+    rule: 'and' | 'or';
+    set: TConditionsValidationSet[];
+    conditions?: TConditionsValidation;
+};
+type TAvailableValidations = Omit<TValidationMethods, 'multipleValidations'> | TGenericValidationRule;
+/**
+ * @type TMultipleValidation
+ * Represents a set of multiple validation methods combined with a logical rule.
+ *
+ * @property {'AND' | 'OR' | 'NOT'} rule - The logical rule to combine the validation methods (AND, OR, NOT).
+ * @property {TAvailableValidations} validations - The validation methods to be combined.
+ *
+ * @example
+ * ```typescript
+ * const multipleValidation: TMultipleValidation = {
+ *   rule: 'AND',
+ *   validations: {
+ *     required: true,
+ *     min: 5,
+ *     max: 10
+ *   }
+ * };
+ * ```
+ */
+type TMultipleValidation = {
+    rule: 'AND' | 'OR' | 'NOT';
+    validations: TAvailableValidations;
+};
+/**
+ * @type TBetweenDatesValidation
+ * Represents a validation method to check if a value falls between specified dates.
+ *
+ * @property {TDateValidation[]} [TBetweenDatesValidation] - An array of date validation methods.
+ *
+ * @example
+ * ```typescript
+ * const betweenDatesValidation: TBetweenDatesValidation = [
+ *    {
+ *      onlyValidDate: true,
+ *      operator: '>=',
+ *      origin: {
+ *        format: 'MMDDYYYY',
+ *        intervals: {
+ *          years: 1
+ *        }
+ *      },
+ *      target: {
+ *        value: Date.now(),
+ *        format: 'timestamp',
+ *        value: '01/01/2023',
+ *      }
+ *    },
+ *    {
+ *      onlyValidDate: true,
+ *      operator: '<=',
+ *      origin: {
+ *        format: 'MMDDYYYY',
+ *        intervals: {
+ *          years: 1
+ *        }
+ *      },
+ *      target: {
+ *        format: 'timestamp',
+ *        value: '31/12/2023',
+ *      }
+ *    }
+ * ];
+ * ```
+ */
+type TBetweenDatesValidation = TDateValidation[];
+/**
+ * @type TDateFormatsValidation
+ * Represents the supported date formats for validation.
+ *
+ * @type {'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD' | 'YYYYDDMM' | 'timestamp'}
+ *
+ * @example
+ * ```typescript
+ * const dateFormat: TDateFormatsValidation = 'MMDDYYYY';
+ * ```
+ */
+type TDateFormatsValidation = 'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD' | 'YYYYDDMM' | 'timestamp';
+type TDateInterval = {
+    years?: number;
+    months?: number;
+    days?: number;
+};
+/**
+ * @type TDateValidation
+ * Represents a validation method for date values.
+ *
+ * @property {boolean} [onlyValidDate] - Flag to validate only if the date is valid.
+ * @property {TDateOperatorsValidation} operator - The validation operator to be used.
+ * @property {Object} origin - The origin date configuration.
+ * @property {string | number} [origin.value] - The origin date value.
+ * @property {TDateFormatsValidation} origin.format - The format of the origin date.
+ * @property {Object} [origin.intervals] - The intervals to add to the origin date for comparison.
+ * @property {number} [origin.intervals.years] - The number of years to add.
+ * @property {number} [origin.intervals.months] - The number of months to add.
+ * @property {number} [origin.intervals.days] - The number of days to add.
+ * @property {Object} [target] - The target date configuration.
+ * @property {string | number} target.value - The target date value.
+ * @property {TDateFormatsValidation} target.format - The format of the target date.
+ *
+ * @example
+ * ```typescript
+ * const dateValidation: TDateValidation = {
+ *   onlyValidDate: true,
+ *   operator: '===',
+ *   origin: {
+ *     value: '10/10/2022',
+ *     format: 'MMDDYYYY',
+ *     intervals: {
+ *       years: 1
+ *     }
+ *   },
+ *   target: {
+ *     value: Date.now(),
+ *     format: 'timestamp'
+ *   }
+ * };
+ * ```
+ */
+type TDateValidation = {
+    onlyValidDate?: boolean;
+    operator: TDateOperatorsValidation;
+    origin: {
+        value?: string | number;
+        format: TDateFormatsValidation;
+        /**
+         * Intervals to compare with the original date.
+         *
+         * It will use today's date for comparison.
+         *
+         * @example
+         * ```typescript
+         * 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?: TDateInterval;
+    };
+    target?: {
+        value: string | number;
+        format: TDateFormatsValidation;
+    };
+};
+/**
+ * @type TValidationMethods
+ * Represents the various validation methods that can be applied to form fields.
+ *
+ * @property {number} [max] - Maximum value or length.
+ * @property {number} [min] - Minimum value or length.
+ * @property {number} [lessThan] - Minimum value or length.
+ * @property {number} [greaterThan] - Minimum value or length.
+ * @property {TLengthValidation} [length] - Length validation rule.
+ * @property {boolean} [required] - Indicates if the field is required.
+ * @property {unknown} [value] - Specific value to match.
+ * @property {string} [regex] - Regular expression for validation.
+ * @property {boolean} [email] - Indicates if the value should be a valid email.
+ * @property {boolean} [url] - Indicates if the value should be a valid URL.
+ * @property {boolean} [onlyLetters] - Indicates if the value should contain only letters.
+ * @property {boolean} [notAllowSpaces] - Indicates if spaces are not allowed.
+ * @property {TCallbackValidation} [callback] - Custom validation callback function.
+ * @property {boolean} [isNumber] - Indicates if the value should be a number.
+ * @property {boolean} [bool] - Indicates if the value should be a boolean or a string that can be converted to a boolean.
+ * @property {boolean | string} [exists] - Indicates if the value should exist or match a specific existence condition.
+ * @property {boolean} [hasNoExtraSpaces] - Indicates if there should be no extra spaces.
+ * @property {boolean} [notEmpty] - Indicates if the field should not be empty.
+ * @property {TBetweenValidation} [between] - Validation rule for range between two values.
+ * @property {boolean} [sequential] - Indicates if the value should be sequential.
+ * @property {boolean} [repeated] - Indicates if the value should not be repeated.
+ * @property {string[] | number[]} [includes] - Array of values that should be included.
+ * @property {string[]} [isCreditCard] - Array of valid credit card numbers.
+ * @property {TCreditCardMatch} [isCreditCodeMatch] - Validation rule for credit card matching.
+ * @property {string[]} [isCreditCardAndLength] - Array of valid credit card numbers with length check.
+ * @property {TDocumentValidation} [document] - Document validation rule.
+ * @property {TConditionsValidation} [conditions] - Conditional validation rules.
+ * @property {TMultipleValidation} [multipleValidations] - Multiple validation rules combined with a logical rule.
+ * @property {TBetweenDatesValidation} [betweenDates] - Validation rule for checking if a date falls between two dates.
+ * @property {TDateValidation} [date] - Validation rule for date values.
+ * @property {TDateFormatsValidation} [validDate] - Validation rule for valid date formats.
+ *
+ * @example
+ * ```typescript
+ * const validationMethods: TValidationMethods = {
+ *   max: 100,
+ *   min: 1,
+ *   lessThan: 1995,
+ *   greaterThan: 82000,
+ *   length: { rule: 'greaterOrEqual', target: 8 },
+ *   required: true,
+ *   regex: '^[a-zA-Z0-9]+$',
+ *   email: true,
+ *   conditions: {
+ *     rule: 'and',
+ *     set: [
+ *       {
+ *         forceDefinedOrigin: true,
+ *         forceDefinedTarget: true,
+ *         origin: '2023-01-01',
+ *         condition: '>',
+ *         target: '2022-01-01'
+ *       }
+ *     ]
+ *   },
+ *   multipleValidations: {
+ *     rule: 'AND',
+ *     validations: {
+ *       required: true,
+ *       min: 5,
+ *       max: 10
+ *     }
+ *   },
+ *   betweenDates: {
+ *     start: Date.parse('2023-01-01'),
+ *     end: Date.parse('2023-12-31'),
+ *     isIncludedBoundaries: true
+ *   },
+ *   date: {
+ *     operator: '===',
+ *     origin: {
+ *       value: '10/10/2022',
+ *       format: 'MMDDYYYY',
+ *       intervals: {
+ *         years: 1
+ *       }
+ *     },
+ *     target: {
+ *       value: Date.now(),
+ *       format: 'timestamp'
+ *     }
+ *   },
+ *   validDate: 'MMDDYYYY'
+ * };
+ * ```
+ */
+type TValidationMethods = {
+    /** Maximum value or length. */
+    max?: number;
+    /** Minimum value or length. */
+    min?: number;
+    /** Minimum value or length. */
+    lessThan?: number;
+    /** Minimum value or length. */
+    greaterThan?: number;
+    /** Length validation rule. */
+    length?: TLengthValidation;
+    /** Indicates if the field is required. */
+    required?: boolean;
+    /** Specific value to match. */
+    value?: unknown;
+    /** Regular expression for validation. */
+    regex?: string;
+    /** Indicates if the value should be a valid email. */
+    email?: boolean;
+    /** Indicates if the value should be a valid URL. */
+    url?: boolean;
+    /** Indicates if the value should contain only letters. */
+    onlyLetters?: boolean;
+    /** Indicates if spaces are not allowed. */
+    notAllowSpaces?: boolean;
+    /** Custom validation callback function. */
+    callback?: TCallbackValidation;
+    /** Indicates if the value should be a number. */
+    isNumber?: boolean;
+    /** Indicates if the value should be a boolean or a string that can be converted to a boolean. */
+    bool?: boolean | string;
+    /** Indicates if the value should exist or match a specific existence condition. */
+    exists?: boolean | string;
+    /** Indicates if there should be no extra spaces. */
+    hasNoExtraSpaces?: boolean;
+    /** Indicates if the field should not be empty. */
+    notEmpty?: boolean;
+    /** Validation rule for range between two values. */
+    between?: TBetweenValidation;
+    /** Indicates if the value should be sequential. */
+    sequential?: boolean;
+    /** Indicates if the value should not be repeated. */
+    repeated?: boolean;
+    /** Array of values that should be included. */
+    includes?: (string | number)[];
+    /** Array of valid credit card numbers. */
+    isCreditCard?: string[];
+    /** Validation rule for credit card matching. */
+    isCreditCodeMatch?: TCreditCardMatch;
+    /** Array of valid credit card numbers with length check. */
+    isCreditCardAndLength?: string[];
+    /** Document validation rule. */
+    document?: TDocumentValidation;
+    /** Conditional validation rules. */
+    conditions?: TConditionsValidation;
+    /** Multiple validation rules combined with a logical rule. */
+    multipleValidations?: TMultipleValidation;
+    /** Validation rule for checking if a date falls between two dates. */
+    betweenDates?: TBetweenDatesValidation;
+    /** Validation rule for date values. */
+    date?: TDateValidation;
+    /** Validation rule for valid date formats. */
+    validDate?: TDateFormatsValidation;
+};
+/**
+ * @type {Object.<string, TValidationMethods>} TGenericValidationRule
+ * Represents a generic validation rule where each key is associated with a set of validation methods.
+ *
+ * @example
+ * const genericValidationRule = {
+ *   email: {
+ *     required: true,
+ *     email: true,
+ *   },
+ *   password: {
+ *     required: true,
+ *     minLength: 8,
+ *   },
+ * };
+ */
+type TGenericValidationRule = Record<string, TValidationMethods>;
+/**
+ * @type {TValidationMethods | TGenericValidationRule} TSchemaValidation
+ * Represents the schema validation which can be either a set of validation methods or a generic validation rule.
+ *
+ * @example
+ * const schemaValidation = {
+ *   required: true,
+ *   maxLength: 10,
+ * };
+ *
+ * const genericSchemaValidation = {
+ *   email: {
+ *     required: true,
+ *     email: true,
+ *   },
+ *   password: {
+ *     required: true,
+ *     minLength: 8,
+ *   },
+ * };
+ * @interface
+ */
+type TSchemaValidation = TValidationMethods | TGenericValidationRule;
+/**
+ * Formatter types
+ * @type TSplitterFormatterValue
+ * Represents a value and its position for splitting or formatting purposes.
+ *
+ * @property {string} value - The value to be split or formatted.
+ * @property {number} position - The position for splitting or formatting.
+ *
+ * @example
+ * ```typescript
+ * const splitterFormatter: TSplitterFormatterValue = { value: '-', position: 3 };
+ * ```
+ */
+type TSplitterFormatterValue = {
+    value: string;
+    position: number;
+};
+/**
+ * @type TFormatters
+ * Represents the various formatting options that can be applied to form field values.
+ *
+ * @property {boolean} [dotEvery3chars] - Add a dot every 3 characters.
+ * @property {boolean} [capitalize] - Capitalize the value.
+ * @property {boolean} [uppercase] - Convert the value to uppercase.
+ * @property {boolean} [onlyNumbers] - Allow only numbers.
+ * @property {boolean} [onlyLetters] - Allow only letters.
+ * @property {Pick<TCurrencyMask, 'precision' | 'decimal'>} [onlyFloatNumber] - Allow only float numbers with specific precision and decimal.
+ * @property {string} [regex] - Regular expression for formatting.
+ * @property {string[]} [gapsCreditCard] - Gaps to insert in credit card numbers.
+ * @property {(value: unknown) => unknown} [callback] - Custom formatter callback function.
+ * @property {TSplitterFormatterValue[]} [splitter] - Splitter values for formatting.
+ * @property {boolean} [trim] - Removes whitespace from both ends of this string and returns a new string, without modifying the original string.
+ * @property {number} [maxLength] - Truncates the input value to a specified maximum length if necessary.
+ *
+ * @example
+ * ```json
+ * {
+ *   formatters: {
+ *      dotEvery3chars: true,
+ *      capitalize: true,
+ *      uppercase: true,
+ *      onlyNumbers: true,
+ *      regex: '^[a-zA-Z0-9]+$',
+ *      gapsCreditCard: [' ', ' '],
+ *      callback: (value) => value.toString().toUpperCase(),
+ *      splitter: [{ value: '-', position: 3 }],
+ *      trim: true,
+ *      maxLength: 15
+ *   }
+ * }
+ * ```
+ */
+type TFormatters = {
+    /** Add a dot every 3 characters. */
+    dotEvery3chars?: boolean;
+    /** Capitalize the value. */
+    capitalize?: boolean;
+    /** Convert the value to uppercase. */
+    uppercase?: boolean;
+    /** Allow only numbers. */
+    onlyNumbers?: boolean;
+    /** Allow only letters. */
+    onlyLetters?: boolean;
+    /** Allow only float numbers with specific precision and decimal. */
+    onlyFloatNumber?: Pick<TCurrencyMask, 'precision' | 'decimal'>;
+    /** Regular expression for formatting. */
+    regex?: string;
+    gapsCreditCard?: string[] | boolean;
+    callback?: ((value: unknown) => unknown) | null;
+    splitter?: TSplitterFormatterValue[];
+    /** Removes whitespace from both ends of this string and returns a new string, without modifying the original string. */
+    trim?: boolean;
+    /** Truncates the input value to a specified maximum length if necessary. */
+    maxLength?: number;
+};
+/**
+ * Mask types
+ * @type TCurrencyMask
+ * Represents the mask configuration for currency values.
+ *
+ * @property {'left' | 'right'} [align] - The alignment of the currency symbol. (default: right)
+ * @property {string} [decimal] - The decimal separator. (default: '.')
+ * @property {number} [precision] - The number of decimal places. (default: 2)
+ * @property {TCurrencyCode} [prefix] - The currency symbol prefix. (default: '$')
+ * @property {string} [thousands] - The thousands separator. (default: ',')
+ *
+ * @example
+ * ```typescript
+ * const currencyMask: TCurrencyMask = {
+ *   align: 'left',
+ *   decimal: '.',
+ *   precision: 2,
+ *   prefix: '$',
+ *   thousands: ','
+ * };
+ * ```
+ */
+type TCurrencyMask = {
+    align?: 'left' | 'right';
+    decimal?: string;
+    precision?: number;
+    prefix?: TCurrencyCode;
+    thousands?: string;
+};
+/**
+ * @type TMaskGeneric
+ * Represents a generic mask configuration.
+ *
+ * @property {number} to - The ending position of the mask.
+ * @property {number} from - The starting position of the mask.
+ * @property {string} mask - The mask pattern to apply.
+ *
+ * @example
+ * ```typescript
+ * const maskGeneric: TMaskGeneric = { to: 4, from: 0, mask: '****' };
+ * ```
+ */
+type TMaskGeneric = {
+    to: number;
+    from: number;
+    mask: string;
+};
+/**
+ * @type TMasks
+ * Represents the different types of masks that can be applied to form field values.
+ *
+ * @property {TCurrencyMask} [currency] - Mask for currency values.
+ * @property {TMaskGeneric[]} [generic] - Array of generic masks.
+ * @property {string} [custom] - Custom mask pattern.
+ * @property {boolean} [secureCreditCard] - Mask for securing credit card values.
+ * @property {boolean} [card] - Mask for card values.
+ * @property {boolean} [cardDate] - Mask for card date values.
+ * @property {boolean} [fein] - Mask for FEIN (Federal Employer Identification Number).
+ * @property {string | number} [replaceAll] - Value to replace all matches.
+ * @property {(value: unknown) => string} [callback] - Custom mask callback function.
+ *
+ * @example
+ * ```typescript
+ * const masks: TMasks = {
+ *   currency: { align: 'left', decimal: '.', precision: 2, prefix: '$', thousands: ',' },
+ *   generic: [{ to: 4, from: 0, mask: '****' }],
+ *   custom: '###-##-####',
+ *   secureCreditCard: true,
+ *   card: true,
+ *   cardDate: true,
+ *   fein: true,
+ *   replaceAll: '*',
+ *   callback: (value) => value.toString().replace(/\d/g, '*')
+ * };
+ * ```
+ */
+type TMasks = {
+    /** Mask for currency values. */
+    currency?: TCurrencyMask;
+    /** Array of generic masks. */
+    generic?: TMaskGeneric[];
+    /** Custom mask pattern. */
+    custom?: string | null;
+    /** Mask for securing credit card values. */
+    secureCreditCard?: boolean;
+    /** Mask for card values. */
+    card?: boolean;
+    /** Mask for card date values. */
+    cardDate?: boolean;
+    /** Mask for FEIN (Federal Employer Identification Number). */
+    fein?: boolean;
+    /** Value to replace all matches. */
+    replaceAll?: string | number;
+    /** Custom mask callback function. */
+    callback?: (value: unknown) => string;
+};
+/**
+ * @type TVisibility
+ * Represents the visibility conditions for form fields based on validations.
+ *
+ * @property {boolean} showOnlyIfTrue - Enables visibility of fields only if any or all validation conditions are positive.
+ * @property {TSchemaValidation} validations - The validation methods to determine visibility.
+ * @property {string[] | string} fields - The fields to be shown or hidden based on validations.
+ * @property {string[]} events - Events where visibility will occur.
+ *
+ * @example
+ * ```typescript
+ * const visibility: TVisibility = {
+ *   showOnlyIfTrue: false,
+ *   validations: { required: true },
+ *   fields: ['fieldName'],
+ *   events: ['ON_FIELD_CHANGE']
+ * };
+ * ```
+ */
+type TVisibility = {
+    showOnlyIfTrue?: boolean;
+    validations: TSchemaValidation;
+    fields: string[] | string;
+    events: TEvents[];
+};
+/**
+ * @type TResetValueMethods
+ * @extends TVisibility with methods to reset values.
+ * @summary schema method to reset values from event
+ * much cool such wow
+ *
+ * @property {unknown[] | unknown} resettledValue - The values to reset.
+ * @property {Partial<TEvents>[]} events - events that will react to the value reset
+ * @property {string | string[]} fields - fields that will react to the value reset
+ * @property {TSchemaValidation} validations - validations to trigger the property reset
+ *
+ *
+ * @example
+ * ```typescript
+ * const resetValueMethods: TResetValueMethods = {
+ *   validations: { required: true },
+ *   fields: ['fieldName'],
+ *   resettledValue: [''],
+ *   events: ['ON_FIELD_CHANGE]
+ * };
+ * ```
+ * @interface
+ */
+type TResetValueMethods = Omit<TVisibility, 'showOnlyIfTrue' | 'validations'> & {
+    resettledValue: unknown[] | unknown;
+    validations?: TSchemaValidation;
+};
+/**
+ * @type TResetPathMethods
+ * Method to reset some field properties other than component props or field value
+ *
+ * @property {TAllowedResetPropsMutations} property property to be changed, ex: api, resetValues, etc..
+ * @property {string} path path where the property to be changed is located
+ * @property {string} field field that will recieve the property change
+ * @property {unknown} resettledValue value to be replaced onto the property
+ * @property {TSchemaValidation} validations validations rules to be validated to change the property value
+ * @property {Partial<TEvents>[]} events events to listen to apply this change
+ *
+ * @example
+ * ```typescript
+ * const resetValueMethods: TResetValueMethods = {
+ *   validations: { required: true },
+ *   fields: ['fieldName'],
+ *   resettledValue: ['']
+ * };
+ * ```
+ */
+type TResetPathMethods = {
+    property: TAllowedResetPropsMutations;
+    path: string;
+    field: string;
+    resettledValue: unknown;
+    validations: TSchemaValidation;
+    events: Partial<TEvents>[];
+};
+/**
+ * @type TApiConfig
+ * Represents the configuration for an API request.
+ *
+ * @property {'GET' | 'POST'} method - The HTTP method for the request.
+ * @property {string} url - The URL for the request.
+ * @property {OutgoingHttpHeaders} [headers] - The headers for the request.
+ * @property {Record<string, string>} queryParams - query parameters for request.
+ * @property {string} [resultPath] - The path to extract the result from the response.
+ * @property {unknown} [fallbackValue] - The fallback value if the request fails.
+ * @property {TSchemaValidation} preConditions - validation conditions to execute the API call
+ * @property {boolean} blockRequestWhenInvalid - blocks request when field validation fails
+ *
+ * @example
+ * ```typescript
+ * const apiConfig: TApiConfig = {
+ *   method: 'POST',
+ *   url: 'https://api.example.com/data',
+ *   headers: { 'Content-Type': 'application/json' },
+ *   resultPath: 'data.results',
+ *   fallbackValue: [],
+ *   preConditions: {
+ *     required: true,
+ *   }
+ *   blockRequestWhenInvalid: true,
+ * };
+ * ```
+ */
+type TApiConfig = {
+    /** The HTTP method for the request. */
+    method: 'GET' | 'POST';
+    /** The URL for the request. */
+    url: string;
+    /** The body payload for the request. */
+    body?: Record<string, unknown>;
+    /** The headers for the request. */
+    headers?: OutgoingHttpHeaders;
+    /** Query parameters for the request. */
+    queryParams?: Record<string, string>;
+    /** The path to extract the result from the response. */
+    resultPath?: string;
+    /** The fallback value if the request fails. */
+    fallbackValue?: unknown;
+    /** Validation conditions to execute the API call. */
+    preConditions?: TSchemaValidation;
+    /** Blocks request when field validation fails. */
+    blockRequestWhenInvalid?: boolean;
+    /** Custom transform callback for the request payload. */
+    transform?: {
+        callback(callbackPayload: {
+            payload: unknown;
+            formValues: TFormValues<unknown>;
+        }): unknown;
+    };
+};
+/**
+ * @type TProps
+ * Represents the properties for a component.
+ */
+type TProps = Record<string, unknown>;
+/**
+ * @type TValidations
+ * Represents the validation configuration for form fields, including methods, event-specific messages, and error messages.
+ *
+ * @property {TSchemaValidation} methods - The validation methods to be applied.
+ * @property {Partial<Record<TEvents, string[]>>} eventMessages - The messages to be displayed for specific validation events.
+ * @property {TErrorMessages} messages - The general error messages for validation methods.
+ *
+ * @interface
+ *
+ * @example
+ * ```typescript
+ * const validations: TValidations = {
+ *   methods: {
+ *     max: 100,
+ *     required: true,
+ *     regex: '^[a-zA-Z0-9]+$',
+ *   },
+ *   eventMessages: {
+ *     ON_FIELD_MOUNT: ['required'],
+ *     ON_FIELD_CHANGE: ['regex', 'required'],
+ *     ON_FIELD_BLUR: ['max', 'required'],
+ *   },
+ *   messages: {
+ *     default: 'This field is required',
+ *     max: 'Value exceeds the maximum limit',
+ *     regex: 'Value does not match the pattern',
+ *   },
+ * };
+ * ```
+ */
+type TValidations = {
+    methods: TSchemaValidation;
+    eventMessages?: TEventMessages;
+    messages?: TErrorMessages;
+};
+/**
+ * @type TValidations
+ * Represents the validation configuration for form fields, including methods, event-specific messages, and error messages.
+ *
+ * @property {TSchemaValidation} methods - The validation methods to be applied.
+ * @property {Partial<Record<TEvents, string[]>>} eventMessages - The messages to be displayed for specific validation events.
+ * @property {TErrorMessages} messages - The general error messages for validation methods.
+ *
+ * @example
+ * ```typescript
+ * const eventMessages: {
+ *     ON_FIELD_MOUNT: ['required'],
+ *     ON_FIELD_CHANGE: ['regex', 'required'],
+ *     ON_FIELD_BLUR: ['max', 'required'],
+ *   },
+ * ```
+ * @interface
+ */
+type TEventMessages = Partial<Record<TEvents, TEventMessagesValidationMethods[]>>;
+/**
+ * @type TEventMessagesValidationMethods
+ *
+ * allowed validation methods to trigger the event messages desc
+ *
+ * @property {keyof TValidationMethods | TAnyKey;} TEventMessagesValidationMethods - allowed validation methods to trigger the event messages
+ */
+type TEventMessagesValidationMethods = keyof TValidationMethods | TAnyKey;
+type TAnyKey = string & NonNullable<unknown>;
+/**
+ * @type TErrorMessages
+ * Represents the error messages for different validation methods.
+ * @property {string} default - the message to display regardless the validation
+ *
+ * @example
+ * ```typescript
+ * const errorMessages: TErrorMessages = {
+ *   required: 'This field is required.',
+ *   max: 'The value cannot exceed the maximum limit.'
+ *   default: 'Default error message'
+ * };
+ * ```
+ * @interface
+ */
+type TErrorMessages = Partial<Record<keyof TSchemaValidation | 'default' | (string & NonNullable<unknown>), string>>;
+/**
+ * Represents an event configuration with a specific type.
+ *
+ * @template T
+ * @property {T} config - The configuration of the event.
+ * @property {Partial<TEvents>[]} events - The events associated with the configuration.
+ */
+type TEvent<T> = {
+    config: T;
+    events: TEvents[];
+};
+/**
+ * Represents the API event configurations.
+ *
+ * @property {TEvent<TApiConfig>} [defaultConfig] - The default event configuration.
+ * @property {Record<string, TEvent<TApiConfig>>} [configs] - Named event configurations.
+ *
+ * @example
+ * ```typescript
+ * const apiEvent: TApiEvent = {
+ *   defaultConfig: {
+ *     config: {
+ *       method: 'POST',
+ *       url: 'https://api.example.com/data',
+ *       headers: { 'Content-Type': 'application/json' },
+ *       resultPath: 'data.results',
+ *       fallbackValue: [],
+ *       preConditions: {
+ *         required: true,
+ *       },
+ *       blockRequestWhenInvalid: true,
+ *     },
+ *     events: ['ON_FIELD_MOUNT', 'ON_FIELD_CHANGE'],
+ *   },
+ *   configs: {
+ *     example_config_name: {
+ *       config: {
+ *         method: 'POST',
+ *         url: 'https://api.example.com/data',
+ *         headers: { 'Content-Type': 'application/json' },
+ *         resultPath: 'data.results',
+ *         fallbackValue: [],
+ *         preConditions: {
+ *           required: true,
+ *         },
+ *         blockRequestWhenInvalid: true,
+ *       },
+ *       events: ['ON_FIELD_MOUNT', 'ON_FIELD_CHANGE'],
+ *     },
+ *   },
+ * };
+ * ```
+ */
+type TApiEvent = {
+    defaultConfig?: TEvent<TApiConfig>;
+    configs?: Record<string, TEvent<TApiConfig>>;
+};
+/**
+ * Represents the API response return payload for handling.
+ *
+ * @property {unknown} response - The default response.
+ * @property {number | null} status - response http status number.
+ */
+type TApiResponsePayload = {
+    response: unknown;
+    status: number | null;
+};
+/**
+ * Represents the API response structure.
+ *
+ * @property {TApiResponsePayload} default - The default response.
+ * @property {Record<string, TApiResponsePayload>} [named] - Named responses.
+ */
+type TApiResponse = {
+    default: TApiResponsePayload;
+    named?: Record<string, TApiResponsePayload>;
+    apiState: {
+        loading: boolean;
+        lastEvent?: TEvents;
+    };
+};
+/**
+ * Represents the schema config structure
+ *
+ * @property {number} defaultAPIdebounceTimeMS - default API debounce time between request events.
+ * @property {boolean} defaultLogVerbose - flag to turn warning log messages on client.
+ * @property {number} [defaultStateRefreshTimeMS] - default state refresh between events side effects.
+ */
+type TSchemaFormConfig = {
+    defaultAPIdebounceTimeMS?: number;
+    defaultStateRefreshTimeMS?: number;
+    defaultLogVerbose?: boolean;
+};
+
+/**
+ * @interface IState
+ * Represents the state of a form component.
+ *
+ * @property {string[]} errors - The list of error messages.
+ * @property {boolean} visibility - The visibility state of the component.
+ * @property {Record<string, unknown>} props - The properties of the component.
+ *
+ * @example
+ * ```typescript
+ * const state: IState = {
+ *   visibility: true,
+ *   props: { type: 'text', value: 'John' }
+ * };
+ * ```
+ */
+interface IState {
+    visibility: boolean;
+    props: Record<string, unknown>;
+    errors: Record<string, unknown>;
+}
+
+/**
+ * Custom RXJS Subject to gracefully handle errors on unsubscribed Subjects
+ * that were unmounted due to adapter external handling such as visibility
+ */
+declare class SafeSubject<T> extends Subject<T> {
+    private isMounted;
+    constructor(isMounted: () => boolean);
+    next(value: T): void;
+}
+
+type TTemplateAvaliableScopes = (typeof TEMPLATE_AVALIABLE_SCOPES)[number];
+/**
+ * @type TTemplateAvaliableScopesEnum
+ * Represents the different types of events that can occur on form fields.
+ * @property {never} fields - scope related to field content ex: '${fields.fieldName.value}'
+ * @property {never} iVars - scope related to iVars content ex: '${iVars.test}'
+ * @property {never} form - scope related to form content ex: '${form.valid}'
+ *
+ * @example
+ * ```typescript
+ * const scope: TTemplateAvaliableScopesEnum = 'fields';
+ * ```
+ * @interface
+ */
+type TTemplateAvaliableScopesEnum = Record<TTemplateAvaliableScopes, never>;
+/**
+ * @type TSubscribedTemplates
+ * Represents the subscribed templates for dynamic updates.
+ *
+ * @property {string} originExpression - The expression to evaluate.
+ * @property {TTemplateAvaliableScopes[]} originScopeKeys - Origin scope of the updated template value
+ * @property {string[]} originPropertyKeys - The properties of the origin fields.
+ * @property {string[]} originFieldKeys - The keys of the origin fields.
+ * @property {string} destinationKey - The key of the destination field.
+ * @property {string} destinationProperty - The property of the destination field.
+ * @property {string[]} destinationPath - The path to the destination property.
+ *
+ * @example
+ * ```typescript
+ * const subscribedTemplates: TSubscribedTemplates = {
+ *   originExpression: 'originField1 + originField2',
+ *   originScopeKeys: ['field','field'],
+ *   originPropertyKeys: ['value', 'props'],
+ *   originFieldKeys: ['originField1', 'originField2'],
+ *   destinationKey: 'resultField',
+ *   destinationProperty: 'value',
+ *   destinationPath: ['path', 'to', 'resultField']
+ * };
+ * ```
+ */
+type TSubscribedTemplates = {
+    originExpression: string;
+    originScopeKeys: TTemplateAvaliableScopes[];
+    originPropertyKeys: string[];
+    originFieldKeys: string[];
+    destinationKey: string;
+    destinationProperty: string;
+    destinationPath: string[];
+};
+/**
+ * @type TTemplateEvent
+ * Represents the event occuring on templates that changes property values.
+ *
+ * @property {TTemplateAvaliableScopes} scope - template scope triggering the event.
+ * @property {string} key - field triggering the template refresh
+ * @property {TMutationEvents} event - template event triggering the template refresh.
+ */
+type TTemplateEvent = {
+    scope: TTemplateAvaliableScopes;
+    key?: string;
+    event: TMutationEvents;
+};
+
+/**
+ * Represents a form field with observables for managing form state, validations, and API requests.
+ */
+declare class FormField {
+    formIndex: string;
+    name: string;
+    nameToSubmit?: string;
+    component: string;
+    children?: string[];
+    originalSchema: IComponentSchemaAsFormField<unknown>;
+    validations?: TValidations;
+    visibilityConditions?: TVisibility[];
+    resetValues?: TResetValueMethods[];
+    resetPropertyValues?: TResetPathMethods[];
+    apiSchema?: TApiEvent;
+    formatters?: TFormatters;
+    masks?: TMasks;
+    valuePropName?: string;
+    config: Required<TSchemaFormConfig>;
+    mapper: TMapper<unknown>;
+    errorsString: string;
+    errorsList: string[];
+    private _props;
+    private _value;
+    private _stateValue;
+    private _metadata;
+    private _visibility;
+    private _errors;
+    private _api;
+    private _valid;
+    private _mounted;
+    propsSubject$: SafeSubject<Record<string, unknown>>;
+    errorSubject$: SafeSubject<Record<string, unknown>>;
+    valueSubject$: SafeSubject<Record<string, unknown>>;
+    valueSubscription$: Subscription;
+    visibilitySubject$: SafeSubject<boolean>;
+    fieldEventSubject$: Subject<TFieldEvent>;
+    apiEventQueueSubject$: SafeSubject<{
+        event: TEvents;
+    }>;
+    fieldStateSubscription$: Subscription;
+    templateSubject$: Subject<TTemplateEvent>;
+    dataSubject$: Subject<TFormDataPayload>;
+    fieldValidNotification$: Subject<TFieldValidationPayload>;
+    mountSubject$: Subject<{
+        key: string;
+        status: boolean;
+    }>;
+    validateVisibility: (payload: {
+        event: TEvents;
+        key: string;
+    }) => void;
+    resetValue: (payload: {
+        event: TEvents;
+        key: string;
+    }) => void;
+    resetProperty: (payload: {
+        event: TEvents;
+        key: string;
+    }) => void;
+    getFormValues: () => TFormValues<unknown>;
+    valueChangeEvent: TValueChangeEvent;
+    submitEvent: () => void;
+    persistValue?: boolean;
+    /**
+     * Creates an instance of FormField.
+     *
+     * @param {object} options - Configuration options for the form field.
+     * @param {IComponentSchema} options.schemaComponent - The schema definition for the form field.
+     * @param {TSchemaFormConfig} options.config - The schema default configuration for debounced actions.
+     * @param {string} [options.path] - The path within the form field (used internally during recursion).
+     * @param {string[]} options.children - An array of children fields names.
+     * @param {Function} options.validateVisibility - A function to validate the visibility of the field.
+     * @param {Function} options.resetValue - A function to reset the field value.
+     * @param {Function} options.resetProperty - A function to reset a field property.
+     * @param {Subject<{ key: string }>} options.templateSubject$ - A subject for template updates.
+     * @param {Subject<TFieldEvent>} options.fieldEventSubject$, - Subject for basic event mapped field emissions, except onData to form instance
+     * @param {Subject<{ key: string; event: TEvents }>} options.dataSubject$, - Subject to emit onData events to form instance
+     * @param {Subject<{ key: string }>} options.formValidNotification$, - Subject to emit field valid change to form instance
+     * @param {TMapper<unknown>} options.mapper, - component generic mapper containing render parameters for adapters
+     * @param {() => TFormValues<unknown>} options.getFormValues, - form instance function that builds onData parameter payload from fields
+     */
+    constructor({ formIndex, schemaComponent, config, path, children, validateVisibility, resetValue, resetProperty, templateSubject$, fieldEventSubject$, dataSubject$, fieldValidNotification$, mountSubject$, mapper, getFormValues, submitEvent, visibility, persistValue, }: {
+        formIndex: string;
+        schemaComponent: IComponentSchema;
+        config?: TSchemaFormConfig;
+        path?: string;
+        children?: string[];
+        validateVisibility: (payload: {
+            event: TEvents;
+            key: string;
+        }) => void;
+        resetValue: (payload: {
+            event: TEvents;
+            key: string;
+        }) => void;
+        resetProperty: (payload: {
+            event: TEvents;
+            key: string;
+        }) => void;
+        submitEvent: () => void;
+        templateSubject$: Subject<TTemplateEvent>;
+        fieldEventSubject$: Subject<TFieldEvent>;
+        dataSubject$: Subject<TFormDataPayload>;
+        fieldValidNotification$: Subject<TFieldValidationPayload>;
+        mountSubject$: Subject<{
+            key: string;
+            status: boolean;
+        }>;
+        mapper: TMapper<unknown>;
+        getFormValues: () => TFormValues<unknown>;
+        visibility?: boolean;
+        persistValue?: boolean;
+    });
+    /**
+     * method to initialize all recycled Subjects and initialize Observers on field instance creation or rerender
+     * due to some visibility conditions unmounts the field from the adapter if they are children of it and avoid
+     * emissions to unsubscribed fields
+     */
+    initializeObservers(): void;
+    /**
+     * Retrieves the properties associated with the form field.
+     *
+     * @returns {Record<string, unknown>} - The properties of the form field.
+     */
+    get props(): Record<string, unknown>;
+    /**
+     * Sets the properties of the form field and notifies subscribers about the change.
+     *
+     * @param {Record<string, unknown>} props - The new properties to be set.
+     */
+    set props(props: Record<string, unknown>);
+    /**
+     * Static function to remove templates form the component props that will be shown when
+     * the field mounts and the template routine executes, to be used on the adapter
+     *
+     * @param {unknown} props - the properties from the adapter components.
+     */
+    static filterProps(props: unknown): unknown;
+    /**
+     * Retrieves the current state value of the form field.
+     *
+     * @returns {Record<string,unknown>} - The current state value of the form field.
+     */
+    get stateValue(): Record<string, unknown>;
+    get metadata(): unknown;
+    /**
+     * Retrieves the current value of the form field.
+     *
+     * @returns {unknown} - The current value of the form field.
+     */
+    get value(): unknown;
+    /**
+     * Sets the value of the form field and notifies subscribers about the change.
+     *
+     * @param {unknown} value - The new value to be set.
+     */
+    set value(value: unknown);
+    /**
+     * Retrieves the visibility status of the form field.
+     *
+     * @returns {boolean} - The visibility status of the form field.
+     */
+    get visibility(): boolean;
+    /**
+     * Sets the visibility status of the form field and notifies subscribers about the change.
+     *
+     * @param {boolean} visible - The new visibility status to be set.
+     */
+    set visibility(visible: boolean);
+    /**
+     * sets valid field state and notifies form instance via formValidNotification$
+     */
+    set valid(valid: boolean);
+    /**
+     * Retrieves the validity status of the form field.
+     *
+     * @returns {boolean} - The validity status of the form field.
+     */
+    get valid(): boolean;
+    /**
+     * triggers field valid notification to handle the form instance valid notification
+     *
+     * Note: since form unmount can occur before field unmount, this subject might already be closed by form instance
+     * quick workaround is to check if the subject is already closed before emitting
+     * if form instance onValid or template form.valid doesn't work properly, might be due to this workaround
+     */
+    triggerFieldValidNotification(): void;
+    /**
+     * Retrieves the error messages associated with the form field.
+     *
+     * @returns {TErrorMessages} - The error messages associated with the form field.
+     */
+    get errors(): TErrorMessages;
+    /**
+     * Sets the error messages associated with the form field and notifies subscribers about the change.
+     *
+     * @param {TErrorMessages} errors - The new error messages to be set.
+     */
+    set errors(errors: TErrorMessages);
+    /**
+     * Retrieves the API response data associated with the form field.
+     *
+     * @returns {TApiResponse} - The API response data associated with the form field.
+     */
+    get api(): TApiResponse;
+    /**
+     * Sets the API response data associated with the form field and notifies subscribers about the change.
+     *
+     * @param {TApiResponse} response - The new API response data to be set.
+     */
+    set api(response: TApiResponse);
+    /**
+     * notifies templates and event binded field configurations that a request starts it's processing
+     */
+    notifyApiRequest(): void;
+    /** Retrieves the mounted status of the field.
+     *
+     * @returns {boolean} - the mounted status of the field.
+     */
+    get mounted(): boolean;
+    /**
+     * sets the mountedStatus and notifies the form that the field was mounted on the adapter
+     * and it's ready to be handled by the form instance
+     *
+     * @param {boolean} mountedStatus - the mounted status to be set from the mountField function.
+     */
+    set mounted(mountedStatus: boolean);
+    /**
+     * Mounts the form field by initializing necessary subjects and combining their streams.
+     *
+     * @param {object} mountOpts - Adapter mount options.
+     * @param {(value: unknown) => unknown} prop.valueSubscription - Adapter value change function
+     * @param {(payload: Partial<IState>) => unknown} prop.propsSubscription - Adapter prop change function
+     * @returns {void}
+     */
+    mountField({ valueSubscription, propsSubscription, }: {
+        valueSubscription: (value: Record<string, unknown>) => void;
+        propsSubscription: (payload: Partial<IState>) => void;
+    }): void;
+    /**
+     * Sets the value of the form field and emits associated events.
+     *
+     * @param {unknown} prop.value - The new value to be set.
+     * @param {TEvents} prop.event - The event associated with setting the value.
+     * @returns {void}
+     */
+    emitValue(prop: {
+        value: unknown;
+        event: TEvents;
+    }): void;
+    /**
+     * Emits events to trigger field-related actions such as validation, visibility checks, value resets, and API requests.
+     *
+     * @param {TEvents} event - The event type that triggers the field actions.
+     * @returns {void}
+     */
+    emitEvents({ event }: {
+        event: TEvents;
+    }): void;
+    /**
+     * Sets the validity state of the field based on the provided validation rules and triggers error message updates.
+     *
+     * @param {TEvents} event - The event type associated with the field action.
+     * @returns {void}
+     */
+    setFieldValidity({ event }: {
+        event: TEvents;
+    }): void;
+    /**
+     * Formats the field value using the specified formatters, if available.
+     *
+     * @param {unknown} value - The value to be formatted.
+     * @returns {unknown} - The formatted value.
+     */
+    formatValue(value: unknown): unknown;
+    /**
+     * Masks the field value using the specified masks, if available.
+     *
+     * @param {unknown} value - The value to be masked.
+     * @returns {unknown} - The masked value.
+     */
+    maskValue(value: unknown): unknown;
+    checkApiRequestValidations(config: TApiConfig): boolean;
+    /**
+     * Makes an API request based on the field's API configuration and event type, updating the field's API response data.
+     *
+     * @param {TEvents} event - The event type associated with the API request.
+     * @returns {Promise<void>}
+     */
+    apiRequest({ event }: {
+        event: TEvents;
+    }): Promise<void>;
+    /**
+     * Unsubscribes from all subject subscriptions associated with the field, cleaning up resources.
+     *
+     * @returns {void}
+     */
+    destroyField(): void;
+    /**
+     * Subscribes to changes in the field state and executes the provided callback function.
+     *
+     * @param {Function} callback - The callback function to be executed when the field state changes.
+     * @returns {void}
+     */
+    subscribeState(callback: (payload: Partial<IState>) => void): void;
+    /**
+     * Subscribes to changes in the field value and executes the provided callback function.
+     *
+     * @param {Function} callback - The callback function to be executed when the field value changes.
+     * @returns {void}
+     */
+    subscribeValue(callback: (value: unknown) => void): void;
+}
+type IFormField = FormField;
+
+/**
+ * Represents the core logic for managing a form, including field management, validation, and submission.
+ */
+declare class FormCore {
+    index: string;
+    schema?: IFormSchema;
+    fields: Map<string, IFormField>;
+    private _iVars;
+    templateSubject$: Subject<TTemplateEvent>;
+    templateSubscription$: Subscription;
+    submitSubject$: Subject<TFormSubmitPayload<unknown>>;
+    mountSubject$: Subject<{
+        key: string;
+        status: boolean;
+    }>;
+    fieldEventSubject$: Subject<TFieldEvent>;
+    dataSubject$: Subject<TFormDataPayload>;
+    formValidSubject$: Subject<TFormValidationPayload>;
+    fieldValidNotification$: Subject<TFieldValidationPayload>;
+    subscribedTemplates: TSubscribedTemplates[];
+    action?: string;
+    method?: string;
+    config: Required<TSchemaFormConfig>;
+    mappers: Map<string, TMapper<unknown>>;
+    queuedFieldVisibilityEvents: Map<string, {
+        hasError: boolean;
+        showOnlyIfTrue?: boolean;
+    }>;
+    queuedFieldResetValuesEvents: Map<string, {
+        value: unknown;
+    }>;
+    queuedFieldResetPropertyEvents: Map<string, {
+        property: string;
+        path: string;
+        value: unknown;
+    }>;
+    queuedInitialValues: Map<string, unknown>;
+    _valid: boolean;
+    stopEventsOnSubmit: boolean;
+    submitted: boolean;
+    /**
+     * Creates an instance of FormCore.
+     *
+     * @param {TFormEntry & Omit<IFormSchema, 'components'>} entry - Configuration options for the form.
+     * @param {IFormSchema} entry.schema - The schema definition for the form.
+     * @param {Record<string, unknown> | IFormSchema.initialValues} [entry.initialValues] - Initial values for the form fields.
+     * @param {string} [entry.action] - The action attribute of the form.
+     * @param {string} [entry.method] - The method attribute of the form.
+     * @param {IFormSchema.iVars} [entry.iVars] - The internal variables of the form.
+     * @param {((payload: {field: string;data: TFormValues;}) => void) | undefined} [entry.onData] - A callback function to handle data emission.
+     */
+    constructor(entry: TFormEntry & Omit<IFormSchema, 'components'>);
+    /**
+     * mock function to simulate form mount onto the adapter
+     */
+    generateFields(): void;
+    /**
+     *flag utility to prevent Subjects from emitting after form submission and stopEventsOnSubmit
+     * @returns {boolean} - result of the flag utility.
+     */
+    private submitChecker;
+    /**
+     * callback function passed to field instance to notify field adapter mount status
+     * once the field has all field instance properties set, this function will handle all
+     * field routines
+     *
+     * @param { string } entry.key field unique identifier
+     * @param { boolean } entry.status mount status notified from field
+     */
+    mountActions({ key, status }: {
+        key: string;
+        status: boolean;
+    }): void;
+    /**
+     * initialValues setter to handle field values set externally from the adapter
+     *
+     * @param { Record<string, unknown> | undefined } payload initialValues to set onto fields
+     */
+    set initialValues(payload: Record<string, unknown> | undefined);
+    /**
+     * Retrieves the internal variables (iVars) of the form.
+     *
+     * @returns {Record<string, unknown>} - The internal variables of the form.
+     */
+    get iVars(): Record<string, unknown>;
+    /**
+     * Sets the internal variables (iVars) of the form and notifies subscribers about the change.
+     *
+     * @param {Record<string, unknown>} payload - The new internal variables to be set.
+     */
+    set iVars(payload: Record<string, unknown>);
+    /**
+     * Validates all form fields and sets the form valid flag
+     *
+     */
+    validateForm(): boolean;
+    get valid(): boolean;
+    set valid(valid: boolean);
+    /**
+     * Subscribes to templates for dynamic updates.
+     */
+    subscribeTemplates(): void;
+    /**
+     * Gets the value of a property from a field.
+     *
+     * @param {object} options - Options for getting the value.
+     * @param {string} options.key - The key of the field.
+     * @param {string} options.property - The property to retrieve.
+     * @param {string[]} options.path - The path to the property if it's nested.
+     * @returns {unknown | undefined} The value of the property, or undefined if the field doesn't exist.
+     */
+    getValue({ scope, key, property, path, }: {
+        scope: TTemplateAvaliableScopes;
+        key: string;
+        property: string;
+        path: string[];
+    }): unknown | undefined;
+    /**
+     * Sets the value of a property in a field.
+     *
+     * @param {object} options - Options for setting the value.
+     * @param {string} options.key - The key of the field.
+     * @param {string} options.property - The property to set.
+     * @param {string[]} options.path - The path to the property if it's nested.
+     * @param {unknown} options.originKey - field that called templating
+     * @param {unknown} options.value - The value to set.
+     * @param {TMutationEvents} options.event - Internal Event for template Handling.
+     */
+    setValue({ key, property, path, originKey, value, }: {
+        key: string;
+        property: string;
+        path: string[];
+        originKey?: string;
+        value: unknown;
+        event: TMutationEvents;
+    }): void;
+    /**
+     * Extracts parameters from an expression.
+     *
+     * @param {string} expression - The expression containing parameters.
+     * @returns {string[]} An array of extracted parameters.
+     */
+    extractParams(expression: string): unknown[];
+    /**
+     * Replaces expressions marked by ${...} in the expression string with the provided values.
+     *
+     * @param {string} expression - The expression string containing the marked expressions.
+     * @param {string[]} values - The values to be inserted into the marked expressions.
+     * @returns {string} The expression string with the replacements made.
+     */
+    replaceExpression(expression: string, values: unknown[]): string;
+    /**
+     * Checks if an expression string contains string concatenation within a marked expression.
+     *
+     * @param {string} expression - The expression string to be checked.
+     * @returns {boolean} True if the expression contains string concatenation, otherwise false.
+     */
+    hasStringConcatenation(expression: string): boolean;
+    /**
+     * Refreshes templates with updated values.
+     *
+     * @param {object} options - Options for refreshing templates.
+     * @param {string} options.key - The key of the field triggering the update.
+     * @param {TMutationEvents} options.event - Internal event descriptor to handle templating.
+     */
+    refreshTemplates({ key, event }: TTemplateEvent): void;
+    /**
+     * executes events that were stored due to field unavaliability
+     *
+     * @param {string} field field to check
+     */
+    checkFieldEventQueues(field: string): void;
+    /**
+     * Validates and collects the names of form fields in the provided schema structure.
+     *
+     * @param {IComponentSchema[]} [struct] - The schema structure of the form components.
+     * @param {string[]} [indexes=[]] - An array to collect the names of the form fields.
+     * @returns {string[]} - An array of form field names.
+     * @throws {Error} - Throws an error if a field name matches the reserved name defined by `IVARPROPNAME`.
+     * @private
+     */
+    private static checkIndexes;
+    /**
+     * @internal
+     * Update field visibility accordingly.
+     *
+     * @param {object} options - options to set field visibility
+     * @param {string} options.field - Field name to be updated.
+     * @param {boolean} options.hasError - Condition to be used as visibility.
+     * @param {boolean|undefined} options.showOnlyIfTrue - Flag to be considered when update field visibility. If it's true, then considered error, if it's false, always considered the opposite.
+     */
+    private setFieldVisibility;
+    /**
+     * Validates visibility conditions for a given event and updates field visibility accordingly.
+     *
+     * @param {object} options - Options for validating visibility.
+     * @param {TEvents} options.event - The event triggering visibility validation.
+     * @param {string} options.key - The key of the field.
+     */
+    validateVisibility({ event, key }: {
+        event: TEvents;
+        key: string;
+    }): void;
+    /**
+     * @internal
+     * Update field value and emit change and cleared event.
+     *
+     * @param {options} options to reset the field value
+     * @param {string} options.key - Field name to be updated.
+     * @param {unknown} options.value - Value to be inserted into field.
+     */
+    private setResetFieldValue;
+    /**
+     * Resets field values based on reset conditions defined in the schema.
+     *
+     * @param {object} options - Options for resetting field values.
+     * @param {TEvents} options.event - The event triggering the reset.
+     * @param {string} options.key - The key of the field.
+     */
+    resetValue({ event, key }: {
+        event: TEvents;
+        key: string;
+    }): void;
+    /**
+     * @internal
+     * Update field property and emit template change.
+     *
+     * @param {object} options - Options for resetting field property
+     * @param {string} options.key - Field name to be updated.
+     * @param {string} options.property - field property to change.
+     * @param {string} options.path - field property path to change.
+     * @param {unknown} options.value - Value to be inserted into field.
+     */
+    private setResetPathValue;
+    /**
+     * Resets field properties based on reset conditions defined in the schema.
+     *
+     * @param {object} options - Options for resetting field property.
+     * @param {TEvents} options.event - The event triggering the reset.
+     * @param {string} options.key - The key of the field.
+     */
+    resetProperty({ event, key }: {
+        event: TEvents;
+        key: string;
+    }): void;
+    /**
+     * Adds a field onto the form instance regardless there is a schema or not
+     *
+     * @param fieldSchema
+     * @param mapperElement
+     */
+    addField({ fieldSchema, mapperElement, path, }: {
+        fieldSchema: IComponentSchema;
+        mapperElement?: TMapper<unknown>;
+        path?: string;
+    }): void;
+    /**
+     * function to be called from the adapter to remove a field when a field is removed from it
+     *
+     * @param {{ key: string }} entry.key
+     */
+    removeField({ key }: {
+        key: string;
+    }): void;
+    /**
+     * Serializes the schema structure to create form fields.
+     *
+     * @param {IComponentSchema[]} [struct] - The schema structure to serialize.
+     * @param {string} [path] - The path of the parent component.
+     */
+    serializeStructure(struct?: IComponentSchemaAsFormField<unknown>[], path?: string): void;
+    /**
+     * Refreshes form fields based on changes in the schema structure.
+     *
+     * @param {IComponentSchema[]} struct - The updated schema structure.
+     */
+    refreshFields(struct: IComponentSchemaAsFormField<unknown>[]): void;
+    /**
+     * Gets a form field by its key.
+     *
+     * @param {object} options - Options for getting the form field.
+     * @param {string} options.key - The key of the form field.
+     * @returns {IFormField | undefined} The form field, or undefined if not found.
+     */
+    getField({ key }: {
+        key: string;
+    }): IFormField | undefined;
+    /**
+     * Prints the current values of all form fields.
+     */
+    printValues(): void;
+    /**
+     * Gets the current values of all form fields.
+     *
+     * @returns {TFormValues} The current form values.
+     */
+    getFormValues<T>(): TFormValues<T>;
+    /**
+     * function to be called to events sent from the adapter
+     *
+     * @param {{callback: (payload: TFieldEvent) => void}} entry.callback callback function from the adapter
+     * @returns
+     */
+    subscribeFieldEvent({ callback, }: {
+        callback: (payload: TFieldEvent) => void;
+    }): Subscription;
+    /**
+     * to be called from the adapter when the form mounts
+     *
+     * @param {(payload: TFormValues<T>) => void} callback
+     * @returns Subscription
+     */
+    subscribeOnMount<T>(callback: (payload: TFormValues<T>) => void): Subscription;
+    /**
+     *
+     * @param {(payload: { field: string; data: TFormValues }) => void} callback callback function to call onData
+     */
+    subscribeData<T>(callback: (payload: {
+        field: string;
+        data: TFormValues<T>;
+    }) => void): Subscription;
+    /**
+     * method to register a callback function to be called when the form is valid
+     *
+     * @param {(payload: TFormValues<T>) => void} callback callback function to call when the submit action occurs
+     */
+    subscribeOnSubmit<T>(callback: (payload: TFormValues<T>) => void): Subscription;
+    /**
+     * method to check whenever the validity status of the form changes, only emits on status change
+     *
+     * @param {(payload: TFormValidationPayload) => void} callback callback function to call onValid
+     */
+    subscribeFormValidation(callback: (payload: TFormValidationPayload) => void): Subscription;
+    /**
+     * Submits the form by triggering form field events and invoking the onSubmit callback.
+     */
+    submit<T>(): void;
+    /**
+     * recycles all the Suscriptions, to be called from the adapter when the form leaves the page
+     */
+    destroy(): void;
+}
+type TFormCore = FormCore;
+
+/**
+ * Represents a group that manages multiple forms.
+ */
+declare class FormGroup<ComponentElementType> {
+    forms: Map<string, TFormCore>;
+    config: Required<TSchemaFormConfig>;
+    dataSubject$: Subject<TFormDataPayload>;
+    formValidSubject$: Subject<TFormValidationPayload>;
+    submitSubject$: Subject<TFormSubmitPayload<unknown>>;
+    mappers?: TMapper<ComponentElementType>[];
+    /**
+     * Creates an instance of FormGroup.
+     */
+    constructor(entry?: {
+        mappers?: TMapper<ComponentElementType>[];
+        config?: TSchemaFormConfig;
+    });
+    /**
+     * Creates an empty form with given index
+     *
+     * @param {string} options.index
+     * @param {TMapper<unknown>} options.mappers
+     */
+    createFormWithIndex({ index, mappers, }: {
+        index: string;
+        mappers?: TMapper<unknown>[];
+    }): void;
+    /**
+     * Adds a form instance to the form group.
+     *
+     * @param {object} options - Options for adding a form.
+     * @param {string} options.key - The key associated with the form instance.
+     * @param {TFormCore} options.formInstance - The instance of the form to add.
+     */
+    addForm({ key, params }: {
+        key: string;
+        params: TFormEntry;
+    }): void;
+    /**
+     * Retrieves a form instance from the form group.
+     *
+     * @param {object} options - Options for retrieving a form.
+     * @param {string} options.key - The key associated with the form instance.
+     * @returns {TFormCore | undefined} The instance of the form, if found; otherwise, undefined.
+     */
+    getForm({ key }: {
+        key: string;
+    }): TFormCore | undefined;
+    /**
+     * Removes a form instance from the form group.
+     *
+     * @param {object} options - Options for removing a form.
+     * @param {string} options.key - The key associated with the form instance to remove.
+     */
+    removeForm({ key }: {
+        key: string;
+    }): void;
+    /**
+     * removes a field given a form and field index
+     *
+     * @param {string} options.formIndex
+     * @param {string} options.fieldIndex
+     */
+    removeField({ formIndex, fieldIndex, }: {
+        formIndex: string;
+        fieldIndex: string;
+    }): void;
+    /**
+     * Checks if the specified key already exists in the form group.
+     *
+     * @param {object} options - Options for checking the key.
+     * @param {string} options.key - The key to check.
+     * @throws {Error} Throws an error if the key already exists in the form group.
+     */
+    checkIndexes({ key }: {
+        key: string;
+    }): void;
+    /**
+     * Prints the form group instance to the console.
+     */
+    printFormGroupInstance(): void;
+    /**
+     * Prototype submit function to multiple forms
+     * @param {string[]} indexes form indexes to be submitted
+     * @param callback
+     * @returns
+     */
+    submitMultipleFormsByIndex<T>(indexes: string[], callback?: (payload: TFormValues<T>) => void): void;
+    onDataSubscription<T>({ ids, callback, }: {
+        ids: string[];
+        callback: (payload: TFormGroupOnDataEventPayload<T>) => void;
+    }): rxjs.Subscription;
+    onValidSubscription({ ids, callback, }: {
+        ids: string[];
+        callback: (payload: TFormGroupOnValidEventPayload) => void;
+    }): rxjs.Subscription;
+    onSubmitSubscription<T>({ ids, callback, }: {
+        ids: string[];
+        callback: (payload: TFormGroupOnSubmitEventPayload<T>) => void;
+    }): rxjs.Subscription;
+    destroy: () => void;
+}
+type TFormGroup<T> = FormGroup<T>;
+
+/**
+ * @type TEventEnum
+ * Represents the different types of events that can occur on form fields.
+ * @property {never} ON_FIELD_MOUNT - when field mounts on page
+ * @property {never} ON_FIELD_UNMOUNT - when field unmounts on page (also triggered when form is unmounted from page)
+ * @property {never} ON_FIELD_CHANGE - when field changes value by user inout
+ * @property {never} ON_FIELD_BLUR - when field is blurred
+ * @property {never} ON_FIELD_FOCUS - when field is focused
+ * @property {never} ON_FIELD_CLICK - when field is clicked
+ * @property {never} ON_FIELD_KEYUP - when the pressing key button on field is lifted up
+ * @property {never} ON_FIELD_KEYDOWN - when a key button on field is pressed down
+ * @property {never} ON_FIELD_CLEARED - when a field was changed with a resetValues rule
+ * @property {never} ON_FORM_SUBMIT - when the form is submitted (only type="submit" buttons)
+ * @property {never} ON_FIELD_VALIDATION - when a field is validaded by a validation rule
+ * @property {never} ON_FORM_MOUNT - emitted when the form mounts
+ * @property {never} ON_API_FIELD_REQUEST - emitted when an api request from schema is called
+ * @property {never} ON_API_FIELD_RESPONSE - emitted when an api response from schema is received
+ *
+ * @example
+ * ```typescript
+ * const event: TEvents = 'ON_FIELD_CHANGE';
+ * ```
+ */
+type TEventEnum = {
+    ON_FIELD_MOUNT: never;
+    ON_FIELD_UNMOUNT: never;
+    ON_FIELD_CHANGE: never;
+    ON_FIELD_BLUR: never;
+    ON_FIELD_FOCUS: never;
+    ON_FIELD_CLICK: never;
+    ON_FIELD_KEYUP: never;
+    ON_FIELD_KEYDOWN: never;
+    ON_FIELD_CLEARED: never;
+    ON_FORM_SUBMIT: never;
+    ON_FIELD_VALIDATION: never;
+    ON_FORM_MOUNT: never;
+    ON_API_FIELD_REQUEST: never;
+    ON_API_FIELD_RESPONSE: never;
+};
+type TEvents = keyof TEventEnum;
+/**
+ * Represents the possible event properties for form fields callbacks.
+ * * Represents a mapping of event properties to their corresponding callback functions.
+ * @property {string} onChange - trigger bind component change event
+ * @property {string} onBlur - trigger bind component blur event
+ * @property {string} onFocus - trigger bind component focus event
+ * @property {string} onKeyDown - trigger bind component keydown event
+ * @property {string} onKeyUp - trigger bind component keyup event
+ * @property {string} onMount - triggered on field mount
+ * @property {string} onApiResponse - triggered when schema api call is completed
+ * @property {string} onApiRequest - triggered when schema api call starts
+ * @property {string} onClick - trigger bind component keyup event
+ * @property {string} onCleared - triggered when a resetValue rule apply on the target field
+ * @property {string} onUnmount - triggered when a field unmounts
+ */
+type TEventPropsEnum = {
+    onChange: never;
+    onBlur: never;
+    onFocus: never;
+    onKeyDown: never;
+    onKeyUp: never;
+    onMount: never;
+    onApiResponse: never;
+    onApiRequest: never;
+    onClick: never;
+    onCleared: never;
+    onUnmount: never;
+};
+type TEventProps = keyof TEventPropsEnum;
+type TEventDataPropsEnum = {
+    onFormMount: never;
+    onData: never;
+    onSubmit: never;
+    onValid: never;
+};
+type TEventDataProps = keyof TEventDataPropsEnum;
+/**
+ * @type TMutationEvents
+ * Represents the different types of events that can occur internally that triggers templating.
+ *
+ * @example
+ * ```typescript
+ * const event: TMutationEvents = 'ON_VALUE';
+ * ```
+ */
+type TMutationEvents = 'ON_VALUE' | 'ON_PROPS' | 'ON_VISIBILITY' | 'ON_API_REQUEST' | 'ON_API_RESPONSE' | 'ON_IVARS' | 'ON_FIELDS' | 'ON_RESET' | 'ON_FORM';
+declare enum TMutationEnum {
+    ON_VALUE = "value",
+    ON_PROPS = "props",
+    ON_VISIBILITY = "visibility",
+    ON_API = "api",
+    ON_IVARS = "iVars",
+    ON_FIELDS = "fields"
+}
+/**
+ * @type TValueChangeEvent
+ * Represents the custom change handle function to perform value changes.
+ *
+ * @example
+ * ```typescript
+ * handleChangeEvent (value, opts) {
+ *   return value
+ * }
+ * ```
+ */
+type TValueChangeEvent = (value: unknown, opts?: {
+    props: Record<string, unknown>;
+}) => void;
+/**
+ * @type TFieldEvent
+ * Event emitted on all basic form events, except onData
+ */
+type TFieldEvent = {
+    event: TEvents;
+    fieldName: string;
+    fieldInstance?: IFormField;
+};
+/**
+ * @type TFormDataPayload
+ * Event emitted to formGroup instance to capture onData form events
+ */
+type TFormDataPayload = {
+    formIndex: string;
+    fieldIndex: string;
+    event: TEvents;
+};
+/**
+ * @type TFormSubmitPayload
+ * Event emitted to formGroup instance to capture onSubmit form events
+ */
+type TFormSubmitPayload<T> = {
+    formIndex: string;
+    values: TFormValues<T>;
+};
+/**
+ * @type TFormValidationPayload
+ * Form onValid event emmited payload on callback function parameter
+ */
+type TFormValidationPayload = {
+    formIndex: string;
+    valid: boolean;
+};
+/**
+ * @type TFieldValidationPayload
+ * field event emmited payload on field validation
+ */
+type TFieldValidationPayload = {
+    fieldTrigger: string;
+};
+type TFormDataValues<T> = {
+    formId: string;
+    formField: string;
+    values?: TFormValues<T>;
+};
+/**
+ * @type TFormGroupOnDataEventPayload
+ * Form Group onData event emitted payload on callback function parameter
+ */
+type TFormGroupOnDataEventPayload<T> = Record<string, TFormDataValues<T>>;
+/**
+ * @type TFormGroupOnValidEventPayload
+ * Form Group onValid event emitted payload on callback function parameter
+ */
+type TFormGroupOnValidEventPayload = {
+    groupValid: boolean;
+    forms: Record<string, boolean>;
+};
+/**
+ * @type TFormGroupOnSubmitEventPayload
+ * Form Group onSubmit event emitted payload on callback function parameter
+ */
+type TFormGroupOnSubmitEventPayload<T> = Record<string, TFormValues<T> | undefined>;
+
+export { FormCore, FormField, FormGroup, TMutationEnum };
+export type { AllowOnly, IComponentSchema, IComponentSchemaAsFormField, IFormField, IFormSchema, IState, OneOf, TAllowedResetPropsMutationsEnum, TApiConfig, TApiEvent, TApiResponse, TApiResponsePayload, TAvailableValidations, TBetweenDatesValidation, TBetweenValidation, TCallbackValidation, TComponentPropsMapping, TConditionsValidation, TConditionsValidationSet, TCreditCardMatch, TCurrencyMask, TDateFormatsValidation, TDateInterval, TDateOperatorsValidation, TDateValidation, TDocumentValidation, TErrorMessages, TEvent, TEventDataProps, TEventDataPropsEnum, TEventEnum, TEventMessages, TEventMessagesValidationMethods, TEventProps, TEventPropsEnum, TEvents, TFieldEvent, TFieldValidationPayload, TFormCore, TFormDataPayload, TFormDataValues, TFormEntry, TFormGroup, TFormGroupOnDataEventPayload, TFormGroupOnSubmitEventPayload, TFormGroupOnValidEventPayload, TFormSubmitPayload, TFormValidationPayload, TFormValues, TFormatters, TGenericValidationRule, TLengthValidation, TMapper, TMaskGeneric, TMasks, TMultipleValidation, TMutationEvents, TProps, TResetPathMethods, TResetValueMethods, TSchemaFormConfig, TSchemaValidation, TSplitterFormatterValue, TSubscribedTemplates, TTemplateAvaliableScopes, TTemplateAvaliableScopesEnum, TTemplateEvent, TValidationHandler, TValidationMethods, TValidations, TValueChangeEvent, TVisibility };