@bolttech/form-engine-core 1.1.0-beta.0 → 1.1.0

package/credit-card.d.ts

@@ -0,0 +1,743 @@
+import { TCurrencyCode, TCurrencyLocalCode } from '@gaignoux/currency';
+
+/**
+ * @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;
+};
+
+/** @virtual */
+
+/**
+ * @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, formValues: Pick<TFormValues<unknown>, 'values' | 'metadata'>) => 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>;
+/**
+ * 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;
+};
+
+/**
+ * Validates if a given value is a valid credit card number based on predefined validation methods.
+ *
+ * @param value - The value to be validated as a credit card number.
+ * @param validations - An object containing validation methods.
+ * @returns `true` if the value is either falsy or does not match a valid credit card type, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCard } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCard('4111111111111111', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+declare const isCreditCard: (value: unknown, validations: TValidationMethods) => boolean;
+/**
+ * Validates if a given security code matches the expected length for a specified credit card type.
+ *
+ * @param value - The security code to be validated.
+ * @param validations - An object containing validation methods, specifically with `isCreditCodeMatch` details.
+ * @returns `true` if the value is either falsy or if the validation methods are not provided. Otherwise, it checks if the security code length matches the expected length for the card type.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCodeMatch } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCodeMatch('123', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+declare const isCreditCodeMatch: (value: string, validations: TValidationMethods) => boolean;
+/**
+ * Validates if a given value is a valid credit card number and checks if its length matches the expected lengths for the card type.
+ *
+ * @param value - The credit card number to be validated.
+ * @param validations - An object containing validation methods, specifically with `isCreditCardAndLength` details.
+ * @returns `true` if the value is either falsy or if the card number does not match any valid lengths for the card type, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCardAndLength } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCardAndLength('4111111111111111', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+declare const isCreditCardAndLength: (value: string, validations: TValidationMethods) => boolean;
+
+/**
+ * Formats a credit card number by adding gaps based on the card type.
+ *
+ * @param {unknown} value - The input value to be formatted, expected to be a string representing a credit card number.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {boolean} formatters.gapsCreditCard - A flag indicating whether to apply credit card gap formatting.
+ * @returns {unknown} - The formatted credit card number with appropriate gaps, or the original value if formatting is not applied.
+ *
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: true };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111 1111 1111 1111" (formatted based on card type, e.g., Visa)
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: false };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111111111111111" (no formatting applied)
+ * ```
+ */
+declare const gapsCreditCard: (value: unknown, formatters: TFormatters) => unknown;
+
+/**
+ * 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'
+ * ```
+ */
+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'
+ * ```
+ */
+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'
+ * ```
+ */
+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'
+ * ```
+ */
+declare const fein: (value: string) => string;
+
+export { card, cardDate, fein, gapsCreditCard, isCreditCard, isCreditCardAndLength, isCreditCodeMatch, secureCreditCard };