@bolttech/form-engine-core 1.0.10 → 1.1.0

package/src/managers/form.d.ts

@@ -0,0 +1,357 @@
+import { IFormField } from './field';
+import { Subject, Subscription } from 'rxjs';
+import { IComponentSchema, IComponentSchemaAsFormField, IFormSchema, TPrefetchedFieldData } from '../interfaces/schema';
+import { TSchemaFormConfig } from '../types/schema';
+import { TSubscribedTemplates, TTemplateAvaliableScopes, TTemplateEvent } from '../types/template';
+import { TEvents, TFieldEvent, TFieldValidationPayload, TFormDataPayload, TFormSubmitPayload, TFormValidationPayload, TMutationEvents } from '../types/event';
+import { TFormEntry, TFormValues } from '../types/form';
+import { TMapper } from '../types/mapper';
+import { SafeBehaviourSubject } from '../helpers/SafeSubject';
+/**
+ * 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>;
+    formValuesStateSubject$: SafeBehaviourSubject<TFormValues<unknown>>;
+    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>;
+    prefetchedData?: Record<string, TPrefetchedFieldData>;
+    _valid: boolean;
+    stopEventsOnSubmit: boolean;
+    submitted: boolean;
+    getFormValues: () => TFormValues<unknown>;
+    isolatedFormInstance: 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.
+     */
+    getFormState<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;
+export { TFormCore, FormCore };

package/src/managers/formGroup.d.ts

@@ -0,0 +1,110 @@
+import { Subject } from 'rxjs';
+import { TFormEntry, TFormValues } from '../types/form';
+import { TMapper } from '../types/mapper';
+import { TFormCore } from './form';
+import { TSchemaFormConfig } from '../types/schema';
+import { TFormDataPayload, TFormGroupOnDataEventPayload, TFormGroupOnSubmitEventPayload, TFormGroupOnValidEventPayload, TFormSubmitPayload, TFormValidationPayload } from '../types/event';
+/**
+ * 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;
+    }): import("rxjs").Subscription;
+    onValidSubscription({ ids, callback, }: {
+        ids: string[];
+        callback: (payload: TFormGroupOnValidEventPayload) => void;
+    }): import("rxjs").Subscription;
+    onSubmitSubscription<T>({ ids, callback, }: {
+        ids: string[];
+        callback: (payload: TFormGroupOnSubmitEventPayload<T>) => void;
+    }): import("rxjs").Subscription;
+    destroy: () => void;
+}
+type TFormGroup<T> = FormGroup<T>;
+export { TFormGroup, FormGroup };

package/src/managers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './form';
+export * from './field';
+export * from './formGroup';

package/src/masks/creditCard.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Applies a secure mask to a credit card number, hiding most of its digits.
+ *
+ * @param value - The credit card number to be masked.
+ * @returns The masked credit card number.
+ *
+ * @example
+ * ```typescript
+ * import { secureCreditCard } from './path/to/creditCardFunctions';
+ *
+ * const maskedCardNumber = secureCreditCard('1234567890123456');
+ * console.log(maskedCardNumber); // Output: '1xxxxxxxxxxxx456'
+ * ```
+ */
+export declare const secureCreditCard: (value: string) => string;
+/**
+ * Formats a credit card number by inserting spaces every four characters.
+ *
+ * @param value - The credit card number to be formatted.
+ * @returns The formatted credit card number.
+ *
+ * @example
+ * ```typescript
+ * import { card } from './path/to/creditCardFunctions';
+ *
+ * const formattedCardNumber = card('1234567890123456');
+ * console.log(formattedCardNumber); // Output: '1234 5678 9012 3456'
+ * ```
+ */
+export declare const card: (value: string) => string;
+/**
+ * Formats a credit card expiration date (MM/YY).
+ *
+ * @param value - The expiration date to be formatted (in MMYY or MM/YY format).
+ * @returns The formatted expiration date.
+ *
+ * @example
+ * ```typescript
+ * import { cardDate } from './path/to/creditCardFunctions';
+ *
+ * const formattedCardDate = cardDate('1223');
+ * console.log(formattedCardDate); // Output: '12/23'
+ * ```
+ */
+export declare const cardDate: (value: string) => string;
+/**
+ * Formats a credit card FEIN (Federal Employer Identification Number) in a specific format.
+ *
+ * @param value - The FEIN to be formatted.
+ * @returns The formatted FEIN.
+ *
+ * @example
+ * ```typescript
+ * import { fein } from './path/to/creditCardFunctions';
+ *
+ * const formattedFEIN = fein('123456789');
+ * console.log(formattedFEIN); // Output: '12-3456789'
+ * ```
+ */
+export declare const fein: (value: string) => string;

package/src/masks/currency.d.ts

@@ -0,0 +1,29 @@
+import { TMasks } from '../types/schema';
+/**
+ * Formats a numeric value as a currency string based on the provided mask configuration.
+ *
+ * @param value - The numeric value to be formatted.
+ * @param masks - An object containing the mask configuration.
+ * @returns The formatted currency string.
+ *
+ * @example
+ * ```typescript
+ * import { currency } from './path/to/maskFunctions';
+ *
+ * const masks = {
+ *   currency: {
+ *     align: 'right',
+ *     decimal: ',',
+ *     precision: 2,
+ *     prefix: 'USD',
+ *     thousands: '.'
+ *   }
+ * };
+ *
+ * const formattedValue = currency(12345.67, masks);
+ * console.log(formattedValue); // Output: '12.345,67 $'
+ *
+ * PS: To unCurrency this value, usage onlyFloatNumber formatter
+ * ```
+ */
+export declare const currency: (value: string | number, masks: TMasks) => unknown;

package/src/masks/generic.d.ts

@@ -0,0 +1,39 @@
+import { TMasks } from '../types/schema';
+/**
+ * Applies multiple generic masks to a string based on the provided mask configuration.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import maskValue from './path/to/maskFunctions';
+ *
+ * const masks = {
+ *   generic: [
+ *     { from: 2, to: 4, mask: '*' },
+ *     { from: 7, to: 9, mask: '#' }
+ *   ]
+ * };
+ *
+ * const maskedValue = maskValue('123456789', masks);
+ * console.log(maskedValue); // Output: '1**45###9'
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   value: 'abcdefghij',
+ *   masks: {
+ *     generic: [
+ *       { from: 3, to: 6, mask: '*' },
+ *       { from: 8, to: 10, mask: '#' }
+ *     ]
+ *   }
+ * };
+ *
+ * const maskedValue = maskValue(config.value, config.masks);
+ * console.log(maskedValue); // Output: 'ab***gh###'
+ * ```
+ */
+declare const _default: (value: string, masks: TMasks | null) => string;
+export default _default;

package/src/masks/handler.d.ts

@@ -0,0 +1,2 @@
+import { TMasks } from '../types/schema';
+export declare const masks: Record<string, (value: unknown, masks?: TMasks | null) => unknown>;

package/src/masks/string.d.ts

@@ -0,0 +1,37 @@
+import { TMasks } from '../types/schema';
+/**
+ * Replaces all characters in a string with a specified replacement string or character.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import { replaceAll } from './path/to/maskFunctions';
+ *
+ * const masks = { replaceAll: '*' };
+ *
+ * const maskedValue = replaceAll('12345', masks);
+ * console.log(maskedValue); // Output: '*****'
+ * ```
+ */
+export declare const replaceAll: (value: string | number, masks: TMasks) => unknown;
+/**
+ * Applies a custom mask to a string based on the provided mask configuration.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import { custom } from './path/to/maskFunctions';
+ *
+ * const masks = { custom: '##-##' };
+ *
+ * const maskedValue = custom('123456', masks);
+ * console.log(maskedValue); // Output: '12-34'
+ * ```
+ */
+export declare const custom: (value: string, masks: TMasks) => string;

package/src/plugins/credit-card.d.ts

@@ -0,0 +1,4 @@
+import { isCreditCard, isCreditCardAndLength, isCreditCodeMatch } from '../validations/creditCard';
+import { gapsCreditCard } from '../formatters/creditCard';
+import { secureCreditCard, card, cardDate, fein } from '../masks/creditCard';
+export { isCreditCard, isCreditCardAndLength, isCreditCodeMatch, gapsCreditCard, secureCreditCard, card, cardDate, fein, };

package/src/plugins/currency.d.ts

@@ -0,0 +1,2 @@
+import { currency } from '../masks/currency';
+export { currency };

package/src/plugins/date.d.ts

@@ -0,0 +1,2 @@
+import { date, betweenDates, validDate } from '../validations/date';
+export { date, betweenDates, validDate };

package/src/plugins/document.d.ts

@@ -0,0 +1,2 @@
+import document from '../validations/document';
+export { document };

package/src/registry.d.ts

@@ -0,0 +1,20 @@
+import { TValidationHandler } from './types/utility';
+/**
+ * Global mutable registries for validations, formatters, and masks.
+ * Plugins (sub-path exports) can extend these at import time.
+ */
+export declare const validationRegistry: TValidationHandler;
+export declare const formatterRegistry: Record<string, (value: unknown, formatters?: any) => unknown>;
+export declare const maskRegistry: Record<string, (value: unknown, masks?: any) => unknown>;
+/**
+ * Registers additional validation methods into the global registry.
+ */
+export declare function registerValidations(methods: TValidationHandler): void;
+/**
+ * Registers additional formatter methods into the global registry.
+ */
+export declare function registerFormatters(methods: Record<string, (value: unknown, formatters?: any) => unknown>): void;
+/**
+ * Registers additional mask methods into the global registry.
+ */
+export declare function registerMasks(methods: Record<string, (value: unknown, masks?: any) => unknown>): void;