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

package/dist/cjs/validators/isRFC3339.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRFC3339 = isRFC3339;
+const string_1 = require("../convert/string");
+const date_1 = require("../convert/date");
+const dateFullYear = /[0-9]{4}/;
+const dateMonth = /(0[1-9]|1[0-2])/;
+const dateMDay = /([12]\d|0[1-9]|3[01])/;
+const timeHour = /([01][0-9]|2[0-3])/;
+const timeMinute = /[0-5][0-9]/;
+const timeSecond = /([0-5][0-9]|60)/;
+const timeSecFrac = /(\.[0-9]+)?/;
+const timeNumOffset = new RegExp(`[-+]${timeHour.source}:${timeMinute.source}`);
+const timeOffset = new RegExp(`([zZ]|${timeNumOffset.source})`);
+const partialTime = new RegExp(`${timeHour.source}:${timeMinute.source}:${timeSecond.source}${timeSecFrac.source}`);
+const fullDate = new RegExp(`${dateFullYear.source}-${dateMonth.source}-${dateMDay.source}`);
+const fullTime = new RegExp(`${partialTime.source}${timeOffset.source}`);
+const rfc3339 = new RegExp(`^${fullDate.source}[ tT]${fullTime.source}$`);
+function isRealCalendarDate(str) {
+    return (0, date_1.isCalendarDate)(Number(str.slice(0, 4)), Number(str.slice(5, 7)), Number(str.slice(8, 10)));
+}
+function isRFC3339(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return rfc3339.test(s) && isRealCalendarDate(s);
+}

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

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

package/dist/cjs/validators/isRequired.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequired = isRequired;
+function isRequired(value) {
+    return value !== null && value !== undefined;
+}

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

@@ -0,0 +1,5 @@
+export interface IsRgbColorOptions {
+    includePercentValues?: boolean;
+    allowSpaces?: boolean;
+}
+export declare function isRgbColor(value: unknown, options?: IsRgbColorOptions): boolean;

package/dist/cjs/validators/isRgbColor.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRgbColor = isRgbColor;
+const string_1 = require("../convert/string");
+const rgbColor = /^rgb\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){2}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\)$/;
+const rgbaColor = /^rgba\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+const rgbColorPercent = /^rgb\((([0-9]%|[1-9][0-9]%|100%),){2}([0-9]%|[1-9][0-9]%|100%)\)$/;
+const rgbaColorPercent = /^rgba\((([0-9]%|[1-9][0-9]%|100%),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+const startsWithUnspacedRgbPrefix = /^rgba?/;
+function isRgbColor(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    let allowSpaces = false;
+    let includePercentValues = true;
+    if (options !== null && typeof options === 'object') {
+        allowSpaces = options.allowSpaces !== undefined ? options.allowSpaces : allowSpaces;
+        includePercentValues =
+            options.includePercentValues !== undefined
+                ? options.includePercentValues
+                : includePercentValues;
+    }
+    if (allowSpaces) {
+        if (!startsWithUnspacedRgbPrefix.test(str)) {
+            return false;
+        }
+        str = str.replace(/\s/g, '');
+    }
+    if (!includePercentValues) {
+        return rgbColor.test(str) || rgbaColor.test(str);
+    }
+    return (rgbColor.test(str) ||
+        rgbaColor.test(str) ||
+        rgbColorPercent.test(str) ||
+        rgbaColorPercent.test(str));
+}

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

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

package/dist/cjs/validators/isSemVer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSemVer = isSemVer;
+const string_1 = require("../convert/string");
+const semanticVersioningRegex = new RegExp('^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)' +
+    '(?:-((?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*))*))' +
+    '?(?:\\+([0-9a-z-]+(?:\\.[0-9a-z-]+)*))?$', 'i');
+function isSemVer(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return semanticVersioningRegex.test(str);
+}

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

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

package/dist/cjs/validators/isSlug.js

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

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

@@ -0,0 +1,8 @@
+export interface IsStrongPasswordOptions {
+    minLength?: number;
+    minLowercase?: number;
+    minUppercase?: number;
+    minNumbers?: number;
+    minSymbols?: number;
+}
+export declare function isStrongPassword(value: unknown, options?: IsStrongPasswordOptions): boolean;

package/dist/cjs/validators/isStrongPassword.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStrongPassword = isStrongPassword;
+const merge_1 = require("../helpers/merge");
+const analyzePassword_1 = require("../helpers/analyzePassword");
+const string_1 = require("../convert/string");
+const defaultOptions = {
+    minLength: 8,
+    minLowercase: 1,
+    minUppercase: 1,
+    minNumbers: 1,
+    minSymbols: 1,
+};
+function isStrongPassword(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const analysis = (0, analyzePassword_1.analyzePassword)(stringResult.value);
+    const mergedOptions = (0, merge_1.merge)(options || {}, defaultOptions);
+    return (analysis.length >= mergedOptions.minLength &&
+        analysis.lowercaseCount >= mergedOptions.minLowercase &&
+        analysis.uppercaseCount >= mergedOptions.minUppercase &&
+        analysis.numberCount >= mergedOptions.minNumbers &&
+        analysis.symbolCount >= mergedOptions.minSymbols);
+}

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

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

package/dist/cjs/validators/isSurrogatePair.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSurrogatePair = isSurrogatePair;
+const string_1 = require("../convert/string");
+const surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/;
+function isSurrogatePair(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return surrogatePair.test(str);
+}

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

@@ -0,0 +1,5 @@
+export interface IsTimeOptions {
+    hourFormat?: 'hour12' | 'hour24';
+    mode?: 'default' | 'withSeconds' | 'withOptionalSeconds';
+}
+export declare function isTime(value: unknown, options?: IsTimeOptions): boolean;

package/dist/cjs/validators/isTime.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTime = isTime;
+const merge_1 = require("../helpers/merge");
+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 default_time_options = {
+    hourFormat: 'hour24',
+    mode: 'default',
+};
+const formats = {
+    hour24: {
+        default: /^([01]?[0-9]|2[0-3]):([0-5][0-9])$/,
+        withSeconds: /^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/,
+        withOptionalSeconds: /^([01]?[0-9]|2[0-3]):([0-5][0-9])(?::([0-5][0-9]))?$/,
+    },
+    hour12: {
+        default: /^(0?[1-9]|1[0-2]):([0-5][0-9]) (A|P)M$/,
+        withSeconds: /^(0?[1-9]|1[0-2]):([0-5][0-9]):([0-5][0-9]) (A|P)M$/,
+        withOptionalSeconds: /^(0?[1-9]|1[0-2]):([0-5][0-9])(?::([0-5][0-9]))? (A|P)M$/,
+    },
+};
+function isTime(value, options) {
+    const { hourFormat, mode } = (0, merge_1.merge)(options, default_time_options);
+    if (!(0, hasOwn_1.hasOwn)(formats, hourFormat))
+        throw new errors_1.ValidationConfigError(`Invalid hourFormat '${(0, config_1.configText)(hourFormat)}'`);
+    const byMode = formats[hourFormat];
+    if (!(0, hasOwn_1.hasOwn)(byMode, mode))
+        throw new errors_1.ValidationConfigError(`Invalid mode '${(0, config_1.configText)(mode)}'`);
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return byMode[mode].test(s);
+}

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

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

package/dist/cjs/validators/isULID.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isULID = isULID;
+const string_1 = require("../convert/string");
+function isULID(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i.test(str);
+}

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

@@ -0,0 +1,22 @@
+export interface IsURLOptions {
+    protocols?: string[];
+    require_tld?: boolean;
+    require_protocol?: boolean;
+    require_host?: boolean;
+    require_port?: boolean;
+    require_valid_protocol?: boolean;
+    allow_underscores?: boolean;
+    allow_trailing_dot?: boolean;
+    allow_protocol_relative_urls?: boolean;
+    allow_fragments?: boolean;
+    allow_query_components?: boolean;
+    disallow_auth?: boolean;
+    validate_length?: boolean;
+    max_allowed_length?: number;
+    host_whitelist?: (string | RegExp)[];
+    host_blacklist?: (string | RegExp)[];
+    allow_wildcard?: boolean;
+    allow_numeric_tld?: boolean;
+    ignore_max_length?: boolean;
+}
+export declare function isURL(value: unknown, options?: IsURLOptions): boolean;

package/dist/cjs/validators/isURL.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isURL = isURL;
+const string_1 = require("../convert/string");
+const checkHost_1 = require("../helpers/checkHost");
+const config_1 = require("../helpers/config");
+const errors_1 = require("../helpers/errors");
+const isFQDN_1 = require("./isFQDN");
+const isIP_1 = require("./isIP");
+const merge_1 = require("../helpers/merge");
+const default_url_options = {
+    protocols: ['http', 'https', 'ftp'],
+    require_tld: true,
+    require_protocol: false,
+    require_host: true,
+    require_port: false,
+    require_valid_protocol: true,
+    allow_underscores: false,
+    allow_trailing_dot: false,
+    allow_protocol_relative_urls: false,
+    allow_fragments: true,
+    allow_query_components: true,
+    validate_length: true,
+    max_allowed_length: 2084,
+};
+const wrapped_ipv6 = /^\[([^\]]+)\](?::([0-9]+))?$/;
+const forbiddenUrlCharactersRegex = /[\s<>\x00-\x1f\x7f]/;
+const userinfoPartRegex = /^(?:[\p{L}\p{M}\p{N}\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*$/u;
+const codeExecutingSchemes = ['javascript', 'vbscript', 'data'];
+const protocolRegex = /^([a-z][a-z0-9+\-.]*):/i;
+const validAuthRegex = /^[a-zA-Z0-9\-_.%:]*$/;
+const encodedContentRegex = /%[0-9a-fA-F]{2}/;
+const leadingDigitRegex = /^[0-9]/;
+const digitsOnlyRegex = /^[0-9]+$/;
+function isURL(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let url = s;
+    if (!url || forbiddenUrlCharactersRegex.test(url)) {
+        return false;
+    }
+    if (url.indexOf('mailto:') === 0) {
+        return false;
+    }
+    options = (0, merge_1.merge)(options, default_url_options);
+    if (!Array.isArray(options.protocols) || !options.protocols.every((p) => typeof p === 'string')) {
+        throw new errors_1.ValidationConfigError(`protocols must be an array of strings, got ${(0, config_1.configText)(options.protocols)}`);
+    }
+    if (options.validate_length && typeof options.max_allowed_length !== 'number') {
+        throw new errors_1.ValidationConfigError(`max_allowed_length must be a number, got ${(0, config_1.configText)(options.max_allowed_length)}`);
+    }
+    const host_whitelist = options.host_whitelist === undefined
+        ? undefined
+        : (0, checkHost_1.hostList)(options.host_whitelist, 'host_whitelist');
+    const host_blacklist = options.host_blacklist === undefined
+        ? undefined
+        : (0, checkHost_1.hostList)(options.host_blacklist, 'host_blacklist');
+    if (options.validate_length && url.length > options.max_allowed_length) {
+        return false;
+    }
+    if (!options.allow_fragments && url.includes('#')) {
+        return false;
+    }
+    if (!options.allow_query_components && (url.includes('?') || url.includes('&'))) {
+        return false;
+    }
+    let protocol, auth, host, port, port_str, split, ipv6;
+    split = url.split('#');
+    url = split.shift();
+    split = url.split('?');
+    url = split.shift();
+    const protocol_match = url.match(protocolRegex);
+    let had_explicit_protocol = false;
+    const cleanUpProtocol = (potential_protocol) => {
+        had_explicit_protocol = true;
+        protocol = potential_protocol.toLowerCase();
+        if (options.require_valid_protocol &&
+            options.protocols.indexOf(protocol) === -1) {
+            return false;
+        }
+        return url.substring(protocol_match[0].length);
+    };
+    if (protocol_match) {
+        const potential_protocol = protocol_match[1];
+        const after_colon = url.substring(protocol_match[0].length);
+        const starts_with_slashes = after_colon.slice(0, 2) === '//';
+        if (!starts_with_slashes) {
+            const first_slash_position = after_colon.indexOf('/');
+            const before_slash = first_slash_position === -1 ? after_colon : after_colon.substring(0, first_slash_position);
+            const at_position = before_slash.indexOf('@');
+            if (at_position !== -1) {
+                const before_at = before_slash.substring(0, at_position);
+                const is_valid_auth = validAuthRegex.test(before_at);
+                const has_encoded_content = encodedContentRegex.test(before_at);
+                const is_code_executing_scheme = codeExecutingSchemes.includes(potential_protocol.toLowerCase());
+                if (is_valid_auth && !has_encoded_content && !is_code_executing_scheme) {
+                    if (options.require_protocol) {
+                        return false;
+                    }
+                }
+                else {
+                    const cleaned1 = cleanUpProtocol(potential_protocol);
+                    if (cleaned1 === false) {
+                        return false;
+                    }
+                    url = cleaned1;
+                }
+            }
+            else {
+                const looks_like_port = leadingDigitRegex.test(after_colon);
+                if (looks_like_port) {
+                    if (options.require_protocol) {
+                        return false;
+                    }
+                }
+                else {
+                    const cleaned2 = cleanUpProtocol(potential_protocol);
+                    if (cleaned2 === false) {
+                        return false;
+                    }
+                    url = cleaned2;
+                }
+            }
+        }
+        else {
+            const cleaned3 = cleanUpProtocol(potential_protocol);
+            if (cleaned3 === false) {
+                return false;
+            }
+            url = cleaned3;
+        }
+    }
+    else if (options.require_protocol) {
+        return false;
+    }
+    if (url.slice(0, 2) === '//') {
+        if (!had_explicit_protocol && !options.allow_protocol_relative_urls) {
+            return false;
+        }
+        url = url.slice(2);
+    }
+    if (url === '') {
+        return false;
+    }
+    split = url.split('/');
+    url = split.shift();
+    if (url.includes('\\')) {
+        return false;
+    }
+    if (url === '' && !options.require_host) {
+        return true;
+    }
+    split = url.split('@');
+    if (split.length > 1) {
+        if (options.disallow_auth) {
+            return false;
+        }
+        if (split[0] === '') {
+            return false;
+        }
+        auth = split.shift();
+        if (auth.indexOf(':') >= 0 && auth.split(':').length > 2) {
+            return false;
+        }
+        const [user, password] = auth.split(':');
+        if (user === '' && password === '') {
+            return false;
+        }
+        if (!userinfoPartRegex.test(user) ||
+            (password !== undefined && !userinfoPartRegex.test(password))) {
+            return false;
+        }
+    }
+    const hostname = split.join('@');
+    port_str = null;
+    ipv6 = null;
+    const ipv6_match = hostname.match(wrapped_ipv6);
+    if (ipv6_match) {
+        host = '';
+        ipv6 = ipv6_match[1];
+        port_str = ipv6_match[2] || null;
+    }
+    else {
+        split = hostname.split(':');
+        host = split.shift();
+        if (split.length) {
+            port_str = split.join(':');
+        }
+    }
+    if (port_str !== null && port_str.length > 0) {
+        port = parseInt(port_str, 10);
+        if (!digitsOnlyRegex.test(port_str) || port <= 0 || port > 65535) {
+            return false;
+        }
+    }
+    else if (options.require_port) {
+        return false;
+    }
+    if (host_whitelist && !(0, checkHost_1.checkHost)(host || ipv6 || '', host_whitelist)) {
+        return false;
+    }
+    if (host === '' && !options.require_host) {
+        return true;
+    }
+    if (!(0, isIP_1.isIP)(host) && !(0, isFQDN_1.isFQDN)(host, options) && (!ipv6 || !(0, isIP_1.isIP)(ipv6, { version: 6 }))) {
+        return false;
+    }
+    host = host || ipv6;
+    if (host_blacklist && (0, checkHost_1.checkHost)(host, host_blacklist)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+export type IsUUIDVersion = 'all' | 'loose' | 'nil' | 'max' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export interface IsUUIDOptions {
+    version?: IsUUIDVersion;
+}
+export declare function isUUID(value: unknown, options?: IsUUIDOptions): boolean;

package/dist/cjs/validators/isUUID.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUUID = isUUID;
+const string_1 = require("../convert/string");
+const hasOwn_1 = require("../helpers/hasOwn");
+const config_1 = require("../helpers/config");
+const uuid = {
+    1: /^[0-9A-F]{8}-[0-9A-F]{4}-1[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    2: /^[0-9A-F]{8}-[0-9A-F]{4}-2[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    6: /^[0-9A-F]{8}-[0-9A-F]{4}-6[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    8: /^[0-9A-F]{8}-[0-9A-F]{4}-8[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    nil: /^00000000-0000-0000-0000-000000000000$/i,
+    max: /^ffffffff-ffff-ffff-ffff-ffffffffffff$/i,
+    loose: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+    all: /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i,
+};
+function isUUID(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const version = (0, config_1.optionsOf)(options).version ?? 'all';
+    return (0, hasOwn_1.hasOwn)(uuid, String(version))
+        ? uuid[String(version)].test(str)
+        : false;
+}

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

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

package/dist/cjs/validators/isUppercase.js

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

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

@@ -0,0 +1,75 @@
+export declare const vatMatchers: {
+    AT: (str: string) => boolean;
+    BE: (str: string) => boolean;
+    BG: (str: string) => boolean;
+    HR: (str: string) => boolean;
+    CY: (str: string) => boolean;
+    CZ: (str: string) => boolean;
+    DK: (str: string) => boolean;
+    EE: (str: string) => boolean;
+    FI: (str: string) => boolean;
+    FR: (str: string) => boolean;
+    DE: (str: string) => boolean;
+    EL: (str: string) => boolean;
+    HU: (str: string) => boolean;
+    IE: (str: string) => boolean;
+    IT: (str: string) => boolean;
+    LV: (str: string) => boolean;
+    LT: (str: string) => boolean;
+    LU: (str: string) => boolean;
+    MT: (str: string) => boolean;
+    NL: (str: string) => boolean;
+    PL: (str: string) => boolean;
+    PT: (str: string) => boolean;
+    RO: (str: string) => boolean;
+    SK: (str: string) => boolean;
+    SI: (str: string) => boolean;
+    ES: (str: string) => boolean;
+    SE: (str: string) => boolean;
+    AL: (str: string) => boolean;
+    MK: (str: string) => boolean;
+    AU: (str: string) => boolean;
+    BY: (str: string) => boolean;
+    CA: (str: string) => boolean;
+    IS: (str: string) => boolean;
+    IN: (str: string) => boolean;
+    ID: (str: string) => boolean;
+    IL: (str: string) => boolean;
+    KZ: (str: string) => boolean;
+    NZ: (str: string) => boolean;
+    NG: (str: string) => boolean;
+    NO: (str: string) => boolean;
+    PH: (str: string) => boolean;
+    RU: (str: string) => boolean;
+    SM: (str: string) => boolean;
+    SA: (str: string) => boolean;
+    RS: (str: string) => boolean;
+    CH: (str: string) => boolean;
+    TR: (str: string) => boolean;
+    UA: (str: string) => boolean;
+    GB: (str: string) => boolean;
+    UZ: (str: string) => boolean;
+    AR: (str: string) => boolean;
+    BO: (str: string) => boolean;
+    BR: (str: string) => boolean;
+    CL: (str: string) => boolean;
+    CO: (str: string) => boolean;
+    CR: (str: string) => boolean;
+    EC: (str: string) => boolean;
+    SV: (str: string) => boolean;
+    GT: (str: string) => boolean;
+    HN: (str: string) => boolean;
+    MX: (str: string) => boolean;
+    NI: (str: string) => boolean;
+    PA: (str: string) => boolean;
+    PY: (str: string) => boolean;
+    PE: (str: string) => boolean;
+    DO: (str: string) => boolean;
+    UY: (str: string) => boolean;
+    VE: (str: string) => boolean;
+};
+export type VATCountryCode = keyof typeof vatMatchers | (string & {});
+export interface IsVATOptions {
+    countryCode: VATCountryCode;
+}
+export declare function isVAT(value: unknown, options: IsVATOptions): boolean;