@archi-code/validation 0.0.0-stage → 3.0.0-alpha.2

package/dist/cjs/validators/isLicensePlate.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLicensePlate = isLicensePlate;
+const string_1 = require("../convert/string");
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const config_1 = require("../helpers/config");
+const validators = {
+    'cs-CZ': (str) => /^(([ABCDEFHIJKLMNPRSTUVXYZ]|[0-9])-?){5,8}$/.test(str),
+    'de-DE': (str) => /^((A|AA|AB|AC|AE|AH|AK|AM|AN|AÖ|AP|AS|AT|AU|AW|AZ|B|BA|BB|BC|BE|BF|BH|BI|BK|BL|BM|BN|BO|BÖ|BS|BT|BZ|C|CA|CB|CE|CO|CR|CW|D|DA|DD|DE|DH|DI|DL|DM|DN|DO|DU|DW|DZ|E|EA|EB|ED|EE|EF|EG|EH|EI|EL|EM|EN|ER|ES|EU|EW|F|FB|FD|FF|FG|FI|FL|FN|FO|FR|FS|FT|FÜ|FW|FZ|G|GA|GC|GD|GE|GF|GG|GI|GK|GL|GM|GN|GÖ|GP|GR|GS|GT|GÜ|GV|GW|GZ|H|HA|HB|HC|HD|HE|HF|HG|HH|HI|HK|HL|HM|HN|HO|HP|HR|HS|HU|HV|HX|HY|HZ|IK|IL|IN|IZ|J|JE|JL|K|KA|KB|KC|KE|KF|KG|KH|KI|KK|KL|KM|KN|KO|KR|KS|KT|KU|KW|KY|L|LA|LB|LC|LD|LF|LG|LH|LI|LL|LM|LN|LÖ|LP|LR|LU|M|MA|MB|MC|MD|ME|MG|MH|MI|MK|ML|MM|MN|MO|MQ|MR|MS|MÜ|MW|MY|MZ|N|NB|ND|NE|NF|NH|NI|NK|NM|NÖ|NP|NR|NT|NU|NW|NY|NZ|OA|OB|OC|OD|OE|OF|OG|OH|OK|OL|OP|OS|OZ|P|PA|PB|PE|PF|PI|PL|PM|PN|PR|PS|PW|PZ|R|RA|RC|RD|RE|RG|RH|RI|RL|RM|RN|RO|RP|RS|RT|RU|RV|RW|RZ|S|SB|SC|SE|SG|SI|SK|SL|SM|SN|SO|SP|SR|ST|SU|SW|SY|SZ|TE|TF|TG|TO|TP|TR|TS|TT|TÜ|ÜB|UE|UH|UL|UM|UN|V|VB|VG|VK|VR|VS|W|WA|WB|WE|WF|WI|WK|WL|WM|WN|WO|WR|WS|WT|WÜ|WW|WZ|Z|ZE|ZI|ZP|ZR|ZW|ZZ)[- ]?[A-Z]{1,2}[- ]?\d{1,4}|(ABG|ABI|AIB|AIC|ALF|ALZ|ANA|ANG|ANK|APD|ARN|ART|ASL|ASZ|AUR|AZE|BAD|BAR|BBG|BCH|BED|BER|BGD|BGL|BID|BIN|BIR|BIT|BIW|BKS|BLB|BLK|BNA|BOG|BOH|BOR|BOT|BRA|BRB|BRG|BRK|BRL|BRV|BSB|BSK|BTF|BÜD|BUL|BÜR|BÜS|BÜZ|CAS|CHA|CLP|CLZ|COC|COE|CUX|DAH|DAN|DAU|DBR|DEG|DEL|DGF|DIL|DIN|DIZ|DKB|DLG|DON|DUD|DÜW|EBE|EBN|EBS|ECK|EIC|EIL|EIN|EIS|EMD|EMS|ERB|ERH|ERK|ERZ|ESB|ESW|FDB|FDS|FEU|FFB|FKB|FLÖ|FOR|FRG|FRI|FRW|FTL|FÜS|GAN|GAP|GDB|GEL|GEO|GER|GHA|GHC|GLA|GMN|GNT|GOA|GOH|GRA|GRH|GRI|GRM|GRZ|GTH|GUB|GUN|GVM|HAB|HAL|HAM|HAS|HBN|HBS|HCH|HDH|HDL|HEB|HEF|HEI|HER|HET|HGN|HGW|HHM|HIG|HIP|HMÜ|HOG|HOH|HOL|HOM|HOR|HÖS|HOT|HRO|HSK|HST|HVL|HWI|IGB|ILL|JÜL|KEH|KEL|KEM|KIB|KLE|KLZ|KÖN|KÖT|KÖZ|KRU|KÜN|KUS|KYF|LAN|LAU|LBS|LBZ|LDK|LDS|LEO|LER|LEV|LIB|LIF|LIP|LÖB|LOS|LRO|LSZ|LÜN|LUP|LWL|MAB|MAI|MAK|MAL|MED|MEG|MEI|MEK|MEL|MER|MET|MGH|MGN|MHL|MIL|MKK|MOD|MOL|MON|MOS|MSE|MSH|MSP|MST|MTK|MTL|MÜB|MÜR|MYK|MZG|NAB|NAI|NAU|NDH|NEA|NEB|NEC|NEN|NES|NEW|NMB|NMS|NOH|NOL|NOM|NOR|NVP|NWM|OAL|OBB|OBG|OCH|OHA|ÖHR|OHV|OHZ|OPR|OSL|OVI|OVL|OVP|PAF|PAN|PAR|PCH|PEG|PIR|PLÖ|PRÜ|QFT|QLB|RDG|REG|REH|REI|RID|RIE|ROD|ROF|ROK|ROL|ROS|ROT|ROW|RSL|RÜD|RÜG|SAB|SAD|SAN|SAW|SBG|SBK|SCZ|SDH|SDL|SDT|SEB|SEE|SEF|SEL|SFB|SFT|SGH|SHA|SHG|SHK|SHL|SIG|SIM|SLE|SLF|SLK|SLN|SLS|SLÜ|SLZ|SMÜ|SOB|SOG|SOK|SÖM|SON|SPB|SPN|SRB|SRO|STA|STB|STD|STE|STL|SUL|SÜW|SWA|SZB|TBB|TDO|TET|TIR|TÖL|TUT|UEM|UER|UFF|USI|VAI|VEC|VER|VIB|VIE|VIT|VOH|WAF|WAK|WAN|WAR|WAT|WBS|WDA|WEL|WEN|WER|WES|WHV|WIL|WIS|WIT|WIZ|WLG|WMS|WND|WOB|WOH|WOL|WOR|WOS|WRN|WSF|WST|WSW|WTL|WTM|WUG|WÜM|WUN|WUR|WZL|ZEL|ZIG)[- ]?(([A-Z][- ]?\d{1,4})|([A-Z]{2}[- ]?\d{1,3})))[- ]?(E|H)?$/.test(str),
+    'de-LI': (str) => /^FL[- ]?\d{1,5}[UZ]?$/.test(str),
+    'en-IN': (str) => /^[A-Z]{2}[ -]?[0-9]{1,2}(?:[ -]?[A-Z])(?:[ -]?[A-Z]*)?[ -]?[0-9]{4}$/.test(str),
+    'en-SG': (str) => /^[A-Z]{3}[ -]?[\d]{4}[ -]?[A-Z]{1}$/.test(str),
+    'es-AR': (str) => /^(([A-Z]{2} ?[0-9]{3} ?[A-Z]{2})|([A-Z]{3} ?[0-9]{3}))$/.test(str),
+    'fi-FI': (str) => /^(?=.{4,7}$)(([A-Z]{1,3}|[0-9]{1,3})[\s-]?([A-Z]{1,3}|[0-9]{1,5}))$/.test(str),
+    'hu-HU': (str) => /^((((?!AAA)(([A-NPRSTVZWXY]{1})([A-PR-Z]{1})([A-HJ-NPR-Z]))|(A[ABC]I)|A[ABC]O|A[A-W]Q|BPI|BPO|UCO|UDO|XAO)-(?!000)\d{3})|(M\d{6})|((CK|DT|CD|HC|H[ABEFIKLMNPRSTVX]|MA|OT|R[A-Z]) \d{2}-\d{2})|(CD \d{3}-\d{3})|(C-(C|X) \d{4})|(X-(A|B|C) \d{4})|(([EPVZ]-\d{5}))|(S A[A-Z]{2} \d{2})|(SP \d{2}-\d{2}))$/.test(str),
+    'pt-BR': (str) => /^(?:[A-Z]{3}[ -]?[0-9][A-Z][0-9]{2}|[A-Z]{3}[ -]?[0-9]{4})$/.test(str),
+    'pt-PT': (str) => /^(([A-Z]{2}[ -·]?[0-9]{2}[ -·]?[0-9]{2})|([0-9]{2}[ -·]?[A-Z]{2}[ -·]?[0-9]{2})|([0-9]{2}[ -·]?[0-9]{2}[ -·]?[A-Z]{2})|([A-Z]{2}[ -·]?[0-9]{2}[ -·]?[A-Z]{2}))$/.test(str),
+    'sq-AL': (str) => /^[A-Z]{2}[- ]?((\d{3}[- ]?(([A-Z]{2})|T))|(R[- ]?\d{3}))$/.test(str),
+    'sv-SE': (str) => /^[A-HJ-PR-UW-Z]{3} ?[\d]{2}[A-HJ-PR-UW-Z1-9]$|(^[A-ZÅÄÖ ]{2,7}$)/.test(str.trim()),
+    'en-PK': (str) => /(^[A-Z]{2}((\s|-){0,1})[0-9]{3,4}((\s|-)[0-9]{2}){0,1}$)|(^[A-Z]{3}((\s|-){0,1})[0-9]{3,4}((\s|-)[0-9]{2}){0,1}$)|(^[A-Z]{4}((\s|-){0,1})[0-9]{3,4}((\s|-)[0-9]{2}){0,1}$)|(^[A-Z]((\s|-){0,1})[0-9]{4}((\s|-)[0-9]{2}){0,1}$)/.test(str.trim()),
+};
+function isLicensePlate(value, options) {
+    const { locale } = (0, config_1.optionsOf)(options);
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if ((0, hasOwn_1.hasOwn)(validators, locale)) {
+        return validators[locale](str);
+    }
+    if (locale === 'any') {
+        for (const key in validators) {
+            const validator = validators[key];
+            if (validator(str)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    throw new errors_1.ValidationConfigError(`Invalid locale '${(0, config_1.configText)(locale)}'`);
+}

package/dist/cjs/validators/isLocale.d.ts

@@ -0,0 +1 @@
+export declare function isLocale(value: unknown): boolean;

package/dist/cjs/validators/isLocale.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocale = isLocale;
+const string_1 = require("../convert/string");
+const extlang = '([A-Za-z]{3}(-[A-Za-z]{3}){0,2})';
+const language = `(([a-zA-Z]{2,3}(-${extlang})?)|([a-zA-Z]{5,8}))`;
+const script = '([A-Za-z]{4})';
+const region = '([A-Za-z]{2}|\\d{3})';
+const variant = '([A-Za-z0-9]{5,8}|(\\d[A-Z-a-z0-9]{3}))';
+const singleton = '(\\d|[A-W]|[Y-Z]|[a-w]|[y-z])';
+const extension = `(${singleton}(-[A-Za-z0-9]{2,8})+)`;
+const privateuse = '(x(-[A-Za-z0-9]{1,8})+)';
+const irregular = '((en-GB-oed)|(i-ami)|(i-bnn)|(i-default)|(i-enochian)|' +
+    '(i-hak)|(i-klingon)|(i-lux)|(i-mingo)|(i-navajo)|(i-pwn)|(i-tao)|' +
+    '(i-tay)|(i-tsu)|(sgn-BE-FR)|(sgn-BE-NL)|(sgn-CH-DE))';
+const regular = '((art-lojban)|(cel-gaulish)|(no-bok)|(no-nyn)|(zh-guoyu)|' +
+    '(zh-hakka)|(zh-min)|(zh-min-nan)|(zh-xiang))';
+const grandfathered = `(${irregular}|${regular})`;
+const delimiter = '(-|_)';
+const langtag = `${language}(${delimiter}${script})?(${delimiter}${region})?(${delimiter}${variant})*(${delimiter}${extension})*(${delimiter}${privateuse})?`;
+const languageTagRegex = new RegExp(`(^${privateuse}$)|(^${grandfathered}$)|(^${langtag}$)`);
+function isLocale(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return languageTagRegex.test(str);
+}

package/dist/cjs/validators/isLowercase.d.ts

@@ -0,0 +1 @@
+export declare function isLowercase(value: unknown): boolean;

package/dist/cjs/validators/isLowercase.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLowercase = isLowercase;
+const string_1 = require("../convert/string");
+function isLowercase(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return str === str.toLowerCase();
+}

package/dist/cjs/validators/isLuhnNumber.d.ts

@@ -0,0 +1 @@
+export declare function isLuhnNumber(value: unknown): boolean;

package/dist/cjs/validators/isLuhnNumber.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLuhnNumber = isLuhnNumber;
+const string_1 = require("../convert/string");
+const digitsOnly = /^[0-9]+$/;
+function isLuhnNumber(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const sanitized = str.replace(/[- ]+/g, '');
+    if (!digitsOnly.test(sanitized))
+        return false;
+    let sum = 0;
+    let digit;
+    let tmpNum;
+    let shouldDouble;
+    for (let i = sanitized.length - 1; i >= 0; i--) {
+        digit = sanitized.substring(i, i + 1);
+        tmpNum = parseInt(digit, 10);
+        if (shouldDouble) {
+            tmpNum *= 2;
+            if (tmpNum >= 10) {
+                sum += (tmpNum % 10) + 1;
+            }
+            else {
+                sum += tmpNum;
+            }
+        }
+        else {
+            sum += tmpNum;
+        }
+        shouldDouble = !shouldDouble;
+    }
+    return !!(sum % 10 === 0 ? sanitized : false);
+}

package/dist/cjs/validators/isMACAddress.d.ts

@@ -0,0 +1,6 @@
+export interface IsMACAddressOptions {
+    no_separators?: boolean;
+    no_colons?: boolean;
+    eui?: '48' | '64' | 48 | 64;
+}
+export declare function isMACAddress(value: unknown, options?: IsMACAddressOptions): boolean;

package/dist/cjs/validators/isMACAddress.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMACAddress = isMACAddress;
+const string_1 = require("../convert/string");
+const macAddress48 = /^(?:[0-9a-fA-F]{2}([-:\s]))([0-9a-fA-F]{2}\1){4}([0-9a-fA-F]{2})$/;
+const macAddress48NoSeparators = /^([0-9a-fA-F]){12}$/;
+const macAddress48WithDots = /^([0-9a-fA-F]{4}\.){2}([0-9a-fA-F]{4})$/;
+const macAddress64 = /^(?:[0-9a-fA-F]{2}([-:\s]))([0-9a-fA-F]{2}\1){6}([0-9a-fA-F]{2})$/;
+const macAddress64NoSeparators = /^([0-9a-fA-F]){16}$/;
+const macAddress64WithDots = /^([0-9a-fA-F]{4}\.){3}([0-9a-fA-F]{4})$/;
+function isMACAddress(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const eui = options?.eui ? String(options.eui) : undefined;
+    if (options?.no_colons || options?.no_separators) {
+        if (eui === '48') {
+            return macAddress48NoSeparators.test(str);
+        }
+        if (eui === '64') {
+            return macAddress64NoSeparators.test(str);
+        }
+        return macAddress48NoSeparators.test(str) || macAddress64NoSeparators.test(str);
+    }
+    if (eui === '48') {
+        return macAddress48.test(str) || macAddress48WithDots.test(str);
+    }
+    if (eui === '64') {
+        return macAddress64.test(str) || macAddress64WithDots.test(str);
+    }
+    return isMACAddress(str, { eui: '48' }) || isMACAddress(str, { eui: '64' });
+}

package/dist/cjs/validators/isMD5.d.ts

@@ -0,0 +1 @@
+export declare function isMD5(value: unknown): boolean;

package/dist/cjs/validators/isMD5.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMD5 = isMD5;
+const string_1 = require("../convert/string");
+const md5 = /^[a-f0-9]{32}$/;
+function isMD5(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return md5.test(str);
+}

package/dist/cjs/validators/isMagnetURI.d.ts

@@ -0,0 +1 @@
+export declare function isMagnetURI(value: unknown): boolean;

package/dist/cjs/validators/isMagnetURI.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMagnetURI = isMagnetURI;
+const string_1 = require("../convert/string");
+const magnetURIComponent = /(?:^magnet:\?|[^?&]&)xt(?:\.1)?=urn:(?:(?:aich|bitprint|btih|ed2k|ed2khash|kzhash|md5|sha1|tree:tiger):[a-z0-9]{32}(?:[a-z0-9]{8})?|btmh:1220[a-z0-9]{64})(?:$|&)/i;
+function isMagnetURI(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const url = s;
+    if (url.indexOf('magnet:?') !== 0) {
+        return false;
+    }
+    return magnetURIComponent.test(url);
+}

package/dist/cjs/validators/isMailtoURI.d.ts

@@ -0,0 +1,4 @@
+import type { IsEmailOptions } from './isEmail';
+export interface IsMailtoURIOptions extends IsEmailOptions {
+}
+export declare function isMailtoURI(value: unknown, options?: IsMailtoURIOptions): boolean;

package/dist/cjs/validators/isMailtoURI.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMailtoURI = isMailtoURI;
+const trim_1 = require("../sanitizer/trim");
+const isEmail_1 = require("./isEmail");
+const string_1 = require("../convert/string");
+function parseMailtoQueryString(queryString) {
+    const unusedAllowedParams = new Set(['subject', 'body', 'cc', 'bcc']), query = { cc: '', bcc: '' };
+    let isParseFailed = false;
+    const queryParams = queryString.split('&');
+    if (queryParams.length > 4) {
+        return false;
+    }
+    for (const q of queryParams) {
+        const [key, value] = q.split('=');
+        if (key && !unusedAllowedParams.has(key)) {
+            isParseFailed = true;
+            break;
+        }
+        if (value && (key === 'cc' || key === 'bcc')) {
+            query[key] = value;
+        }
+        if (key) {
+            unusedAllowedParams.delete(key);
+        }
+    }
+    return isParseFailed ? false : query;
+}
+function isMailtoURI(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const url = s;
+    if (url.indexOf('mailto:') !== 0) {
+        return false;
+    }
+    const [to, queryString = ''] = url.replace('mailto:', '').split('?');
+    if (!to && !queryString) {
+        return true;
+    }
+    const query = parseMailtoQueryString(queryString);
+    if (!query) {
+        return false;
+    }
+    return `${to},${query.cc},${query.bcc}`.split(',').every((email) => {
+        email = (0, trim_1.trim)(email, ' ');
+        if (email) {
+            return (0, isEmail_1.isEmail)(email, options);
+        }
+        return true;
+    });
+}

package/dist/cjs/validators/isMimeType.d.ts

@@ -0,0 +1 @@
+export declare function isMimeType(value: unknown): boolean;

package/dist/cjs/validators/isMimeType.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMimeType = isMimeType;
+const string_1 = require("../convert/string");
+const mimeTypeSimple = /^(application|audio|font|image|message|model|multipart|text|video)\/[a-zA-Z0-9.\-+_]{1,100}$/i;
+const mimeTypeText = /^text\/[a-zA-Z0-9.\-+]{1,100};\s?charset=("[a-zA-Z0-9.\-+\s]{0,70}"|[a-zA-Z0-9.\-+]{0,70})(\s?\([a-zA-Z0-9.\-+\s]{1,20}\))?$/i;
+const mimeTypeMultipart = /^multipart\/[a-zA-Z0-9.\-+]{1,100}(;\s?(boundary|charset)=("[a-zA-Z0-9.\-+\s]{0,70}"|[a-zA-Z0-9.\-+]{0,70})(\s?\([a-zA-Z0-9.\-+\s]{1,20}\))?){0,2}$/i;
+function isMimeType(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return mimeTypeSimple.test(str) || mimeTypeText.test(str) || mimeTypeMultipart.test(str);
+}

package/dist/cjs/validators/isMobilePhone.d.ts

@@ -0,0 +1,171 @@
+export interface IsMobilePhoneOptions {
+    locale?: MobilePhoneLocale | MobilePhoneLocale[];
+    strictMode?: boolean;
+}
+declare const phones: {
+    'am-AM': RegExp;
+    'ar-AE': RegExp;
+    'ar-BH': RegExp;
+    'ar-DZ': RegExp;
+    'ar-LB': RegExp;
+    'ar-EG': RegExp;
+    'ar-IQ': RegExp;
+    'ar-JO': RegExp;
+    'ar-KW': RegExp;
+    'ar-LY': RegExp;
+    'ar-MA': RegExp;
+    'ar-OM': RegExp;
+    'ar-PS': RegExp;
+    'ar-SA': RegExp;
+    'ar-SD': RegExp;
+    'ar-SY': RegExp;
+    'ar-TN': RegExp;
+    'az-AZ': RegExp;
+    'ar-QA': RegExp;
+    'bs-BA': RegExp;
+    'be-BY': RegExp;
+    'bg-BG': RegExp;
+    'bn-BD': RegExp;
+    'ca-AD': RegExp;
+    'cs-CZ': RegExp;
+    'da-DK': RegExp;
+    'de-DE': RegExp;
+    'de-AT': RegExp;
+    'de-CH': RegExp;
+    'de-LU': RegExp;
+    'dv-MV': RegExp;
+    'el-GR': RegExp;
+    'el-CY': RegExp;
+    'en-AI': RegExp;
+    'en-AU': RegExp;
+    'en-AG': RegExp;
+    'en-BM': RegExp;
+    'en-BS': RegExp;
+    'en-GB': RegExp;
+    'en-GG': RegExp;
+    'en-GH': RegExp;
+    'en-GY': RegExp;
+    'en-HK': RegExp;
+    'en-MO': RegExp;
+    'en-IE': RegExp;
+    'en-IN': RegExp;
+    'en-JM': RegExp;
+    'en-KE': RegExp;
+    'fr-CF': RegExp;
+    'en-SS': RegExp;
+    'en-KI': RegExp;
+    'en-KN': RegExp;
+    'en-LS': RegExp;
+    'en-MT': RegExp;
+    'en-MU': RegExp;
+    'en-MW': RegExp;
+    'en-NA': RegExp;
+    'en-NG': RegExp;
+    'en-NZ': RegExp;
+    'en-PG': RegExp;
+    'en-PK': RegExp;
+    'en-PH': RegExp;
+    'en-RW': RegExp;
+    'en-SG': RegExp;
+    'en-SL': RegExp;
+    'en-TZ': RegExp;
+    'en-UG': RegExp;
+    'en-US': RegExp;
+    'en-ZA': RegExp;
+    'en-ZM': RegExp;
+    'en-ZW': RegExp;
+    'en-BW': RegExp;
+    'es-AR': RegExp;
+    'es-BO': RegExp;
+    'es-CO': RegExp;
+    'es-CL': RegExp;
+    'es-CR': RegExp;
+    'es-CU': RegExp;
+    'es-DO': RegExp;
+    'es-HN': RegExp;
+    'es-EC': RegExp;
+    'es-ES': RegExp;
+    'es-GT': RegExp;
+    'es-PE': RegExp;
+    'es-MX': RegExp;
+    'es-NI': RegExp;
+    'es-PA': RegExp;
+    'es-PY': RegExp;
+    'es-SV': RegExp;
+    'es-UY': RegExp;
+    'es-VE': RegExp;
+    'et-EE': RegExp;
+    'fa-IR': RegExp;
+    'fi-FI': RegExp;
+    'fj-FJ': RegExp;
+    'fo-FO': RegExp;
+    'fr-BF': RegExp;
+    'fr-BJ': RegExp;
+    'fr-CD': RegExp;
+    'fr-CM': RegExp;
+    'fr-DJ': RegExp;
+    'fr-FR': RegExp;
+    'fr-GF': RegExp;
+    'fr-GP': RegExp;
+    'fr-MQ': RegExp;
+    'fr-PF': RegExp;
+    'fr-RE': RegExp;
+    'fr-WF': RegExp;
+    'he-IL': RegExp;
+    'hu-HU': RegExp;
+    'id-ID': RegExp;
+    'ir-IR': RegExp;
+    'it-IT': RegExp;
+    'it-SM': RegExp;
+    'ja-JP': RegExp;
+    'ka-GE': RegExp;
+    'kk-KZ': RegExp;
+    'kl-GL': RegExp;
+    'ko-KR': RegExp;
+    'ky-KG': RegExp;
+    'lt-LT': RegExp;
+    'lv-LV': RegExp;
+    'mg-MG': RegExp;
+    'mn-MN': RegExp;
+    'my-MM': RegExp;
+    'ms-MY': RegExp;
+    'mz-MZ': RegExp;
+    'nb-NO': RegExp;
+    'ne-NP': RegExp;
+    'nl-BE': RegExp;
+    'nl-NL': RegExp;
+    'nl-AW': RegExp;
+    'nn-NO': RegExp;
+    'pl-PL': RegExp;
+    'pt-BR': RegExp;
+    'pt-PT': RegExp;
+    'pt-AO': RegExp;
+    'ro-MD': RegExp;
+    'ro-RO': RegExp;
+    'ru-RU': RegExp;
+    'si-LK': RegExp;
+    'sl-SI': RegExp;
+    'sk-SK': RegExp;
+    'so-SO': RegExp;
+    'sq-AL': RegExp;
+    'sr-RS': RegExp;
+    'sv-SE': RegExp;
+    'tg-TJ': RegExp;
+    'th-TH': RegExp;
+    'tr-TR': RegExp;
+    'tk-TM': RegExp;
+    'uk-UA': RegExp;
+    'uz-UZ': RegExp;
+    'vi-VN': RegExp;
+    'zh-CN': RegExp;
+    'zh-TW': RegExp;
+    'dz-BT': RegExp;
+    'ar-YE': RegExp;
+    'ar-EH': RegExp;
+    'fa-AF': RegExp;
+    'mk-MK': RegExp;
+};
+export type MobilePhoneLocale = keyof typeof phones | 'any' | (string & {});
+export declare function isMobilePhone(value: unknown, options?: IsMobilePhoneOptions): boolean;
+export declare const locales: readonly string[];
+export {};