import { GeoShapePoint, MACDelimiter } from '@terascope/types';
import { FQDNOptions, HashConfig, LengthConfig, PostalCodeLocale, ArgsISSNOptions } from './interfaces.js';
import * as i from '../interfaces.js';
export declare const repository: i.Repository;
/**
 * Checks to see if input is a boolean.
 * If given an array, will check if all values are booleans
 *
 * @example
 * FieldValidator.isBoolean(false); // true
 * FieldValidator.isBoolean('astring'); // false
 * FieldValidator.isBoolean(0); // false
 * FieldValidator.isBoolean([true, undefined]); // true
 * FieldValidator.isBoolean(['true', undefined]; // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isBoolean(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a boolean-like value. If an given an array, it will check
 * to see if all values in the array are boolean-like, does NOT ignore null/undefined values
 *
 * @example
 * FieldValidator.isBooleanLike(); // true
 * FieldValidator.isBooleanLike(null); // true
 * FieldValidator.isBooleanLike(0); // true
 * FieldValidator.isBooleanLike('0'); // true
 * FieldValidator.isBooleanLike('false'); // true
 * FieldValidator.isBooleanLike('no'); // true
 * FieldValidator.isBooleanLike(['no', '0', null]); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isBooleanLike(input: unknown, _parentContext?: unknown): boolean;
/**
 * Return true if value is a valid email, or a list of valid emails
 *
 * @example
 * FieldValidator.isEmail('ha3ke5@pawnage.com') // true
 * FieldValidator.isEmail('user@blah.com/junk.junk?a=<tag value="junk"') // true
 * FieldValidator.isEmail('email@example.com'); // true
 * FieldValidator.isEmail(12345); // false
 * FieldValidator.isEmail(['email@example.com', 'ha3ke5@pawnage.com']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isEmail(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a valid geo-point, or a list of valid geo-points
 * excluding null/undefined values
 *
 * @example
 * FieldValidator.isGeoPoint('60,80'); // true
 * FieldValidator.isGeoPoint([80, 60]); // true
 * FieldValidator.isGeoPoint({ lat: 60, lon: 80 }); // true
 * FieldValidator.isGeoPoint({ latitude: 60, longitude: 80 }); // true
 * FieldValidator.isGeoPoint(['60,80', { lat: 60, lon: 80 }]); // true
 * FieldValidator.isGeoPoint(['60,80', 'hello']); // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isGeoPoint(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a valid geo-json geometry, or a list of geo-json geometries
 *
 * @example
 * FieldValidator.isGeoJSON('hello'); // false
 *
 * const polygon = {
 *   type: "Polygon",
 *   coordinates: [
 *       [[10, 10], [10, 50], [50, 50], [50, 10], [10, 10]],
 *   ]
 * };
 * FieldValidator.isGeoJSON(polygon); // true
 * FieldValidator.isGeoJSON([polygon, { other: 'obj'}]); // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isGeoJSON(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a valid geo-json point, or a list of geo-json points
 * @example
 * const polygon = {
 *   type: "Polygon",
 *   coordinates: [
 *      [[10, 10], [10, 50], [50, 50], [50, 10], [10, 10]],
 *    ]
 * };
 *
 * const point = {
 *   type: 'Point',
 *   coordinates: [12, 12]
 * };
 *
 * FieldValidator.isGeoShapePoint(polygon); // false
 * FieldValidator.isGeoShapePoint(point); // true
 * FieldValidator.isGeoShapePoint([polygon, point]); // false
 * FieldValidator.isGeoShapePoint([point, point]); // true
 *
 * @param {JoinGeoShape} input
 * @returns {boolean} boolean
 */
export declare function isGeoShapePoint(input: unknown, _parentContext?: unknown): input is GeoShapePoint;
export declare function isGeoShapePoint(input: unknown[], _parentContext?: unknown): input is GeoShapePoint[];
/**
 * Checks to see if input is a valid geo-json polygon or a list of geo-json polygons
 * @example
 * FieldValidator.isGeoShapePolygon(3); // false
 *
 * const polygon = {
 *   type: 'Polygon',
 *   coordinates: [
 *       [[10, 10], [10, 50], [50, 50], [50, 10], [10, 10]],
 *   ]
 * };
 *
 * const point = {
 *  type: 'Point',
 *   coordinates: [12, 12]
 * };
 *
 * FieldValidator.isGeoShapePolygon(polygon); // true
 * FieldValidator.isGeoShapePolygon(point); // false
 * FieldValidator.isGeoShapePolygon([polygon, point]); // false
 * FieldValidator.isGeoShapePolygon([polygon, polygon]); // true
 *
 * @param {JoinGeoShape} input
 * @returns {boolean} boolean
 */
export declare function isGeoShapePolygon(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a valid geo-json multi-polygon or a list of geo-json multi-polygons
 * @example
 *
 * const polygon = {
 *   type: "Polygon",
 *   coordinates: [
 *       [[10, 10], [10, 50], [50, 50], [50, 10], [10, 10]],
 *   ]
 * };
 *
 * const point = {
 *   type: 'Point',
 *   coordinates: [12, 12]
 * };
 *
 * const multiPolygon = {
 *   type: 'MultiPolygon',
 *   coordinates: [
 *       [
 *           [[10, 10], [10, 50], [50, 50], [50, 10], [10, 10]],
 *      ],
 *       [
 *           [[-10, -10], [-10, -50], [-50, -50], [-50, -10], [-10, -10]],
 *       ]
 *   ]
 * };
 *
 * FieldValidator.isGeoShapeMultiPolygon(polygon); // false
 * FieldValidator.isGeoShapeMultiPolygon(point); // false
 * FieldValidator.isGeoShapeMultiPolygon(multiPolygon); // true
 * FieldValidator.isGeoShapeMultiPolygon([multiPolygon, multiPolygon]); // true
 * FieldValidator.isGeoShapeMultiPolygon([multiPolygon, point]); // false
 *
 * @param {JoinGeoShape} input
 * @returns {boolean} boolean
 */
export declare function isGeoShapeMultiPolygon(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that the input is an IP address, or a list of IP addresses
 *
 * @example
 *
 * FieldValidator.isIP('8.8.8.8'); // true
 * FieldValidator.isIP('192.172.1.18'); // true
 * FieldValidator.isIP('11.0.1.18'); // true
 * FieldValidator.isIP('2001:db8:85a3:8d3:1319:8a2e:370:7348'); // true
 * FieldValidator.isIP('fe80::1ff:fe23:4567:890a%eth2'); // true
 * FieldValidator.isIP('2001:DB8::1'); // true
 * FieldValidator.isIP('172.16.0.1'); // true
 * FieldValidator.isIP(['172.16.0.1', '11.0.1.18']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isIP(input: unknown, _parentContext?: unknown): input is string;
/**
 * Validate is input is a routable IP, or a list of routable IP's
 *
 * @example
 *
 * FieldValidator.isRoutableIP('8.8.8.8'); // true
 * FieldValidator.isRoutableIP('2001:db8::1'); // true
 * FieldValidator.isRoutableIP('172.194.0.1'); // true
 * FieldValidator.isRoutableIP('100.127.255.250'); // false
 * FieldValidator.isRoutableIP('192.168.0.1'); // false
 * FieldValidator.isRoutableIP(['172.194.0.1', '8.8.8.8']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 *
 * see:
 *  https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
 *  https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml
 *  for ip range details
 */
export declare function isRoutableIP(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validate is input is a non-routable IP, or a list of non-routable IP's
 *
 * @example
 *
 * FieldValidator.isNonRoutableIP('192.168.0.1'); // true
 * FieldValidator.isNonRoutableIP('10.16.32.210'); // true
 * FieldValidator.isNonRoutableIP('fc00:db8::1'); // true
 * FieldValidator.isNonRoutableIP('8.8.8.8'); // false
 * FieldValidator.isNonRoutableIP('2001:db8::1'); // false
 * FieldValidator.isNonRoutableIP(['10.16.32.210', '192.168.0.1']); // true
 *
 * @param {*} input
 * @returns { boolean } boolean
 *
 * see:
 *  https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
 *  https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml
 *  for ip range details
 */
export declare function isNonRoutableIP(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a cidr or a list of cidr values
 *
 * @example
 *
 * FieldValidator.isCIDR('8.8.0.0/12'); // true
 * FieldValidator.isCIDR('2001::1234:5678/128'); // true
 * FieldValidator.isCIDR('8.8.8.10'); // false
 * FieldValidator.isCIDR(['8.8.0.0/12', '2001::1234:5678/128']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isCIDR(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates if the input is within a given range of IP's
 * @example
 * FieldValidator.inIPRange('8.8.8.8', {}, { cidr: '8.8.8.0/24' }); // true
 * FieldValidator.inIPRange('fd00::b000', {}, { min: 'fd00::123', max: 'fd00::ea00' }); // true;
 * FieldValidator.inIPRange('8.8.8.8', {}, { cidr: '8.8.8.10/32' }); // false
 *
 * const config = { min: '8.8.8.0', max: '8.8.8.64' };
 * FieldValidator.inIPRange(['8.8.8.64', '8.8.8.8'], {}, config); // true
 *
 * @param {*} input
 * @param {{ min?: string; max?: string; cidr?: string }} args
 * @returns {boolean} boolean
 */
export declare function inIPRange(input: unknown, _parentContext: unknown, args: {
    min?: string;
    max?: string;
    cidr?: string;
}): boolean;
/**
 * Validates that the input is a valid phone number, or a list of phone numbers
 *
 * @example
 * FieldValidator.isISDN('46707123456'); // true
 * FieldValidator.isISDN('1-808-915-6800'); // true
 * FieldValidator.isISDN('NOT A PHONE Number'); // false
 * FieldValidator.isISDN(79525554602); // true
 * FieldValidator.isISDN(['46707123456', '1-808-915-6800']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isISDN(input: unknown, _parentContext?: unknown): boolean;
interface MACAddressArgs {
    delimiter?: MACDelimiter;
}
/**
 * Validates that the input is a MacAddress, or a list of MacAddresses
 *
 * @example
 * FieldValidator.isMACAddress('00:1f:f3:5b:2b:1f'); // true
 * FieldValidator.isMACAddress('001ff35b2b1f'); // true
 * FieldValidator.isMACAddress('001f.f35b.2b1f',{}, { delimiter: 'dot' }); // true
 *
 * const manyDelimiters = { delimiter: 'any' }
 * FieldValidator.isMACAddress('00-1f-f3-5b-2b-1f', {}, manyDelimiters); // true
 * FieldValidator.isMACAddress(12345); // false
 *
 * // specified colon and space delimiter only
 * const twoDelimiters = { delimiter: 'any };
 * FieldValidator.isMACAddress('00-1f-f3-5b-2b-1f', {}, twoDelimiters ); // false,
 * FieldValidator.isMACAddress(['001ff35b2b1f', '00:1f:f3:5b:2b:1f']); // true
 *
 * @param {*} input
 * @param {{delimiter}} [{ delimiter?: string}] may be set to 'colon'|'space'|'dash'|'dot'|'none'
 * @returns {boolean} boolean
 */
export declare function isMACAddress(input: unknown, _parentContext?: unknown, args?: MACAddressArgs): boolean;
/**
 * Will return true if number is between args provided, or that the list
 * of numbers are between the values
 *
 * @example
 * FieldValidator.inNumberRange(42, {}, { min: 0, max: 100}); // true
 * FieldValidator.inNumberRange([42, 11, 94], {}, { min: 0, max: 100}); // true
 * FieldValidator.inNumberRange([42, 11367, 94], {}, { min: 0, max: 100}); // false
 * FieldValidator.inNumberRange(-42, {}, { min:0 , max: 100 }); // false
 * FieldValidator.inNumberRange(42, {}, { min: 0, max: 42 }); // false without the inclusive option
 * FieldValidator.inNumberRange(42, {}, { min: 0, max: 42, inclusive: true }) // true with inclusive
 *
 * @param {number} input
 * @param {{ min?: number; max?: number; inclusive?: boolean }} args
 * @returns {boolean} boolean
 */
export declare function inNumberRange(input: unknown, _parentContext: unknown, args: {
    min?: number;
    max?: number;
    inclusive?: boolean;
}): boolean;
/**
 * Validates that input is a number or a list of numbers
 *
 * @example
 * FieldValidator.isNumber(42.32); // true
 * FieldValidator.isNumber('NOT A Number'); // false
 * FieldValidator.isNumber([42.32, 245]); // true
 * FieldValidator.isNumber([42.32, { some: 'obj' }]); // false
 * FieldValidator.isNumber('1'); // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isNumber(input: unknown, _parentContext?: unknown): input is number;
/**
 * Validates that input is a integer or a list of integers
 *
 * @example
 * FieldValidator.isInteger(42); // true
 * FieldValidator.isInteger(3.14); // false
 * FieldValidator.isInteger(Infinity); // false
 * FieldValidator.isInteger('1'); // false
 * FieldValidator.isInteger(true); //false
 * FieldValidator.isInteger([42, 1]); // true
 * FieldValidator.isInteger([42, 3.14]); // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isInteger(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a string or a list of strings
 *
 * @example
 * FieldValidator.isString('this is a string'); // true
 * FieldValidator.isString(true); // false
 * FieldValidator.isString(['hello', 'world']); // true
 * FieldValidator.isString(['hello', 3]); // false
 * FieldValidator.isString(17.343); // false
 *
 * @param {*} input
 */
export declare function isString(input: unknown, _parentContext?: unknown): input is string;
/**
 * Validates that the input is a url or a list of urls
 *
 * @example
 * FieldValidator.isURL('https://someurl.cc.ru.ch'); // true
 * FieldValidator.isURL('ftp://someurl.bom:8080?some=bar&hi=bob'); // true
 * FieldValidator.isURL('http://xn--fsqu00a.xn--3lr804guic'); // true
 * FieldValidator.isURL('http://example.com'); // true
 * FieldValidator.isURL('BAD-URL'); // false
 * FieldValidator.isURL(['http://example.com', 'http://example.com']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isURL(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a UUID or a list of UUID's
 *
 * @example
 * FieldValidator.isUUID('0668CF8B-27F8-2F4D-AF2D-763AC7C8F68B'); // true
 * FieldValidator.isUUID('BAD-UUID'); // false
 * FieldValidator.isUUID([
 *   '0668CF8B-27F8-2F4D-AF2D-763AC7C8F68B',
 *   '123e4567-e89b-82d3-A456-426655440000'
 * ]); // true
 *
 * @param {*} input
 * @param {{ version: validator.UUIDVersion }} [args]
 * @returns {boolean} boolean
 */
export declare function isUUID(input: unknown, _parentContext?: unknown, args?: {
    version: validator.UUIDVersion;
}): boolean;
/**
 * Validates the input contains the values specified in args,
 * or that the array of inputs contains the value in args
 *
 * @example
 * FieldValidator.contains('hello', {}, { value: 'hello' }); // true
 * FieldValidator.contains('hello', {}, { value: 'll' }); // true
 * FieldValidator.contains(['hello', 'cello'], {}, { value: 'll' }); // true
 * FieldValidator.contains(['hello', 'stuff'], {}, { value: 'll' }); // false
 * FieldValidator.contains('12345', {}, { value: '45' }); // true
 *
 * @param {*} input
 * @param {{ value: string }} { value }
 * @returns {boolean} boolean
 */
export declare function contains(input: unknown, _parentContext: unknown, args: {
    value: string;
}): boolean;
/**
 * Validates that the input matches the value, of that the input array matches the value provided
 *
 * @example
 * FieldValidator.equals('12345', {}, { value: '12345' }); // true
 * FieldValidator.equals('hello', {}, { value: 'llo' }); // false
 * FieldValidator.equals([3, 3], { value: 3 }); // true
 *
 * @param {*} input
 * @param {{ value: string }} { value }
 * @returns {boolean} boolean
 */
export declare function equals(input: unknown, _parentContext: unknown, args: {
    value: string;
}): boolean;
/**
 * Validates that the input is alpha or a list of alpha values
 *
 * @example
 * FieldValidator.isAlpha('ThiSisAsTRing'); // true
 * FieldValidator.isAlpha('ThisiZĄĆĘŚŁ', {}, { locale: 'pl-Pl' }); // true
 * FieldValidator.isAlpha('1123_not-valid'); // false
 * FieldValidator.isAlpha(['validString', 'more']); // true
 *
 * @param {*} input
 * @param {{ locale: validator.AlphaLocale }} [args]
 * @returns {boolean} boolean
 */
export declare function isAlpha(input: unknown, _parentContext?: unknown, args?: {
    locale: validator.AlphaLocale;
}): boolean;
/**
 * Validates that the input is alphanumeric or a list of alphanumeric values
 *
 * @example
 *
 * FieldValidator.isAlphanumeric('123validString'); // true
 * FieldValidator.isAlphanumeric('فڤقکگ1234', { locale: 'ku-IQ' }); // true
 * FieldValidator.isAlphanumeric('-- not valid'); // false
 * FieldValidator.isAlphanumeric(['134', 'hello']); // true
 *
 * @param {*} input
 * @param {{ locale: validator.AlphanumericLocale }} [args]
 * @returns {boolean} boolean
 */
export declare function isAlphanumeric(input: unknown, _parentContext?: unknown, args?: {
    locale: validator.AlphanumericLocale;
}): boolean;
/**
 * Validates that the input is ascii chars or a list of ascii chars
 *
 * @example
 *
 * FieldValidator.isASCII('ascii\s__'); // true;
 * FieldValidator.isASCII('˜∆˙©∂ß'); // false
 * FieldValidator.isASCII(['some', 'words']); // true;
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isASCII(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that the input is a base64 encoded string or a list of base64
 * encoded strings of string or binary data
 *
 * @example
 * FieldValidator.isBase64('H4sIADYPj2YAAytJLS4x4gIA2GR0VwYAAAA='); // true
 * FieldValidator.isBase64('not base 64'); // false\
 * FieldValidator.isBase64(['H4sIADYPj2YAAytJLS4x4gIA2GR0VwYAAAA=',
 *                                'H4sIAFIPj2YAAytJLS4x5AIAGzdZfAYAAAA=']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isBase64(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that the input is empty
 * @example
 * FieldValidator.isEmpty(''); // true
 * FieldValidator.isEmpty(undefined); // true
 * FieldValidator.isEmpty(null); // true
 * FieldValidator.isEmpty({ foo: 'bar' }); // false
 * FieldValidator.isEmpty({}); // true
 * FieldValidator.isEmpty([]); // true
 * FieldValidator.isEmpty('     ', {}, { ignoreWhitespace: true }); // true
 *
 * @param {*} input
 * @param {{ ignoreWhitespace: boolean }} [args] set to true if you want the value to be trimmed
 * @returns {boolean} boolean
 */
export declare function isEmpty(input: unknown, _parentContext?: unknown, args?: {
    ignoreWhitespace: boolean;
}): boolean;
/**
 * Validate that the input is a valid domain name, or a list of domain names
 *
 * @example
 *
 * FieldValidator.isFQDN('example.com.uk'); // true
 * FieldValidator.isFQDN('notadomain'); // false
 * FieldValidator.isFQDN(['example.com.uk', 'google.com']); // true
 *
 * @param {*} input
 * @param {args} [{ require_tld = true, allow_underscores = false, allow_trailing_dot = false}]
 * @returns {boolean} boolean
 */
export declare function isFQDN(input: unknown, _parentContext?: unknown, args?: FQDNOptions): boolean;
/**
 * Validates that the input is a hash, or a list of hashes
 *
 * @example
 * const md5Config = { algo: 'md5'};
 * const sha256Config = { algo: 'sha256' }
 * const sha1Config = { algo: 'sha1' }
 *
 * FieldValidator.isHash('6201b3d1815444c87e00963fcf008c1e', {}, { algo: 'md5' }); // true
 * FieldValidator.isHash(
 * '85031b6f407e7f25cf826193338f7a4c2dc8c8b5130f5ca2c69a66d9f5107e33',
 * {},
 * { algo: 'sha256' }
 * ); // true
 *
 * FieldValidator.isHash('98fc121ea4c749f2b06e4a768b92ef1c740625a0', {}, { algo: 'sha1' }); // true
 * FieldValidator.isHash(['6201b3d1815444c87e00963fcf008c1e', undefined],
 *  {},
 *   { algo: 'md5' }
 * ); // true
 *
 * @param {*} input
 * @param {HashConfig} { algo }
 * @returns {boolean} boolean
 */
export declare function isHash(input: unknown, _parentContext: unknown, args: HashConfig): boolean;
/**
 * Validates that input is a valid country code or a list of country codes
 *
 * @example
 *
 * FieldValidator.isCountryCode('IS'); // true
 * FieldValidator.isCountryCode('ru'); // true
 * FieldValidator.isCountryCode('USA'); // false
 * FieldValidator.isCountryCode(['IS', 'ru']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isCountryCode(input: unknown, _parentContext?: unknown): boolean;
/**
 * Checks to see if input is a valid ISO8601 string dates or a list of valid dates
 * @example
 * FieldValidator.isISO8601('2020-01-01T12:03:03.494Z'); // true
 * FieldValidator.isISO8601('2020-01-01'); // true
 * FieldValidator.isISO8601('2020-01-01T12:03:03'); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isISO8601(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a valid ISSN or a list of valid ISSN
 *
 * @example
 *
 * FieldValidator.isISSN('0378-5955'); // true
 * FieldValidator.isISSN('03785955'); // true
 * FieldValidator.isISSN('0378-5955', {}, { requireHyphen: true }); // true
 * FieldValidator.isISSN(['0378-5955', '0000-006x']); // true
 *
 * @param {*} input
 * @param {ArgsISSNOptions} [{ requireHyphen?: boolean; caseSensitive?: boolean;}]
 * @returns {boolean} boolean
 */
export declare function isISSN(input: unknown, _parentContext?: unknown, args?: ArgsISSNOptions): boolean;
/**
 * Validates that input is a valid RFC3339 dates or a list of valid RFC3339 dates
 *
 * @example
 * FieldValidator.isRFC3339('2020-01-01T12:05:05.001Z'); // true
 * FieldValidator.isRFC3339('2020-01-01 12:05:05.001Z'); // true
 * FieldValidator.isRFC3339('2020-01-01T12:05:05Z'); // true
 * FieldValidator.isRFC3339(['2020-01-01T12:05:05Z', '2020-01-01T12:05:05.001Z']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isRFC3339(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a valid JSON string or a list of valid JSON
 *
 * @example
 * FieldValidator.isJSON('{ "bob": "gibson" }'); // true
 * FieldValidator.isJSON({ bob: 'gibson' }); // false
 * FieldValidator.isJSON('[]'); // true
 * FieldValidator.isJSON('{}'); // true
 * FieldValidator.isJSON(['{ "bob": "gibson" }', '[]']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isJSON(input: unknown, _parentContext?: unknown): boolean;
/**
 * Check to see if input is a string with given length ranges, or a list of valid string lengths
 * @example
 * FieldValidator.isLength('astring', { size: 7 }); // true
 * FieldValidator.isLength('astring', { min: 3, max: 10 }); // true
 * FieldValidator.isLength('astring', { size: 10 }); // false
 * FieldValidator.isLength('astring', {}, { min: 8 }); // false
 * FieldValidator.isLength(['astring', 'stuff', 'other'], { min: 3, max: 10 }); // true
 *
 * @param {*} input
 * @param {LengthConfig} { size, min, max }
 * @returns {boolean} boolean
 */
export declare function isLength(input: unknown, _parentContext: unknown, { size, min, max }: LengthConfig): boolean;
/**
 * Validates that input is a valid mimeType or a list of mimeTypes
 *
 * @example
 *
 * FieldValidator.isMIMEType('application/javascript'); // true
 * FieldValidator.isMIMEType('application/graphql'); // true
 * FieldValidator.isMIMEType(12345); // false
 * FieldValidator.isMIMEType(['application/graphql', 'application/javascript']); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isMIMEType(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that input is a valid postal code or a list of postal codes
 *
 * @example
 *
 * FieldValidator.isPostalCode('85249'); // true
 * FieldValidator.isPostalCode('85249', {}, { locale: 'any' }); // true
 * FieldValidator.isPostalCode('85249', {}, { locale: 'ES' }); // false
 * FieldValidator.isPostalCode('852', {}, { locale: 'IS' }); // true
 * FieldValidator.isPostalCode('885 49', {}, { locale: 'SE' }); // true
 * FieldValidator.isPostalCode(1234567890); // false
 * FieldValidator.isPostalCode(['85249']); // true
 *
 * @param {*} input
 * @param {({ locale: 'any' | PostalCodeLocale })} { locale }
 * @returns {boolean} boolean
 */
export declare function isPostalCode(input: unknown, _parentContext: unknown, args: {
    locale: 'any' | PostalCodeLocale;
}): boolean;
/**
 * Validates that the input is a valid date or a list of valid dates
 *
 * @example
 * FieldValidator.isValidDate('2019-03-17T23:08:59.673Z'); // true
 * FieldValidator.isValidDate('2019-03-17'); // true
 * FieldValidator.isValidDate('2019-03-17T23:08:59'); // true
 * FieldValidator.isValidDate('03/17/2019'); // true
 * FieldValidator.isValidDate('03-17-2019'); // true
 * FieldValidator.isValidDate('Jan 22, 2012'); // true
 * FieldValidator.isValidDate('23 Jan 2012'); // true
 * FieldValidator.isValidDate(1552000139); // true
 * FieldValidator.isValidDate('1552000139'); // false
 * FieldValidator.isValidDate(['2019-03-17', 1552000139]); // true;
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isValidDate(input: unknown, _parentContext?: unknown): boolean;
/**
 * Will throw if input is null or undefined
 *
 * @example
 *
 * FieldValidator.guard({ hello: 'world' }); // true
 * FieldValidator.guard(); // WILL THROW
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function guard(input: unknown, _parentContext?: unknown): boolean;
/**
 * Will return false if input is null or undefined
 *
 * @example
 *
 * FieldValidator.exists({ hello: 'world' }); // true
 * FieldValidator.exists(null); // false
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function exists(input: unknown, _parentContext?: unknown): boolean;
/**
 * Validates that the input is an array
 * @example
 * FieldValidator.isArray(undefined); // false
 * FieldValidator.isArray([1, 2, 3]); // true
 * FieldValidator.isArray([]); // true
 *
 * @param {*} input
 * @returns {boolean} boolean
 */
export declare function isArray(input: unknown, _parentContext?: unknown): input is any[];
/**
 * Validates that the function specified returns true at least once on the list of values
 *
 * @example
 *
 * const mixedArray = ['hello', 3, { some: 'obj' }];
 * FieldValidator.some(mixedArray, mixedArray, fn: 'isString' }); // true
 * FieldValidator.some(mixedArray, mixedArray, { fn: 'isBoolean' }); // false
 *
 * @param {*} input
 * @param {{ fn: string; options?: any }} { fn, options } fn is the name of method on FieldValidator
 * options is any other arguments necessary for that function call
 * @returns {boolean} boolean
 */
export declare function some(input: unknown, _parentContext: unknown, { fn, options }: {
    fn: string;
    options?: any;
}): boolean;
/**
 * Validates that the function specified returns true for every single value in the list
 *
 * @example
 * const mixedArray = ['hello', 3, { some: 'obj' }];
 * const strArray = ['hello', 'world'];
 *
 * FieldValidator.every([mixedArray, mixedArray { fn: 'isString' }); // false
 * FieldValidator.every(strArray, strArray, { fn: 'isString' }); // true
 *
 * @param {*} input
 * @param {{ fn: string; options?: any }} { fn, options } fn is the name of method on FieldValidator
 * options is any other arguments necessary for that function call
 * @returns {boolean} boolean
 */
export declare function every(input: unknown, _parentContext: unknown, { fn, options }: {
    fn: string;
    options?: any;
}): boolean;
export declare function isNumberTuple(input: unknown, _parentContext?: unknown): boolean;
export {};
//# sourceMappingURL=field-validator.d.ts.map