valix

type ArrayConditionalConstraint struct {
	// When is the special token denoting the array condition on which the wrapped constraint is to be checked
	//
	// The special token can be one of:
	//
	// * "first" - when the array item is the first
	//
	// * "!first" - when the array item is not the first
	//
	// * "last" - when the array item is the last
	//
	// * "!last" - when the array item is not the last
	//
	// * "%n" - when the modulus n of the array index is zero
	//
	// * ">n" - when the array index is greater than n
	//
	// * "<n" - when the array index is less than n
	//
	// * "n" - when the array index is n
	When string
	// Ancestry is ancestry depth at which to obtain the current array index information
	//
	// Note: the ancestry level is only for arrays in the object tree (and does not need to include other levels).
	// Therefore, by default the value is 0 (zero) - which means the last encountered array
	Ancestry   uint
	Constraint Constraint
}

type ArrayDistinctProperty struct {
	// the name of the property (in each array element object) to check for distinct (uniqueness)
	PropertyName string `v8n:"default"`
	// whether to ignore null property values in the array
	IgnoreNulls bool
	// whether uniqueness is case in-insensitive (for string value properties)
	IgnoreCase bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type ArrayOf struct {
	// the type to check for each item (use Type values)
	Type string `v8n:"default"`
	// whether to allow null items in the array
	AllowNullElement bool
	// is an optional list of constraints that each array element must satisfy
	Constraints Constraints
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type ArrayUnique struct {
	// whether to ignore null items in the array
	IgnoreNulls bool `v8n:"default"`
	// whether uniqueness is case in-insensitive (for string elements)
	IgnoreCase bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type BooleanOperator int

type Check func(value interface{}, vcx *ValidatorContext, this *CustomConstraint) (passed bool, message string)

type Conditional interface {
	MeetsConditions(vcx *ValidatorContext) bool
}

type ConditionalConstraint struct {
	// When is the condition tokens that determine when the wrapped constraint is checked
	When Conditions
	// Others is the others expression to be evaluated to determine when the wrapped constraint is checked
	Others OthersExpr
	// Constraint is the wrapped constraint
	Constraint Constraint
	// FailNotMet specifies that the conditional constraint should fail if the conditions are not met
	//
	// By default, if the conditions are not met the conditional constraint passes (without calling the wrapped constraint)
	FailNotMet bool
	// NotMetMessage is the message used when FailNotMet is set and the conditions are not met
	NotMetMessage string
}

type ConditionalVariant struct {
	// WhenConditions is the condition tokens that determine when this variant is used
	WhenConditions Conditions
	Constraints    Constraints
	Properties     Properties
	// ConditionalVariants is any descendant conditional variants
	ConditionalVariants ConditionalVariants
}

type ConditionalVariants []*ConditionalVariant

type Conditions []string

type Constraint interface {
	// Check the constraint against a given value
	Check(value interface{}, vcx *ValidatorContext) (passed bool, message string)
	// GetMessage returns the actual message for the constraint
	//
	// This method is required so that any documenting functionality can determine
	// the constraint message without having to actually run the constraint
	GetMessage(tcx I18nContext) string
}

type ConstraintSet struct {
	// Constraints is the slice of constraints within the set
	Constraints Constraints `v8n:"default"`
	// when set to true, OneOf specifies that the constraint set should pass just one of
	// the contained constraints (rather than all of them)
	OneOf bool
	// Message is the violation message to be used if any of the constraints fail
	//
	// If the message is empty, the message from the first failing contained constraint is used
	Message string
	// Stop when set to true, prevents further validation checks on the property if this constraint set fails
	Stop bool
}

type Constraints []Constraint

type CustomConstraint struct {
	CheckFunc Check
	Message   string
}

type CustomTagTokenHandler interface {
	Handle(token string, hasValue bool, tokenValue string, pv *PropertyValidator, propertyName string, fieldName string) error
}

type DatetimeDayOfWeek struct {
	// is the allowed days (of the week) expressed as a string of allowed week day numbers (in any order)
	//
	// Where 0 = Sunday, e.g. "06" (or "60") allows Sunday or Saturday
	//
	// or to allow only 'working days' of the week - "12345"
	Days string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeFuture struct {
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeFutureOrPresent struct {
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeGreaterThan struct {
	// the value to compare against (a string representation of date or datetime in ISO format)
	Value string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeGreaterThanOrEqual struct {
	// the value to compare against (a string representation of date or datetime in ISO format)
	Value string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeGreaterThanOrEqualOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeGreaterThanOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeLessThan struct {
	// the value to compare against (a string representation of date or datetime in ISO format)
	Value string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeLessThanOrEqual struct {
	// the value to compare against (a string representation of date or datetime in ISO format)
	Value string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeLessThanOrEqualOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeLessThanOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimePast struct {
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimePastOrPresent struct {
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeRange struct {
	// is the minimum datetime/date (if this is empty, then no minimum check is performed)
	Minimum string
	// is the maximum datetime/date (if this is empty, then no maximum check is performed)
	Maximum string
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeTimeOfDayRange struct {
	// is the minimum time of day (if this is empty, then no minimum check is performed)
	Minimum string
	// is the maximum time of day (if this is empty, then no maximum check is performed)
	Maximum string
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeTolerance struct {
	// the value to compare against (a string representation of date or datetime in ISO format)
	Value string `v8n:"default"`
	// the tolerance duration amount - which can be positive, negative or zero
	//
	// For negative values, this is the maximum duration into the past
	//
	// For positive values, this is the maximum duration into the future
	//
	// Note: If the value is zero then the behaviour is assumed to be "same" - but is then dependent on the unit
	// specified.  For example, if the Duration is zero and the Unit is specified as "year" then this constraint
	// will check the same year
	Duration int64
	// is the string token specifying the unit in which the Duration is measured
	//
	// this can be "millennium", "century", "decade", "year", "month", "week", "day",
	// "hour", "min", "sec" or "milli" (millisecond), "micro" (microsecond) or "nano" (nanosecond)
	//
	// Note: if this is empty, then "day" is assumed.  If the token is invalid - this constraint fails!
	Unit string
	// when set to true, specifies that the tolerance is a minimum check (rather than the default maximum check)
	MinCheck bool
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// when set to true, IgnoreNull makes the constraint less strict by ignoring null values
	IgnoreNull bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeToleranceToNow struct {
	// the tolerance duration amount - which can be positive, negative or zero
	//
	// For negative values, this is the maximum duration into the past
	//
	// For positive values, this is the maximum duration into the future
	//
	// Note: If the value is zero then the behaviour is assumed to be "same" - but is then dependent on the unit
	// specified.  For example, if the Duration is zero and the Unit is specified as "year" then this constraint
	// will check the same year
	Duration int64
	// is the string token specifying the unit in which the Duration is measured
	//
	// this can be "millennium", "century", "decade", "year", "month", "week", "day",
	// "hour", "min", "sec" or "milli" (millisecond), "micro" (microsecond) or "nano" (nanosecond)
	//
	// Note: if this is empty, then "day" is assumed.  If the token is invalid - this constraint fails!
	Unit string
	// when set to true, specifies that the tolerance is a minimum check (rather than the default maximum check)
	MinCheck bool
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// when set to true, IgnoreNull makes the constraint less strict by ignoring null values
	IgnoreNull bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeToleranceToOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the tolerance duration amount - which can be positive, negative or zero
	//
	// For negative values, this is the maximum duration into the past
	//
	// For positive values, this is the maximum duration into the future
	//
	// Note: If the value is zero then the behaviour is assumed to be "same" - but is then dependent on the unit
	// specified.  For example, if the Duration is zero and the Unit is specified as "year" then this constraint
	// will check the same year
	Duration int64
	// is the string token specifying the unit in which the Duration is measured
	//
	// this can be "millennium", "century", "decade", "year", "month", "week", "day",
	// "hour", "min", "sec" or "milli" (millisecond), "micro" (microsecond) or "nano" (nanosecond)
	//
	// Note: if this is empty, then "day" is assumed.  If the token is invalid - this constraint fails!
	Unit string
	// when set to true, specifies that the tolerance is a minimum check (rather than the default maximum check)
	MinCheck bool
	// when set to true, excludes the time when comparing
	//
	// Note: This also excludes the effect of any timezone offsets specified in either of the compared values
	ExcTime bool
	// when set to true, IgnoreNull makes the constraint less strict by ignoring null values
	//
	// NB. ignoring nulls applies to both the property being checked and the other named property
	IgnoreNull bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DatetimeYearsOld struct {
	// is the minimum age (not checked if this value is zero or less)
	Minimum int
	// is the maximum age (not checked if this value is zero or less)
	Maximum int
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// if set to true, only checks the minimum/maximum age against the current year - i.e. the current age is calculated
	// based on 23:59:59.999999999 at 31st December of the current year
	ThisYear bool
	// is an optional string representing a threshold date at which the age is calculated
	//
	// If this is specified, the year part is ignored (the current year is always used)
	//
	// Note: if specified, this also overrides the ThisYear flag
	ThresholdDate string
	// if set, adjusts the way leapday birthdays are age calculated
	//
	// By default, leapday birthdays are taken as 1st March when the current year is not a leap year
	//
	// Setting LeapdayAdjust to true means that leapday birthdays are taken as 28th Feb
	LeapdayAdjust bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type DecoderProvider interface {
	NewDecoder(r io.Reader, useNumber bool) *json.Decoder
	NewDecoderFor(r io.Reader, validator *Validator) *json.Decoder
}

type Duration struct {
	Negative bool
	Years    *float64
	Months   *float64
	Weeks    *float64
	Days     *float64
	Hours    *float64
	Minutes  *float64
	Seconds  *float64
}

type EqualsOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type FailWhen struct {
	// the conditions under which to fail
	Conditions []string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, StopAll stops the entire validation
	StopAll bool
}

type FailWith struct {
	// Others is the others expression to be evaluated to determine whether the constraint should fail
	Others OthersExpr `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, StopAll stops the entire validation
	StopAll bool
}

type FailingConstraint struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, StopAll stops the entire validation
	StopAll bool
}

type GreaterThan struct {
	// the value to compare against
	Value float64 `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type GreaterThanOrEqual struct {
	// the value to compare against
	Value float64 `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type GreaterThanOrEqualOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type GreaterThanOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type I18n interface {
	ContextFromRequest(r *http.Request) I18nContext
	DefaultContext() I18nContext
}

type I18nContext interface {
	TranslateMessage(msg string) string
	TranslateFormat(format string, a ...interface{}) string
	TranslateToken(token string) string
	Language() string
	Region() string
}

type IsNotNull struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type IsNull struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type JsonType int

type Length struct {
	// the minimum length
	Minimum int
	// the maximum length (only checked if this value is > 0)
	Maximum int
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type LengthExact struct {
	// the length to check
	Value int `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type LessThan struct {
	// the value to compare against
	Value float64 `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type LessThanOrEqual struct {
	// the value to compare against
	Value float64 `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type LessThanOrEqualOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type LessThanOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type Maximum struct {
	// the maximum value
	Value float64 `v8n:"default"`
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type MaximumInt struct {
	// the maximum value
	Value int64 `v8n:"default"`
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type Minimum struct {
	// the minimum value
	Value float64 `v8n:"default"`
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type MinimumInt struct {
	// the minimum value
	Value int64 `v8n:"default"`
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type MultipleOf struct {
	// the multiple of value to check
	Value int64 `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type Negative struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type NegativeOrZero struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type NetIsCIDR struct {
	// if set, allows only CIDR v4
	V4Only bool
	// if set, allows only CIDR v6
	V6Only bool
	// if set, disallows loopback addresses
	DisallowLoopback bool
	// if set, disallows private addresses
	DisallowPrivate bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsHostname struct {
	// CheckHost when set, checks the host (using net.LookupHost)
	CheckHost bool
	// AllowIPAddress when set, allows IP address hostnames
	AllowIPAddress bool
	// AllowIPV6 when set, allows IP v6 address hostnames
	AllowIPV6 bool
	// AllowLocal when set, allows hostnames 'local' (e.g. "localhost", "local", "localdomain", "127.0.0.1", "::1")
	AllowLocal bool
	// AllowTldOnly when set, allows hostnames with only Tld specified (e.g. "audi")
	AllowTldOnly bool
	// AllowGeographicTlds when set, allows hostnames with geographic Tlds (e.g. "some-company.africa")
	AllowGeographicTlds bool
	// AllowGenericTlds when set, allows hostnames with generic Tlds (e.g. "some.academy")
	AllowGenericTlds bool
	// AllowBrandTlds when set, allows hostnames with brand Tlds (e.g. "my.audi")
	AllowBrandTlds bool
	// AllowInfraTlds when set, allows hostnames with infrastructure Tlds (e.g. "arpa")
	AllowInfraTlds bool
	// AllowTestTlds when set, allows hostnames with test Tlds and test domains (e.g. "example.com", "test.com")
	AllowTestTlds bool
	// AddCountryCodeTlds is an optional slice of additional country (and geographic) Tlds to allow
	AddCountryCodeTlds []string
	// ExcCountryCodeTlds is an optional slice of country (and geographic) Tlds to disallow
	ExcCountryCodeTlds []string
	// AddGenericTlds is an optional slice of additional generic Tlds to allow (only checked if AllowGenericTlds is also set)
	AddGenericTlds []string
	// ExcGenericTlds is an optional slice of generic Tlds to disallow (only relevant if AllowGenericTlds is also set)
	ExcGenericTlds []string
	// AddBrandTlds is an optional slice of additional brand Tlds to allow (only checked if AllowBrandTlds is also set)
	AddBrandTlds []string
	// ExcBrandTlds is an optional slice of brand Tlds to disallow (only relevant if AllowBrandTlds is also set)
	ExcBrandTlds []string
	// AddLocalTlds is an optional slice of additional local Tlds to allow (only checked if AllowLocal is also set)
	AddLocalTlds []string
	// ExcLocalTlds is an optional slice of local Tlds to disallow (only relevant if AllowLocal is also set)
	ExcLocalTlds []string
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsIP struct {
	// if set, allows only IP v4
	V4Only bool
	// if set, allows only IP v6
	V6Only bool
	// if set, checks that the address is resolvable
	Resolvable bool
	// if set, disallows loopback addresses
	DisallowLoopback bool
	// if set, disallows private addresses
	DisallowPrivate bool
	// if set, allows value of "localhost" to be seen as valid
	AllowLocalhost bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsMac struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsTCP struct {
	// if set, allows only TCP v4
	V4Only bool
	// if set, allows only TCP v6
	V6Only bool
	// if set, disallows loopback addresses
	DisallowLoopback bool
	// if set, disallows private addresses
	DisallowPrivate bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsTld struct {
	AllowGeographicTlds bool
	AllowGenericTlds    bool
	AllowBrandTlds      bool
	AddCountryCodeTlds  []string
	ExcCountryCodeTlds  []string
	AddGenericTlds      []string
	ExcGenericTlds      []string
	AddBrandTlds        []string
	ExcBrandTlds        []string
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsUDP struct {
	// if set, allows only TCP v4
	V4Only bool
	// if set, allows only TCP v6
	V6Only bool
	// if set, disallows loopback addresses
	DisallowLoopback bool
	// if set, disallows private addresses
	DisallowPrivate bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsURI struct {
	// if set, the host is also checked (see also AllowIPAddress and others)
	CheckHost bool `v8n:"default"`
	// AllowIPAddress when set, allows IP address hostnames
	AllowIPAddress bool
	// AllowIPV6 when set, allows IP v6 address hostnames
	AllowIPV6 bool
	// AllowLocal when set, allows hostnames 'local' (e.g. "localhost", "local", "localdomain", "127.0.0.1", "::1")
	AllowLocal bool
	// AllowTldOnly when set, allows hostnames with only Tld specified (e.g. "audi")
	AllowTldOnly bool
	// AllowGeographicTlds when set, allows hostnames with geographic Tlds (e.g. "some-company.africa")
	AllowGeographicTlds bool
	// AllowGenericTlds when set, allows hostnames with generic Tlds (e.g. "some.academy")
	AllowGenericTlds bool
	// AllowBrandTlds when set, allows hostnames with brand Tlds (e.g. "my.audi")
	AllowBrandTlds bool
	// AllowInfraTlds when set, allows hostnames with infrastructure Tlds (e.g. "arpa")
	AllowInfraTlds bool
	// AllowTestTlds when set, allows hostnames with test Tlds and test domains (e.g. "example.com", "test.com")
	AllowTestTlds bool
	// AddCountryCodeTlds is an optional slice of additional country (and geographic) Tlds to allow
	AddCountryCodeTlds []string
	// ExcCountryCodeTlds is an optional slice of country (and geographic) Tlds to disallow
	ExcCountryCodeTlds []string
	// AddGenericTlds is an optional slice of additional generic Tlds to allow (only checked if AllowGenericTlds is also set)
	AddGenericTlds []string
	// ExcGenericTlds is an optional slice of generic Tlds to disallow (only relevant if AllowGenericTlds is also set)
	ExcGenericTlds []string
	// AddBrandTlds is an optional slice of additional brand Tlds to allow (only checked if AllowBrandTlds is also set)
	AddBrandTlds []string
	// ExcBrandTlds is an optional slice of brand Tlds to disallow (only relevant if AllowBrandTlds is also set)
	ExcBrandTlds []string
	// AddLocalTlds is an optional slice of additional local Tlds to allow (only checked if AllowLocal is also set)
	AddLocalTlds []string
	// ExcLocalTlds is an optional slice of local Tlds to disallow (only relevant if AllowLocal is also set)
	ExcLocalTlds []string
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NetIsURL struct {
	// if set, the host is also checked (see also AllowIPAddress and others)
	CheckHost bool `v8n:"default"`
	// AllowIPAddress when set, allows IP address hostnames
	AllowIPAddress bool
	// AllowIPV6 when set, allows IP v6 address hostnames
	AllowIPV6 bool
	// AllowLocal when set, allows hostnames 'local' (e.g. "localhost", "local", "localdomain", "127.0.0.1", "::1")
	AllowLocal bool
	// AllowTldOnly when set, allows hostnames with only Tld specified (e.g. "audi")
	AllowTldOnly bool
	// AllowGeographicTlds when set, allows hostnames with geographic Tlds (e.g. "some-company.africa")
	AllowGeographicTlds bool
	// AllowGenericTlds when set, allows hostnames with generic Tlds (e.g. "some.academy")
	AllowGenericTlds bool
	// AllowBrandTlds when set, allows hostnames with brand Tlds (e.g. "my.audi")
	AllowBrandTlds bool
	// AllowInfraTlds when set, allows hostnames with infrastructure Tlds (e.g. "arpa")
	AllowInfraTlds bool
	// AllowTestTlds when set, allows hostnames with test Tlds and test domains (e.g. "example.com", "test.com")
	AllowTestTlds bool
	// AddCountryCodeTlds is an optional slice of additional country (and geographic) Tlds to allow
	AddCountryCodeTlds []string
	// ExcCountryCodeTlds is an optional slice of country (and geographic) Tlds to disallow
	ExcCountryCodeTlds []string
	// AddGenericTlds is an optional slice of additional generic Tlds to allow (only checked if AllowGenericTlds is also set)
	AddGenericTlds []string
	// ExcGenericTlds is an optional slice of generic Tlds to disallow (only relevant if AllowGenericTlds is also set)
	ExcGenericTlds []string
	// AddBrandTlds is an optional slice of additional brand Tlds to allow (only checked if AllowBrandTlds is also set)
	AddBrandTlds []string
	// ExcBrandTlds is an optional slice of brand Tlds to disallow (only relevant if AllowBrandTlds is also set)
	ExcBrandTlds []string
	// AddLocalTlds is an optional slice of additional local Tlds to allow (only checked if AllowLocal is also set)
	AddLocalTlds []string
	// ExcLocalTlds is an optional slice of local Tlds to disallow (only relevant if AllowLocal is also set)
	ExcLocalTlds []string
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NotEmpty struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
}

type NotEqualsOther struct {
	// the property name of the other value to compare against
	//
	// Note: the PropertyName can also be JSON dot notation path - where leading dots allow traversal up
	// the object tree and names, separated by dots, allow traversal down the object tree.
	// A single dot at start is equivalent to no starting dot (i.e. a property name at the same level)
	PropertyName string `v8n:"default"`
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the other property is not present (even though the not equals would technically be ok)
	Strict bool
}

type OasInfo struct {
	Description string
	Title       string
	Format      string
	Example     string
	Deprecated  bool
}

type Option interface {
	Apply(on *Validator) error
}

type Other interface {
	// Evaluate evaluates the presence or non-presence of named properties in a given object
	//
	// the currentObj arg is the object that the property should be checked for within
	//
	// the ancestryValues arg provides the ancestry of objects in case there is a need to traverse
	// upwards.  The first, index 0, item in the ancestryValues slice will be the parent of the
	// currentObj... the second item will be the grandparent of currentObj... etc.
	Evaluate(currentObj map[string]interface{}, ancestryValues []interface{}, vcx *ValidatorContext) bool
	// GetOperator returns the boolean operator (And / Or)
	GetOperator() BooleanOperator
	// String method provides a string representation of the expression
	String() string
}

type OtherGrouping struct {
	// Of is the items within the grouping
	Of OthersExpr
	// Not is whether the grouping is NOTed (!)
	Not bool
	// Op is the boolean operator (And / Or) applied to the previous resultant
	Op BooleanOperator
}

type OtherProperty struct {
	// Name is the name of the property whose presence or non-presence is to be checked
	Name string
	// Not is whether presence is NOTed (!) - i.e. if Not is set to true, then the non-presence is checked
	Not bool
	// Op is the boolean operator (And / Or) applied to the previous resultant
	Op BooleanOperator
	// contains filtered or unexported fields
}

type OthersExpr []Other

type Positive struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type PositiveOrZero struct {
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string `v8n:"default"`
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type PostPatternChecker interface {
	Check(str string) bool
}

type Preset interface {
	Check(v string) bool
	GetRegexp() *regexp.Regexp
	GetPostChecker() PostPatternChecker
	GetMessage() string
}

type Properties map[string]*PropertyValidator

type PropertyNameProvider interface {
	// NameFor provides the property name for a given struct field (return ok false if default field name is to be used)
	NameFor(field reflect.StructField) (name string, ok bool)
}

type PropertyValidator struct {
	// Type specifies the property type to be checked (i.e. one of Type)
	//
	// If this value is not one of Type (or an empty string), then the property type is not checked
	Type JsonType
	// NotNull specifies that the value of the property may not be null
	NotNull bool
	// Mandatory specifies that the property must be present
	Mandatory bool
	// MandatoryWhen is complimentary to the Mandatory property - and limits the conditions under which the property is
	// seen as mandatory (if this is empty and Mandatory is set - then the property is always mandatory)
	//
	// Note: If the Mandatory property is not set to true - this property has no effect!
	MandatoryWhen Conditions
	// Constraints is a slice of Constraint items and are checked in the order they are specified
	Constraints Constraints
	// ObjectValidator is checked, if specified, after all Constraints are checked
	ObjectValidator *Validator
	// Order is the order in which the property is checked (see Validator.OrderedPropertyChecks)
	//
	// Note: setting any property with Order other than 0 (zero) will force the validator to use ordered property checks
	// (i.e. as if Validator.OrderedPropertyChecks had been set to true)
	Order int
	// StopOnFirst if set, instructs the property validator to stop at the first constraint violation found
	//
	// This would be the equivalent of setting `Stop` on each constraint
	StopOnFirst bool
	// WhenConditions is the condition tokens that dictate under which conditions this validator is to be checked
	//
	// Condition tokens can be set and unset during validation to allow polymorphism of validation
	// (see ValidatorContext.SetCondition & ValidatorContext.ClearCondition)
	WhenConditions Conditions
	// UnwantedConditions is the condition tokens that dictate when the property should not be present
	UnwantedConditions Conditions
	// RequiredWith is an expression of when this property is required according to the presence of other properties
	//
	// Use MustParseExpression or ParseExpression to build the expression - or build in code directly using
	// combinations of OthersExpr, OtherProperty and OtherGrouping
	RequiredWith OthersExpr
	// RequiredWithMessage is the violation message to use when the RequiredWith fails (if this string is empty, then
	// the default message is used)
	RequiredWithMessage string
	// UnwantedWith is an expression of when this property is unwanted according to the presence of other properties
	//
	// Use MustParseExpression or ParseExpression to build the expression - or build in code directly using
	// combinations of OthersExpr, OtherProperty and OtherGrouping
	UnwantedWith OthersExpr
	// UnwantedWithMessage is the violation message to use when the UnwantedWith fails (if this string is empty, then
	// the default message is used)
	UnwantedWithMessage string
	// Only when set to true, indicates that this should be the only property present
	//
	// When the property is specified alone - all other properties (including their constraints and even their mandatory status) are ignored
	Only bool
	// OnlyConditions is the condition tokens that dictate when the property should be the only property (see also Only)
	OnlyConditions Conditions
	// OnlyMessage is the violation message to use when the Only or OnlyConditions fails (i.e. the property is not the only property)
	OnlyMessage string
	// OasInfo is additional information (for OpenAPI Specification)
	OasInfo *OasInfo
}

type Range struct {
	// the minimum value of the range
	Minimum float64
	// the maximum value of the range
	Maximum float64
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type RangeInt struct {
	// the minimum value of the range
	Minimum int64
	// the maximum value of the range
	Maximum int64
	// if set to true, ExclusiveMin specifies the minimum value is exclusive
	ExclusiveMin bool
	// if set to true, ExclusiveMax specifies the maximum value is exclusive
	ExclusiveMax bool
	// the violation message to be used if the constraint fails (see Violation.Message)
	//
	// (if the Message is an empty string then the default violation message is used)
	Message string
	// when set to true, Stop prevents further validation checks on the property if this constraint fails
	Stop bool
	// when set to true, fails if the value being checked is not a correct type
	Strict bool
}

type RegionalVariantTranslation struct {
	// is the region (must not be "" or will not be added)
	Region string
	// the regional translation (if "" uses the parent language translation)
	Translation string
}

type SetConditionFrom struct {
	// Parent by default, conditions are set on the current property or object - but specifying
	// true for this field means the condition is set on the parent object too
	Parent bool
	// Global setting this field to true means the condition is set for the entire
	// validator context
	Global bool
	// Prefix is any prefix to be appended to the condition token
	Prefix string
	// Mapping converts the string value to alternate values (if the value is not found in the map
	// then the original value is used
	Mapping map[string]string
	// NullToken is the condition token used if the value of the property is null/nil.  If this field is not set
	// and the property value is null at validation - then a condition token of "null" is used
	NullToken string
	// Format is an optional format string for dealing with non-string property values
	Format string
}

type SetConditionIf struct {
	// is the wrapped constraint to be checked
	//
	// If this is nil, the SetOk condition is always set
	//
	// Note: the wrapped constraint cannot add any violations and cannot stop the validation (i.e. it is called 'silently')
	Constraint Constraint
	// is the condition to set if the wrapped constraint is ok
	//
	// Note: if this is an empty string - no condition is set
	SetOk string
	// is the condition to set if the wrapped constraint fails
	//
	// Note: if this is an empty string - no condition is set
	SetFail string
	// Parent by default, conditions are set on the current property or object - but specifying
	// true for this field means the condition is set on the parent object too
	Parent bool
	// Global setting this field to true means the condition is set for the entire
	// validator context
	Global bool
}