validators

var (
	// ErrBadNumType is an error for unsupported type provided to number validators
	ErrBadNumType = errors.New("unsupported type provided to number validator")

	// ErrBadSliceType is an error for unsupported type provided to slice validators
	ErrBadSliceType = errors.New("unsupported type provided to slice validator")

	// ErrNilValue is an error for encountering nil in validator
	ErrNilValue = errors.New("nil value must not be provided to validator")
)

var (
	// DefaultMinUserGID is a default value for MinUserGID, used then parsing of 'login.defs' fails.
	DefaultMinUserGID uint64 = 1000

	// DefaultMaxUserGID is a default value for MaxUserGID, used then parsing of 'login.defs' fails.
	DefaultMaxUserGID uint64 = 60000
)

var (
	// DefaultMinUserUID is a default value for MinUserUID, used then parsing of 'login.defs' fails.
	DefaultMinUserUID uint64 = 1000

	// DefaultMaxUserUID is a default value for MaxUserUID, used then parsing of 'login.defs' fails.
	DefaultMaxUserUID uint64 = 60000
)

var ExecExitCodeHasAnyError = func(v *ExecExitCodeHasAny) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' after execution command must exit with any of defined status codes", strings.Join(v.Command, " "))
}

var ExecExitCodeHasNoneOfError = func(v *ExecExitCodeHasNoneOf) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' after execution command must exit with none of defined status codes", strings.Join(v.Command, " "))
}

var ExecExitCodeIsNotZeroError = func(v *ExecExitCodeIsNotZero) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' after execution command must exit with none-zero status code", strings.Join(v.Command, " "))
}

var ExecExitCodeIsZeroError = func(v *ExecExitCodeIsZero) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' after execution command must exit with zero status code", strings.Join(v.Command, " "))
}

var FuncValidatorError = func(v *FuncValidator) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' failed custom func validation", v.Field)
}

var (
	// LoginDefsPath is a default path to 'login.defs' file.
	LoginDefsPath = "/etc/login.defs"
)

var NumberInRangeError = func(v *NumberInRange) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	e := fmt.Sprintf("'%s' not in range(%s, %s)", NumFieldToString(v.Field), NumFieldToString(v.Min), NumFieldToString(v.Max))

	if v.CheckEqual {
		return fmt.Sprintf("%s (inclusive)", e)
	}

	return e
}

var NumberIsGreaterError = func(v *NumberIsGreater) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	errt := "is not greater than"

	if v.CheckEqual {
		errt += " or equal to"
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' %s '%s'", NumFieldToString(v.Field), errt, NumFieldToString(v.ComparedField))
	}

	return fmt.Sprintf("'%s' %s '%s'", v.Name, errt, v.ComparedName)
}

var NumberIsLessError = func(v *NumberIsLess) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	errt := "is not less than"

	if v.CheckEqual {
		errt += " or equal to"
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' %s '%s'", NumFieldToString(v.Field), errt, NumFieldToString(v.ComparedField))
	}

	return fmt.Sprintf("'%s' %s '%s'", v.Name, errt, v.ComparedName)
}

var NumberIsNotZeroError = func(v *NumberIsNotZero) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must not be equal to 0", v.Name)
}

var NumberIsValidUserGIDError = func(v *NumberIsValidUserGID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid user GID", NumFieldToString(v.Field))
}

var NumberIsValidUserUIDError = func(v *NumberIsValidUserUID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid user UID", NumFieldToString(v.Field))
}

var NumbersAreEqualError = func(v *NumbersAreEqual) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' is not equal to '%s'", NumFieldToString(v.Field), NumFieldToString(v.ComparedField))
	}

	return fmt.Sprintf("'%s' is not equal to '%s'", v.Name, v.ComparedName)
}

var NumbersAreNotEqualError = func(v *NumbersAreNotEqual) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' is equal to '%s'", NumFieldToString(v.Field), NumFieldToString(v.ComparedField))
	}

	return fmt.Sprintf("'%s' is equal to '%s'", v.Name, v.ComparedName)
}

var SliceIsNotEmptyError = func(v *SliceIsNotEmpty) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' slice is empty", v.Name)
}

var SliceIsUniqueError = func(v *SliceIsUnique) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("%v values are not unique", v.Field)
}

var SliceLengthInRangeError = func(v *SliceLengthInRange) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	min := v.Min
	max := v.Max

	if max == 0 {
		max = v.length
	}

	if max == -1 {
		return fmt.Sprintf("%v is not empty", v.Field)
	}

	return fmt.Sprintf("%v length=%d not in range(%d, %d)", v.Field, v.length, min, max)
}

var StringContainsAnyError = func(v *StringContainsAny) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' does not contain any substrings from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' does not contain any substrings from '%s'", v.Name, v.ComparedName)
}

var StringContainsNoneOfError = func(v *StringContainsNoneOf) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' contains substring from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' contains substring from '%s'", v.Name, v.ComparedName)
}

var StringExclusionError = func(v *StringExclusion) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("%s is in the blacklist %v", v.Name, v.Blacklist)
}

var StringHasAlphaError = func(v *StringHasAlpha) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' has no letters", v.Field)
}

var StringHasLowerCaseError = func(v *StringHasLowerCase) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain at least 1 lowercase", v.Field)
}

var StringHasNoFileInPathParentsError = func(v *StringHasNoFileInPathParents) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' contains path to a file", v.Field)
}

var StringHasNoPrefixError = func(v *StringHasNoPrefix) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' starts with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' starts with content of '%s'", v.Name, v.ComparedName)
}

var StringHasNoSuffixError = func(v *StringHasNoSuffix) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' ends with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' ends with content of '%s'", v.Name, v.ComparedName)
}

var StringHasNoWhitespaceError = func(v *StringHasNoWhitespace) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' has whitespace", v.Field)
}

var StringHasNumberError = func(v *StringHasNumber) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' has no numbers", v.Field)
}

var StringHasPrefixAnyError = func(v *StringHasPrefixAny) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' has no prefix from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' has no prefix from contents of '%s'", v.Name, v.ComparedName)
}

var StringHasPrefixError = func(v *StringHasPrefix) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' does not start with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' does not start with content of '%s'", v.Name, v.ComparedName)

}

var StringHasPrefixNoneOfError = func(v *StringHasPrefixNoneOf) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' has prefix from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' has prefix from contents of '%s'", v.Name, v.ComparedName)
}

var StringHasSuffixAnyError = func(v *StringHasSuffixAny) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' has no suffix from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' has no suffix from contents of '%s'", v.Name, v.ComparedName)
}

var StringHasSuffixError = func(v *StringHasSuffix) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' does not end with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' does not end with content of '%s'", v.Name, v.ComparedName)

}

var StringHasSuffixNoneOfError = func(v *StringHasSuffixNoneOf) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' has suffix from %v", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' has suffix from contents of '%s'", v.Name, v.ComparedName)
}

var StringHasUpperCaseError = func(v *StringHasUpperCase) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain at least 1 uppercase", v.Field)
}

var StringInclusionError = func(v *StringInclusion) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not in the whitelist %v", v.Field, v.Whitelist)
}

var StringIsASCIIError = func(v *StringIsASCII) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain ASCII chars only", v.Field)
}

var StringIsAbsPathError = func(v *StringIsAbsPath) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' must be absolute", v.Field)
}

var StringIsAlphaError = func(v *StringIsAlpha) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only letters", v.Field)
}

var StringIsAlphaNumError = func(v *StringIsAlphaNum) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only numbers and/or letters", v.Field)
}

var StringIsBase64Error = func(v *StringIsBase64) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be base64 encoded", v.Field)
}

var StringIsCIDRError = func(v *StringIsCIDR) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a CIDR notation address", v.Field)
}

var StringIsCIDRv4Error = func(v *StringIsCIDRv4) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be CIDR notation of IPv4 address", v.Field)
}

var StringIsCIDRv6Error = func(v *StringIsCIDRv6) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be CIDR notation of IPv6 address", v.Field)
}

var StringIsDirError = func(v *StringIsDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' is not a dir", v.Field)
}

var StringIsDirWithModeStickyError = func(v *StringIsDirWithModeSticky) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a dir or a dir without sticky mode", v.Field)
}

var StringIsDirWithoutModeStickyError = func(v *StringIsDirWithoutModeSticky) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a dir or a dir with mode sticky", v.Field)
}

var StringIsEmailError = func(v *StringIsEmail) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' does not match an email format", v.Field)
}

var StringIsEmailLikeError = func(v *StringIsEmailLike) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("%s does not match an email-like format", v.Field)
}

var StringIsExistingGroupError = func(v *StringIsExistingGroup) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' user group does not exist", v.Field)
}

var StringIsExistingUserError = func(v *StringIsExistingUser) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' user does not exist", v.Field)
}

var StringIsFileAndIsExecutableError = func(v *StringIsFileAndIsExecutable) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' does not have execute bit set", v.Field)
}

var StringIsFileAndIsNotExecutableError = func(v *StringIsFileAndIsNotExecutable) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' has execute bit set", v.Field)
}

var StringIsFileError = func(v *StringIsFile) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a file", v.Field)
}

var StringIsFloatError = func(v *StringIsFloat) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a float", v.Field)
}

var StringIsHTTPURLError = func(v *StringIsHTTPURL) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid URL", v.Field)
}

var StringIsHashError = func(v *StringIsHash) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid '%s' hash", v.Field, v.Algorithm)
}

var StringIsHexadecimalError = func(v *StringIsHexadecimal) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a hexadecimal number", v.Field)
}

var StringIsHexcolorError = func(v *StringIsHexcolor) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a hexadecimal color", v.Field)
}

var StringIsIPError = func(v *StringIsIP) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be either IP version 4 or 6", v.Field)
}

var StringIsIPGlobalUnicastError = func(v *StringIsIPGlobalUnicast) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be Global Unicast IP", v.Field)
}

var StringIsIPHasPTRError = func(v *StringIsIPHasPTR) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be an IP address with resolvable PTR record", v.Field)
}

var StringIsIPIfaceLocalMulticastError = func(v *StringIsIPIfaceLocalMulticast) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be an interface-local multicast address", v.Field)
}

var StringIsIPLinkLocalMulticastError = func(v *StringIsIPLinkLocalMulticast) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a link-local multicast address", v.Field)
}

var StringIsIPLinkLocalUnicastError = func(v *StringIsIPLinkLocalUnicast) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a link-local unicast address", v.Field)
}

var StringIsIPLoopbackError = func(v *StringIsIPLoopback) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a loopback address", v.Field)
}

var StringIsIPMulticastError = func(v *StringIsIPMulticast) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a multicast address", v.Field)
}

var StringIsIPUnspecError = func(v *StringIsIPUnspec) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be an unspecified address either IPv4 '0.0.0.0' or the IPv6 '::'", v.Field)
}

var StringIsIPv4Error = func(v *StringIsIPv4) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be IPv4", v.Field)
}

var StringIsIPv6Error = func(v *StringIsIPv6) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be IPv6", v.Field)
}

var StringIsIntError = func(v *StringIsInt) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be an integer", v.Field)
}

var StringIsJSONError = func(v *StringIsJSON) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a valid JSON", v.Field)
}

var StringIsLowerCaseError = func(v *StringIsLowerCase) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be lowercased", v.Field)
}

var StringIsMACError = func(v *StringIsMAC) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be valid MAC address", v.Field)
}

var StringIsNotDirError = func(v *StringIsNotDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' is a dir", v.Field)
}

var StringIsNotExistingGroupError = func(v *StringIsNotExistingGroup) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' user group exists", v.Field)
}

var StringIsNotExistingUserError = func(v *StringIsNotExistingUser) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' user exists", v.Field)
}

var StringIsNotFileError = func(v *StringIsNotFile) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a file", v.Field)
}

var StringIsNotNumericError = func(v *StringIsNotNumeric) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is numeric", v.Field)
}

var StringIsNotPathError = func(v *StringIsNotPath) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' must not exist", v.Field)
}

var StringIsNotRegularUserError = func(v *StringIsNotRegularUser) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a regular user", v.Field)
}

var StringIsNotResolvableHostnameError = func(v *StringIsNotResolvableHostname) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a resolvable hostname", v.Field)
}

var StringIsNotResolvableHostnameNorIPError = func(v *StringIsNotResolvableHostnameNorIP) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a resolvable hostname or an IP address", v.Field)
}

var StringIsNotResolvableHostnameNorIPv4Error = func(v *StringIsNotResolvableHostnameNorIPv4) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a resolvable hostname or an IPv4 address", v.Field)
}

var StringIsNotResolvableHostnameNorIPv6Error = func(v *StringIsNotResolvableHostnameNorIPv6) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a resolvable hostname or an IPv6 address", v.Field)
}

var StringIsNotSymlinkError = func(v *StringIsNotSymlink) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' is a symlink", v.Field)
}

var StringIsNotUserGroupError = func(v *StringIsNotUserGroup) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is a user group", v.Field)
}

var StringIsNullError = func(v *StringIsNull) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be empty", v.Field)
}

var StringIsNumericError = func(v *StringIsNumeric) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only numbers", v.Field)
}

var StringIsPathAndCharDeviceError = func(v *StringIsPathAndCharDevice) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without CharDevice mode", v.Field)
}

var StringIsPathAndDeviceError = func(v *StringIsPathAndDevice) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without Device mode", v.Field)
}

var StringIsPathAndIrregularFileError = func(v *StringIsPathAndIrregularFile) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without Irregular mode", v.Field)
}

var StringIsPathAndIsWritableError = func(v *StringIsPathAndIsWritable) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' path is not writable", v.Field)
}

var StringIsPathAndNamedPipeError = func(v *StringIsPathAndNamedPipe) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without NamedPipe mode", v.Field)
}

var StringIsPathAndNotCharDeviceError = func(v *StringIsPathAndNotCharDevice) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with CharDevice mode", v.Field)
}

var StringIsPathAndNotDeviceError = func(v *StringIsPathAndNotDevice) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with Device mode", v.Field)
}

var StringIsPathAndNotNamedPipeError = func(v *StringIsPathAndNotNamedPipe) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with NamedPipe mode", v.Field)
}

var StringIsPathAndNotSocketError = func(v *StringIsPathAndNotSocket) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with Socket mode", v.Field)
}

var StringIsPathAndRegularFileError = func(v *StringIsPathAndRegularFile) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing non-regular file", v.Field)
}

var StringIsPathAndSocketError = func(v *StringIsPathAndSocket) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without Socket mode", v.Field)
}

var StringIsPathError = func(v *StringIsPath) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' must exist", v.Field)
}

var StringIsPathWithSetGIDError = func(v *StringIsPathWithSetGID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without SetGID flag", v.Field)
}

var StringIsPathWithSetUIDError = func(v *StringIsPathWithSetUID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path without SetUID flag", v.Field)
}

var StringIsPathWithoutSetGIDError = func(v *StringIsPathWithoutSetGID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with SetGID flag", v.Field)
}

var StringIsPathWithoutSetUIDError = func(v *StringIsPathWithoutSetUID) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not an existing path or is an existing path with SetGID flag", v.Field)
}

var StringIsPortError = func(v *StringIsPort) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid port", v.Field)
}

var StringIsPresentError = func(v *StringIsPresent) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must not be blank", v.Name)
}

var StringIsPrintableASCIIError = func(v *StringIsPrintableASCII) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain printable ASCII chars only", v.Field)
}

var StringIsRGBcolorError = func(v *StringIsRGBcolor) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must be a RGB color in format rgb(RRR, GGG, BBB)", v.Field)
}

var StringIsRegularUserOrWhitelistedError = func(v *StringIsRegularUserOrWhitelisted) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a regular user or whitelisted", v.Field)
}

var StringIsResolvableHostnameError = func(v *StringIsResolvableHostname) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a resolvable hostname", v.Field)
}

var StringIsResolvableHostnameOrIPError = func(v *StringIsResolvableHostnameOrIP) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a resolvable hostname and not an IP address", v.Field)
}

var StringIsResolvableHostnameOrIPv4Error = func(v *StringIsResolvableHostnameOrIPv4) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a resolvable hostname and not an IPv4 address", v.Field)
}

var StringIsResolvableHostnameOrIPv6Error = func(v *StringIsResolvableHostnameOrIPv6) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a resolvable hostname and not an IPv6 address", v.Field)
}

var StringIsSymlinkAndTargetIsDirError = func(v *StringIsSymlinkAndTargetIsDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("symlink's '%s' target is not a directory", v.Field)
}

var StringIsSymlinkAndTargetIsNotDirError = func(v *StringIsSymlinkAndTargetIsNotDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("symlink's '%s' target is a directory", v.Field)
}

var StringIsSymlinkAndTargetIsNotPathError = func(v *StringIsSymlinkAndTargetIsNotPath) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("symlink's '%s' target is an existing path", v.Field)
}

var StringIsSymlinkAndTargetIsPathError = func(v *StringIsSymlinkAndTargetIsPath) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("symlink's '%s' target is not an existing path", v.Field)
}

var StringIsSymlinkError = func(v *StringIsSymlink) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("path '%s' is not a symlink", v.Field)
}

var StringIsUTFLetterNumError = func(v *StringIsUTFLetterNum) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only unicode letter/number characters", v.Field)
}

var StringIsUTFLettersError = func(v *StringIsUTFLetters) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only unicode letter characters", v.Field)
}

var StringIsUTFNumericError = func(v *StringIsUTFNumeric) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must contain only unicode numbers", v.Field)
}

var StringIsUnixFilePermissionError = func(v *StringIsUnixFilePermission) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a unix file permission", v.Field)
}

var StringIsUpperCaseError = func(v *StringIsUpperCase) string {

	if len(v.Message) > 0 {
		return v.Message
	}
	return fmt.Sprintf("'%s' must be uppercased", v.Field)
}

var StringIsUserGroupOrWhitelistedError = func(v *StringIsUserGroupOrWhitelisted) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a user group or whitelisted", v.Field)
}

var StringIsValidShadowPasswordError = func(v *StringIsValidShadowPassword) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid shadow password", v.Field)
}

var StringIsValidUserOrGroupNameError = func(v *StringIsValidUserOrGroupName) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' is not a valid user or group name", v.Field)
}

var StringLengthInRangeError = func(v *StringLengthInRange) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	min := v.Min
	max := v.Max

	strLength := utf8.RuneCountInString(v.Field)
	if max == 0 {
		max = strLength
	}

	return fmt.Sprintf("'%s' not in range(%d, %d)", v.Field, min, max)
}

var StringMatchRegexError = func(v *StringMatchRegex) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' does not match regex '%s'", v.Field, v.Regex)
}

var StringsAreEqualError = func(v *StringsAreEqual) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	var caseName string

	if v.CaseInsensitive {
		caseName = "iequal"

	} else {
		caseName = "equal"
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' does not %s '%s'", v.Field, caseName, v.ComparedField)
	}

	return fmt.Sprintf("'%s' does not %s '%s'", v.Name, caseName, v.ComparedName)
}

var StringsAreNotEqualError = func(v *StringsAreNotEqual) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	var caseName string

	if v.CaseInsensitive {
		caseName = "iequal"

	} else {
		caseName = "equal"
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' is %s to '%s'", v.Field, caseName, v.ComparedField)
	}

	return fmt.Sprintf("'%s' is %s to '%s'", v.Name, caseName, v.ComparedName)
}

var StringsArePathsInTheSameDirError = func(v *StringsArePathsInTheSameDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' path is not in the same dir with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' path is not in the same dir with '%s'", v.Name, v.ComparedName)
}

var StringsArePathsNotInTheSameDirError = func(v *StringsArePathsNotInTheSameDir) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' path is in the same dir with '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' path is in the same dir with '%s'", v.Name, v.ComparedName)
}

var TimeIsAfterTimeError = func(v *TimeIsAfterTime) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s' must be after '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s' must be after '%s'", v.Name, v.ComparedName)
}

var TimeIsBeforeTimeError = func(v *TimeIsBeforeTime) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	if len(v.ComparedName) == 0 {
		return fmt.Sprintf("'%s'  must be before '%s'", v.Field, v.ComparedField)
	}

	return fmt.Sprintf("'%s'  must be before '%s'", v.Name, v.ComparedName)
}

var TimeIsPresentError = func(v *TimeIsPresent) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must not be blank", v.Name)
}

var UUIDIsPresentError = func(v *UUIDIsPresent) string {

	if len(v.Message) > 0 {
		return v.Message
	}

	return fmt.Sprintf("'%s' must not be blank", v.Name)
}