propertyName = {
        // The field under validation must be yes, on, 1, or true. This is useful for validating "Terms of Service" acceptance.
        accepted : any value
        
        // The field under validation must be a date after the set targetDate
        after : targetDate
        
        // The field under validation must be a date after or equal the set targetDate
        afterOrEqual : targetDate
​
        // The field must be alphanumeric ONLY
        alpha : any value
        
        // The field under validation is an array and all items must pass this validation as well
        arrayItem : {
            // All the constraints to validate the items with
        }
        
        // The field under validation must be a date before the set targetDate
        before : targetDate
        
        // The field under validation must be a date before or equal the set targetDate
        beforeOrEqual : targetDate
        
        // The field under validation must be a date that is equal the set targetDate
        dateEquals : targetDate
        
        // discrete math modifiers
        discrete : (gt,gte,lt,lte,eq,neq):value
​
        // value in list
        inList : list
​
        // max value
        max : value
​
        // Validation method to use in the target object must return boolean accept the incoming value and target object 
        method : methodName
​
        // min value
        min : value
​
        // range is a range of values the property value should exist in
        range : eg: 1..10 or 5..-5
​
        // regex validation
        regex : valid no case regex
​
        // required field or not, includes null values
        required : boolean [false]
​
        // The field under validation must be present and not empty if the `anotherfield` field is equal to the passed `value`.
        requiredIf : {
            anotherfield:value, anotherfield:value
        }
​
        // The field under validation must be present and not empty unless the `anotherfield` field is equal to the passed 
        requiredUnless : {
            anotherfield:value, anotherfield:value
        }
​
        // same as but with no case
        sameAsNoCase : propertyName
​
        // same as another property
        sameAs : propertyName
​
        // size or length of the value which can be a (struct,string,array,query)
        size  : numeric or range, eg: 10 or 6..8
​
        // specific type constraint, one in the list.
        type  : (alpha,array,binary,boolean,component,creditcard,date,email,eurodate,float,GUID,integer,ipaddress,json,numeric,query,ssn,string,struct,telephone,url,usdate,UUID,xml,zipcode),
​
        // UDF to use for validation, must return boolean accept the incoming value and target object, validate(value,target):boolean
        udf = variables.UDF or this.UDF or a closure.
​
        // Check if a column is unique in the database
        unique = {
            table : The table name,
            column : The column to check, defaults to the property field in check
        }
​
        // Custom validator, must implement coldbox.system.validation.validators.IValidator
        validator : path or wirebox id, example: 'mypath.MyValidator' or 'id:MyValidator'
}

terms = { accepted = true }

startDate : { required:true, type:"date", after: dateAdd( "d", 1, now() ) }

endDate : { required:true, type:"date", after: "startDate" }

startDate : { required:true, type:"date", afterOrEqual: dateAdd( "d", 1, now() ) }

terms = { alpha = true }

invoiceItems = {
    required : true,
    type : "array",
    arrayItem : {
        logDate : { required : true, type : "date" },
        isBilled : { required: true, type : "boolean" },
        notes : { required: true }
    }
}

endDate : { required:true, type:"date", before: "01/01/2022" }

startDate : { required:true, type:"date", before: "endDate" }

endDate : { required:true, type:"date", beforeOrEqual: "01/01/2022" }

endDate : { required:true, type:"date", dateEquals: "01/01/2022" }

startDate : { required:true, type:"date", dateEquals: "createdDate" }

myField = { discrete = "gt:4" }
myField = { discrete = "eq:luis" }
myField = { discrete = "lte:1" }

myField = { inList = "red,green,blue" }

myField = { max = 25 }

myField = { method = "methodName" }
​
function methodName( validationData, targetValue ){
    return true;
}

myField = { min = 8 }

myField = { range = "1..5" }
myField = { range = "5..-5" }

myField = { regex = "^(sick|vacation|disability)$" }

myField = { required=true }
myField = { required=false }

// Struct based
myField = { 
 // myField is required if field2 = test and field3 = hello
 requiredIf = {
  field2 = "test",
  field3 = "hello"
 }
}
​
// String Based
myField = {
 // myField is required if field3 exists and has a value.
 requiredIf = "field3"
}

myField = { 
 // myField is required unless field2 = test and field3 = hello
 requiredUnless = {
  field2 = "test",
  field3 = "hello"
 }
}
​
// String Based
myField = {
 // myField is required unless field3 exists and has a value.
 requiredUnless = "field3"
}

myField = { sameAs = "otherField" }

myField = { sameAs = "otherField" }

myField = { size : 10 }
myFiedl = { size : "8..20" }

myField = { type : "float" }
myField = { type : "json" }
myField = { type : "xml" }

myField = { udf = function( value, target ) { return true; } }
myField = { udf = (value,target) => true }

myField = { unique = { table : "users", column : "username" } }

myField = { validator = "[email protected]" }