 		}
 
 		// loop over the passed in types
-		loc.iEnd = ListLen(arguments.type);
-		for (loc.i=1; loc.i <= loc.iEnd; loc.i++)
-		{
-			loc.item = ListGetAt(arguments.type, loc.i);
+		local.iEnd = ListLen(arguments.type);
+		for (local.i=1; local.i <= local.iEnd; local.i++)
+		{
+			local.item = ListGetAt(arguments.type, local.i);
 
 			// loop through all validations for passed in type (onSave, onCreate etc) that has been set on this model object
-			loc.jEnd = ArrayLen(variables.wheels.class.validations[loc.item]);
-			for (loc.j=1; loc.j <= loc.jEnd; loc.j++)
-			{
-				loc.thisValidation = variables.wheels.class.validations[loc.item][loc.j];
-				if ($evaluateCondition(argumentCollection=loc.thisValidation.args))
-				{
-					if (loc.thisValidation.method == "$validatesPresenceOf")
+			local.jEnd = ArrayLen(variables.wheels.class.validations[local.item]);
+			for (local.j=1; local.j <= local.jEnd; local.j++)
+			{
+				local.thisValidation = variables.wheels.class.validations[local.item][local.j];
+				if ($evaluateCondition(argumentCollection=local.thisValidation.args))
+				{
+					if (local.thisValidation.method == "$validatesPresenceOf")
 					{
 						// if the property does not exist or if it's blank we add an error on the object (for all other validation types we call corresponding methods below instead)
-						if (!StructKeyExists(this, loc.thisValidation.args.property) || (IsSimpleValue(this[loc.thisValidation.args.property]) && !Len(Trim(this[loc.thisValidation.args.property]))) || (IsStruct(this[loc.thisValidation.args.property]) && !StructCount(this[loc.thisValidation.args.property])))
+						if (!StructKeyExists(this, local.thisValidation.args.property) || (IsSimpleValue(this[local.thisValidation.args.property]) && !Len(Trim(this[local.thisValidation.args.property]))) || (IsStruct(this[local.thisValidation.args.property]) && !StructCount(this[local.thisValidation.args.property])))
 						{
-							addError(property=loc.thisValidation.args.property, message=$validationErrorMessage(loc.thisValidation.args.property, loc.thisValidation.args.message));
+							addError(property=local.thisValidation.args.property, message=$validationErrorMessage(local.thisValidation.args.property, local.thisValidation.args.message));
 						}
 					}
 					else
 					{
 						// if the validation set does not allow blank values we can set an error right away, otherwise we call a method to run the actual check
-						if (StructKeyExists(loc.thisValidation.args, "property") && StructKeyExists(loc.thisValidation.args, "allowBlank") && !loc.thisValidation.args.allowBlank && (!StructKeyExists(this, loc.thisValidation.args.property) || (!Len(this[loc.thisValidation.args.property]) && loc.thisValidation.method != "$validatesUniquenessOf")))
+						if (StructKeyExists(local.thisValidation.args, "property") && StructKeyExists(local.thisValidation.args, "allowBlank") && !local.thisValidation.args.allowBlank && (!StructKeyExists(this, local.thisValidation.args.property) || (!Len(this[local.thisValidation.args.property]) && local.thisValidation.method != "$validatesUniquenessOf")))
 						{
-							addError(property=loc.thisValidation.args.property, message=$validationErrorMessage(loc.thisValidation.args.property, loc.thisValidation.args.message));
+							addError(property=local.thisValidation.args.property, message=$validationErrorMessage(local.thisValidation.args.property, local.thisValidation.args.message));
 						}
-						else if (!StructKeyExists(loc.thisValidation.args, "property") || (StructKeyExists(this, loc.thisValidation.args.property) &&(Len(this[loc.thisValidation.args.property]) || loc.thisValidation.method == "$validatesUniquenessOf")))
+						else if (!StructKeyExists(local.thisValidation.args, "property") || (StructKeyExists(this, local.thisValidation.args.property) &&(Len(this[local.thisValidation.args.property]) || local.thisValidation.method == "$validatesUniquenessOf")))
 						{
-							$invoke(method=loc.thisValidation.method, invokeArgs=loc.thisValidation.args);
+							$invoke(method=local.thisValidation.method, invokeArgs=local.thisValidation.args);
 						}
 					}
 				}
 			}
 		}
-
 		// now that we have run all the validation checks we can return "true" if no errors exist on the object, "false" otherwise
-		loc.rv = !hasErrors();
-	</cfscript>
-	<cfreturn loc.rv>
-</cffunction>
-
-<cffunction name="$evaluateCondition" returntype="boolean" access="public" output="false" hint="Evaluates the condition to determine if the validation should be executed.">
-	<cfscript>
-		var loc = {};
-		loc.rv = false;
-
+		return !hasErrors();
+	}
+
+	/**
+    * Evaluates the condition to determine if the validation should be executed.
+    */
+	public boolean function $evaluateCondition() {
+		local.rv = false;
 		// since cf8 can't handle cfscript operators (==, != etc) inside an Evaluate() call we replace them with eq, neq etc in a try / catch
-		loc.evaluate = "condition,unless";
-		loc.iEnd = ListLen(loc.evaluate);
-		for (loc.i=1; loc.i <= loc.iEnd; loc.i++)
-		{
-			loc.item = ListGetAt(loc.evaluate, loc.i);
-			if (StructKeyExists(arguments, loc.item) && Len(arguments[loc.item]))
-			{
-				loc.key = loc.item & "Evaluated";
+		local.evaluate = "condition,unless";
+		local.iEnd = ListLen(local.evaluate);
+		for (local.i=1; local.i <= local.iEnd; local.i++)
+		{
+			local.item = ListGetAt(local.evaluate, local.i);
+			if (StructKeyExists(arguments, local.item) && Len(arguments[local.item]))
+			{
+				local.key = local.item & "Evaluated";
 				try
 				{
-					loc[loc.key] = Evaluate(arguments[loc.item]);
+					local[local.key] = Evaluate(arguments[local.item]);
 				}
 				catch (any e)
 				{
-					arguments[loc.item] = Replace(ReplaceList(arguments[loc.item], "==,!=,<,<=,>,>=", " eq , neq , lt , lte , gt , gte "), "  ", " ", "all");
-					loc[loc.key] = Evaluate(arguments[loc.item]);
-				}
-			}
-		}
-
+					arguments[local.item] = Replace(ReplaceList(arguments[local.item], "==,!=,<,<=,>,>=", " eq , neq , lt , lte , gt , gte "), "  ", " ", "all");
+					local[local.key] = Evaluate(arguments[local.item]);
+				}
+			}
+		}
 		// proceed with validation when "condition" has been supplied and it evaluates to "true" or when "unless" has been supplied and it evaluates to "false"
 		// if both "condition" and "unless" have been supplied though, they both need to be evaluated correctly ("true"/false" that is) for validation to proceed
-		if ((!StructKeyExists(arguments, "condition") || !Len(arguments.condition) || loc.conditionEvaluated) && (!StructKeyExists(arguments, "unless") || !Len(arguments.unless) || !loc.unlessEvaluated))
-		{
-			loc.rv = true;
-		}
-	</cfscript>
-	<cfreturn loc.rv>
-</cffunction>
-
-<cffunction name="$validatesConfirmationOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesConfirmationOf method.">
-	<cfscript>
-		var loc = {};
-		loc.virtualConfirmProperty = arguments.property & "Confirmation";
-		if (StructKeyExists(this, loc.virtualConfirmProperty) && this[arguments.property] != this[loc.virtualConfirmProperty])
-		{
-			addError(property=loc.virtualConfirmProperty, message=$validationErrorMessage(argumentCollection=arguments));
-		}
-	</cfscript>
-</cffunction>
-
-<cffunction name="$validatesExclusionOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesExclusionOf method.">
-	<cfscript>
+		if ((!StructKeyExists(arguments, "condition") || !Len(arguments.condition) || local.conditionEvaluated) && (!StructKeyExists(arguments, "unless") || !Len(arguments.unless) || !local.unlessEvaluated))
+		{
+			local.rv = true;
+		}
+		return local.rv;
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesConfirmationOf method.
+    */
+	public void function $validatesConfirmationOf() {
+		local.virtualConfirmProperty = arguments.property & "Confirmation";
+		if (StructKeyExists(this, local.virtualConfirmProperty) && this[arguments.property] != this[local.virtualConfirmProperty])
+		{
+			addError(property=local.virtualConfirmProperty, message=$validationErrorMessage(argumentCollection=arguments));
+		}
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesExclusionOf method.
+    */
+	public void function $validatesExclusionOf() {
 		if (ListFindNoCase(arguments.list, this[arguments.property]))
 		{
 			addError(property=arguments.property, message=$validationErrorMessage(argumentCollection=arguments));
 		}
-	</cfscript>
-</cffunction>
-
-<cffunction name="$validatesFormatOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesFormatOf method.">
-	<cfscript>
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesFormatOf method.
+    */
+	public void function $validatesFormatOf() {
 		if ((Len(arguments.regEx) && !REFindNoCase(arguments.regEx, this[arguments.property])) || (Len(arguments.type) && !IsValid(arguments.type, this[arguments.property])))
 		{
 			addError(property=arguments.property, message=$validationErrorMessage(argumentCollection=arguments));
 		}
-	</cfscript>
-</cffunction>
-
-<cffunction name="$validatesInclusionOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesInclusionOf method.">
-	<cfscript>
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesInclusionOf method.
+    */
+	public void function $validatesInclusionOf() {
 		if (!ListFindNoCase(arguments.list, this[arguments.property]))
 		{
 			addError(property=arguments.property, message=$validationErrorMessage(argumentCollection=arguments));
 		}
-	</cfscript>
-</cffunction>
-
-<cffunction name="$validatesPresenceOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesPresenceOf method.">
-	<cfargument name="property" type="string" required="true">
-	<cfargument name="message" type="string" required="true">
-	<cfargument name="properties" type="struct" required="false" default="#this.properties()#">
-	<cfscript>
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesPresenceOf method.
+    */
+	public void function $validatesPresenceOf(
+		required string property,
+		required string message,
+		struct properties=this.properties()
+	) {
 		// if the property does not exist or if it's blank we add an error on the object
 		if (!StructKeyExists(arguments.properties, arguments.property) || (IsSimpleValue(arguments.properties[arguments.property]) && !Len(Trim(arguments.properties[arguments.property]))) || (IsStruct(arguments.properties[arguments.property]) && !StructCount(arguments.properties[arguments.property])))
 		{
 			addError(property=arguments.property, message=$validationErrorMessage(argumentCollection=arguments));
 		}
-	</cfscript>
-</cffunction>
-
-<cffunction name="$validatesLengthOf" returntype="void" access="public" output="false" hint="Adds an error if the object property fail to pass the validation setup in the @validatesLengthOf method.">
-	<cfargument name="property" type="string" required="true">
-	<cfargument name="message" type="string" required="true">
-	<cfargument name="exactly" type="numeric" required="true">
-	<cfargument name="maximum" type="numeric" required="true">
-	<cfargument name="minimum" type="numeric" required="true">
-	<cfargument name="within" type="any" required="true">
-	<cfargument name="properties" type="struct" required="false" default="#this.properties()#">
-	<cfscript>
-		var loc = {};
-		loc.lenValue = Len(arguments.properties[arguments.property]);
+	}
+
+	/**
+    * Adds an error if the object property fail to pass the validation setup in the @validatesLengthOf method.
+    */
+	public void function $validatesLengthOf(
+		required string property,
+		required string message,
+		required numeric exactly,
+		required numeric maximum,
+		required numeric minimum,
+		required any within,
+		struct properties=this.properties()
+	) {
+		local.lenValue = Len(arguments.properties[arguments.property]);
 
 		// for within, just create minimum / maximum values
 		if (IsArray(arguments.within) && ArrayLen(arguments.within) == 2)

			}
		}
		$registerValidation(methods="$validatesFormatOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<cffunction name="validatesInclusionOf" returntype="void" access="public" output="false">
	<cfargument name="properties" type="string" required="false" default="">
	<cfargument name="list" type="string" required="true">
	<cfargument name="message" type="string" required="false">
	<cfargument name="when" type="string" required="false" default="onSave">
	<cfargument name="allowBlank" type="boolean" required="false">
	<cfargument name="condition" type="string" required="false" default="">
	<cfargument name="unless" type="string" required="false" default="">
	<cfscript>
		$args(name="validatesInclusionOf", args=arguments);
		arguments.list = $listClean(arguments.list);
		$registerValidation(methods="$validatesInclusionOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<cffunction name="validatesLengthOf" returntype="void" access="public" output="false">
	<cfargument name="properties" type="string" required="false" default="">
	<cfargument name="message" type="string" required="false">
	<cfargument name="when" type="string" required="false" default="onSave">
	<cfargument name="allowBlank" type="boolean" required="false">
	<cfargument name="exactly" type="numeric" required="false">
	<cfargument name="maximum" type="numeric" required="false">
	<cfargument name="minimum" type="numeric" required="false">
	<cfargument name="within" type="string" required="false">
	<cfargument name="condition" type="string" required="false" default="">
	<cfargument name="unless" type="string" required="false" default="">
	<cfscript>
		$args(name="validatesLengthOf", args=arguments);
		if (Len(arguments.within))
		{
			arguments.within = $listClean(list=arguments.within, returnAs="array");
		}
		$registerValidation(methods="$validatesLengthOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<cffunction name="validatesNumericalityOf" returntype="void" access="public" output="false">
	<cfargument name="properties" type="string" required="false" default="">
	<cfargument name="message" type="string" required="false">
	<cfargument name="when" type="string" required="false" default="onSave">
	<cfargument name="allowBlank" type="boolean" required="false">
	<cfargument name="onlyInteger" type="boolean" required="false">
	<cfargument name="condition" type="string" required="false" default="">
	<cfargument name="unless" type="string" required="false" default="">
	<cfargument name="odd" type="boolean" required="false">
	<cfargument name="even" type="boolean" required="false">
	<cfargument name="greaterThan" type="numeric" required="false">
	<cfargument name="greaterThanOrEqualTo" type="numeric" required="false">
	<cfargument name="equalTo" type="numeric" required="false">
	<cfargument name="lessThan" type="numeric" required="false">
	<cfargument name="lessThanOrEqualTo" type="numeric" required="false">
	<cfscript>
		$args(name="validatesNumericalityOf", args=arguments);
		$registerValidation(methods="$validatesNumericalityOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<cffunction name="validatesPresenceOf" returntype="void" access="public" output="false">
	<cfargument name="properties" type="string" required="false" default="">
	<cfargument name="message" type="string" required="false">
	<cfargument name="when" type="string" required="false" default="onSave">
	<cfargument name="condition" type="string" required="false" default="">
	<cfargument name="unless" type="string" required="false" default="">
	<cfscript>
		$args(name="validatesPresenceOf", args=arguments);
		$registerValidation(methods="$validatesPresenceOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<cffunction name="validatesUniquenessOf" returntype="void" access="public" output="false">
	<cfargument name="properties" type="string" required="false" default="">
	<cfargument name="message" type="string" required="false">
	<cfargument name="when" type="string" required="false" default="onSave">
	<cfargument name="allowBlank" type="boolean" required="false">
	<cfargument name="scope" type="string" required="false" default="">
	<cfargument name="condition" type="string" required="false" default="">
	<cfargument name="unless" type="string" required="false" default="">
	<cfargument name="includeSoftDeletes" type="boolean" required="false" default="true">
	<cfscript>
		$args(name="validatesUniquenessOf", args=arguments);
		arguments.scope = $listClean(arguments.scope);
		$registerValidation(methods="$validatesUniquenessOf", argumentCollection=arguments);
	</cfscript>
</cffunction>

<!--- PUBLIC MODEL OBJECT METHODS --->

<cffunction name="valid" returntype="boolean" access="public" output="false">
	<cfargument name="callbacks" type="boolean" required="false" default="true">
	<cfscript>
		var loc = {};
		loc.rv = false;
		clearErrors();
		if ($callback("beforeValidation", arguments.callbacks))
		{

<cfscript>
	/*
	* PUBLIC MODEL INITIALIZATION METHODS
	*/

	public void function automaticValidations(required boolean value) {
		variables.wheels.class.automaticValidations = arguments.value;
	}

	public void function validate(
		string methods="",
		string condition="",
		string unless="",
		string when="onSave"
	) {
		$registerValidation(argumentCollection=arguments);
	}

	public void function validateOnCreate(
		string methods="",
		string condition="",
		string unless=""
	) {
		$registerValidation(when="onCreate", argumentCollection=arguments);
	}

	public void function validateOnUpdate(
		string methods="",
		string condition="",
		string unless=""
	) {
		$registerValidation(when="onUpdate", argumentCollection=arguments);
	}

	public void function validatesConfirmationOf(
		string properties="",
		string message,
		string when="onSave",
		string condition="",
		string unless=""
	) {
		$args(name="validatesConfirmationOf", args=arguments);
		$registerValidation(methods="$validatesConfirmationOf", argumentCollection=arguments);
	}

	public void function validatesExclusionOf(
		string properties="",
		required string list,
		string message,
		string when="onSave",
		boolean allowBlank,
		string condition="",
		string unless=""
	) {
		$args(name="validatesExclusionOf", args=arguments);
		arguments.list = $listClean(arguments.list);
		$registerValidation(methods="$validatesExclusionOf", argumentCollection=arguments);
	}

	public void function validatesFormatOf(
		string properties="",
		string regEx="",
		string type="",
		string message,
		string when="onSave",
		boolean allowBlank,
		string condition="",
		string unless=""
	) {
		$args(name="validatesFormatOf", args=arguments);
		if (application.wheels.showErrorInformation)
		{
