diff --git a/Makefile b/Makefile
index 4ef8ce9..d0b36e5 100644
--- a/Makefile
+++ b/Makefile
@@ -16,7 +16,7 @@ clean:
 unittests:
 	@echo "Running unit tests"
 	go clean -testcache
-	go test -v ./...
+	go test -v ./internal/... ./types/...
 
 benchtests: build
 	@echo "Running bench tests"
@@ -32,7 +32,7 @@ build: clean
 endtoendtests: build
 	@echo "Running endtoend tests"
 	find tests/endtoend/ -name 'validator__.go' -exec rm \{} \;
-	cd tests/endtoend/generate_tests/; rm -f numeric_*.go; go run generate_numeric_tests_main.go; mv numeric_*.go ..
+	cd tests/endtoend/generate_tests/; rm -f generated*tests.go; go run *.go; mv generated*tests.go ..
 	$(VALIDGEN_BIN) tests/endtoend
 	cd tests/endtoend; go run .
 
diff --git a/internal/analyzer/analyzer.go b/internal/analyzer/analyzer.go
index 3177a33..211865c 100644
--- a/internal/analyzer/analyzer.go
+++ b/internal/analyzer/analyzer.go
@@ -109,7 +109,7 @@ func checkForInvalidOperations(structs []*Struct) error {
 
 				// Check if is a valid operation for this type.
 				if !ops.IsValidByType(op, fdType.ToNormalizedString()) {
-					return types.NewValidationError("operation %s: invalid %s type", op, fdType.BaseType)
+					return types.NewValidationError("operation %s: invalid %s(%s) type", op, fdType.BaseType, fdType.ToNormalizedString())
 				}
 			}
 		}
diff --git a/internal/analyzer/analyzer_test.go b/internal/analyzer/analyzer_test.go
index 00bd1f1..4767594 100644
--- a/internal/analyzer/analyzer_test.go
+++ b/internal/analyzer/analyzer_test.go
@@ -257,7 +257,7 @@ func TestAnalyzeStructsWithInvalidInnerFieldOperations(t *testing.T) {
 					},
 				},
 			},
-			wantErr: types.NewValidationError("operation ltfield: invalid string type"),
+			wantErr: types.NewValidationError("operation ltfield: invalid string(<STRING>) type"),
 		},
 	}
 
@@ -359,7 +359,7 @@ func TestAnalyzeStructsWithInvalidNestedFieldOperations(t *testing.T) {
 					},
 				},
 			},
-			wantErr: types.NewValidationError("operation ltfield: invalid string type"),
+			wantErr: types.NewValidationError("operation ltfield: invalid string(<STRING>) type"),
 		},
 	}
 
diff --git a/internal/analyzer/operations/operations.go b/internal/analyzer/operations/operations.go
index eca23a4..d93952a 100644
--- a/internal/analyzer/operations/operations.go
+++ b/internal/analyzer/operations/operations.go
@@ -2,6 +2,7 @@ package operations
 
 import (
 	"slices"
+	"strings"
 
 	"github.com/opencodeco/validgen/internal/common"
 )
@@ -29,6 +30,15 @@ func (o *Operations) IsValid(op string) bool {
 }
 
 func (o *Operations) IsValidByType(op, fieldType string) bool {
+	// * is a modifier and can be ignored for type validation.
+	fieldType, pointer := strings.CutPrefix(fieldType, "*")
+
+	// Required can be used with all pointer types.
+	if pointer && op == "required" {
+		// Required can be used with all pointers types.
+		return true
+	}
+
 	return slices.Contains(o.operations[op].ValidTypes, fieldType)
 }
 
diff --git a/internal/analyzer/operations/operations_list.go b/internal/analyzer/operations/operations_list.go
index ea0bc00..5b38611 100644
--- a/internal/analyzer/operations/operations_list.go
+++ b/internal/analyzer/operations/operations_list.go
@@ -11,7 +11,10 @@ var operationsList = map[string]Operation{
 	"required": {
 		CountValues:      common.ZeroValue,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "<INT>", "<FLOAT>", "[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+			"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 	},
 	"gt": {
 		CountValues:      common.OneValue,
@@ -36,12 +39,18 @@ var operationsList = map[string]Operation{
 	"min": {
 		CountValues:      common.OneValue,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+		},
 	},
 	"max": {
 		CountValues:      common.OneValue,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+		},
 	},
 	"eq_ignore_case": {
 		CountValues:      common.OneValue,
@@ -51,7 +60,10 @@ var operationsList = map[string]Operation{
 	"len": {
 		CountValues:      common.OneValue,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+		},
 	},
 	"neq": {
 		CountValues:      common.OneValue,
@@ -66,12 +78,22 @@ var operationsList = map[string]Operation{
 	"in": {
 		CountValues:      common.ManyValues,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "<INT>", "<FLOAT>", "[]<STRING>", "[]<INT>", "[N]<STRING>", "[N]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+			"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"[N]<STRING>", "[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+		},
 	},
 	"nin": {
 		CountValues:      common.ManyValues,
 		IsFieldOperation: false,
-		ValidTypes:       []string{"<STRING>", "<INT>", "<FLOAT>", "[]<STRING>", "[]<INT>", "[N]<STRING>", "[N]<INT>", "map[<STRING>]", "map[<INT>]"},
+		ValidTypes: []string{
+			"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+			"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+			"[N]<STRING>", "[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>",
+			"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+		},
 	},
 	"email": {
 		CountValues:      common.ZeroValue,
diff --git a/internal/analyzer/operations/operations_test.go b/internal/analyzer/operations/operations_test.go
index 49266c1..7153478 100644
--- a/internal/analyzer/operations/operations_test.go
+++ b/internal/analyzer/operations/operations_test.go
@@ -50,355 +50,214 @@ func TestOperationsIsValid(t *testing.T) {
 
 func TestOperationsIsValidByType(t *testing.T) {
 	tests := []struct {
-		fieldType string
-		op        string
-		valid     bool
+		op         string
+		fieldTypes []string
+		valid      bool
 	}{
 		// eq operations
 		{
-			fieldType: "<STRING>",
-			op:        "eq",
-			valid:     true,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "eq",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "eq",
-			valid:     true,
-		},
-		{
-			fieldType: "<BOOL>",
-			op:        "eq",
-			valid:     true,
+			op: "eq",
+			fieldTypes: []string{
+				"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+				"*<STRING>", "*<INT>", "*<FLOAT>", "*<BOOL>",
+			},
+			valid: true,
 		},
 
 		// required operations
 		{
-			fieldType: "<STRING>",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "required",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "required",
-			valid:     true,
+			op: "required",
+			fieldTypes: []string{
+				"<STRING>", "<INT>", "<FLOAT>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<STRING>", "*<INT>", "*<FLOAT>", "*<BOOL>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*[N]<STRING>", "*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// gt operations
 		{
-			fieldType: "<INT>",
-			op:        "gt",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "gt",
-			valid:     true,
+			op: "gt",
+			fieldTypes: []string{
+				"<INT>", "<FLOAT>", "*<INT>", "*<FLOAT>",
+			},
+			valid: true,
 		},
 
 		// gte operations
 		{
-			fieldType: "<INT>",
-			op:        "gte",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "gte",
-			valid:     true,
+			op: "gte",
+			fieldTypes: []string{
+				"<INT>", "<FLOAT>", "*<INT>", "*<FLOAT>",
+			},
+			valid: true,
 		},
 
 		// lt operations
 		{
-			fieldType: "<INT>",
-			op:        "lt",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "lt",
-			valid:     true,
+			op: "lt",
+			fieldTypes: []string{
+				"<INT>", "<FLOAT>", "*<INT>", "*<FLOAT>",
+			},
+			valid: true,
 		},
 
 		// lte operations
 		{
-			fieldType: "<INT>",
-			op:        "lte",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "lte",
-			valid:     true,
+			op: "lte",
+			fieldTypes: []string{
+				"<INT>", "<FLOAT>", "*<INT>", "*<FLOAT>",
+			},
+			valid: true,
 		},
 
 		// min operations
 		{
-			fieldType: "<STRING>",
-			op:        "min",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "min",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "min",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "min",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "min",
-			valid:     true,
+			op: "min",
+			fieldTypes: []string{
+				"<STRING>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<STRING>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// max operations
 		{
-			fieldType: "<STRING>",
-			op:        "max",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "max",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "max",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "max",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "max",
-			valid:     true,
+			op: "max",
+			fieldTypes: []string{
+				"<STRING>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<STRING>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// eq_ignore_case operations
 		{
-			fieldType: "<STRING>",
-			op:        "eq_ignore_case",
-			valid:     true,
+			op: "eq_ignore_case",
+			fieldTypes: []string{
+				"<STRING>",
+				"*<STRING>",
+			},
+			valid: true,
 		},
 
 		// len operations
 		{
-			fieldType: "<STRING>",
-			op:        "len",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "len",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "len",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "len",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "len",
-			valid:     true,
+			op: "len",
+			fieldTypes: []string{
+				"<STRING>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<STRING>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// neq operations
 		{
-			fieldType: "<STRING>",
-			op:        "neq",
-			valid:     true,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "neq",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "neq",
-			valid:     true,
-		},
-		{
-			fieldType: "<BOOL>",
-			op:        "neq",
-			valid:     true,
+			op: "neq",
+			fieldTypes: []string{
+				"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+				"*<STRING>", "*<INT>", "*<FLOAT>", "*<BOOL>",
+			},
+			valid: true,
 		},
 
 		// neq_ignore_case operations
 		{
-			fieldType: "<STRING>",
-			op:        "neq_ignore_case",
-			valid:     true,
+			op: "neq_ignore_case",
+			fieldTypes: []string{
+				"<STRING>",
+				"*<STRING>",
+			},
+			valid: true,
 		},
 
 		// in operations
 		{
-			fieldType: "<STRING>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "[N]<STRING>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "[N]<INT>",
-			op:        "in",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "in",
-			valid:     true,
+			op: "in",
+			fieldTypes: []string{
+				"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"[N]<STRING>", "[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>",
+				"*<STRING>", "*<INT>", "*<FLOAT>", "*<BOOL>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*[N]<STRING>", "*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// nin operations
 		{
-			fieldType: "<STRING>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "<FLOAT>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<STRING>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "[N]<STRING>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<STRING>]",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "[]<INT>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "[N]<INT>",
-			op:        "nin",
-			valid:     true,
-		},
-		{
-			fieldType: "map[<INT>]",
-			op:        "nin",
-			valid:     true,
+			op: "nin",
+			fieldTypes: []string{
+				"<STRING>", "<INT>", "<FLOAT>", "<BOOL>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"[N]<STRING>", "[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>",
+				"*<STRING>", "*<INT>", "*<FLOAT>", "*<BOOL>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*[N]<STRING>", "*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: true,
 		},
 
 		// email operations
 		{
-			fieldType: "<STRING>",
-			op:        "email",
-			valid:     true,
+			op: "email",
+			fieldTypes: []string{
+				"<STRING>",
+				"*<STRING>",
+			},
+			valid: true,
 		},
 
 		// invalid cases
 		{
-			fieldType: "<BOOL>",
-			op:        "email",
-			valid:     false,
-		},
-		{
-			fieldType: "<BOOL>",
-			op:        "gt",
-			valid:     false,
-		},
-		{
-			fieldType: "<INT>",
-			op:        "neq_ignore_case",
-			valid:     false,
-		},
-		{
-			fieldType: "<XPTO>",
-			op:        "neq_ignore_case",
-			valid:     false,
+			op: "email",
+			fieldTypes: []string{
+				"<INT>", "<FLOAT>", "<BOOL>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<INT>", "*<FLOAT>", "*<BOOL>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: false,
+		},
+		{
+			op: "gt",
+			fieldTypes: []string{
+				"<BOOL>",
+				"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>",
+				"map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]",
+				"*<BOOL>",
+				"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>",
+				"*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]",
+			},
+			valid: false,
+		},
+		{
+			op:         "neq_ignore_case",
+			fieldTypes: []string{"<INT>", "<FLOAT>", "<BOOL>", "[]<STRING>", "map[<STRING>]", "<XPTO>", "*<XPTO>"},
+			valid:      false,
 		},
 	}
 
@@ -411,15 +270,17 @@ func TestOperationsIsValidByType(t *testing.T) {
 			testType = "invalid"
 		}
 
-		testName := fmt.Sprintf("%s %s %s", testType, tt.fieldType, tt.op)
+		for _, fieldType := range tt.fieldTypes {
+			testName := fmt.Sprintf("%s %s %s", testType, fieldType, tt.op)
 
-		t.Run(testName, func(t *testing.T) {
-			valid := ops.IsValidByType(tt.op, tt.fieldType)
-			if valid != tt.valid {
-				t.Errorf("IsValidTypeOperation() = %v, want %v", valid, tt.valid)
-				return
-			}
-		})
+			t.Run(testName, func(t *testing.T) {
+				valid := ops.IsValidByType(tt.op, fieldType)
+				if valid != tt.valid {
+					t.Errorf("IsValidTypeOperation() = %v, want %v", valid, tt.valid)
+					return
+				}
+			})
+		}
 	}
 }
 
diff --git a/internal/codegenerator/build_validator_test.go b/internal/codegenerator/build_validator_test.go
index d1a0f7f..c5bfcf6 100644
--- a/internal/codegenerator/build_validator_test.go
+++ b/internal/codegenerator/build_validator_test.go
@@ -1,6 +1,7 @@
 package codegenerator
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/opencodeco/validgen/internal/analyzer"
@@ -350,3 +351,171 @@ errs = append(errs, types.NewValidationError("Field must have at least 2 element
 		})
 	}
 }
+
+func TestBuildValidationCodeWithPointerTypes(t *testing.T) {
+	tests := []struct {
+		fieldType  common.FieldType
+		validation string
+		want       string
+	}{
+		// Pointer basic types.
+		{
+			fieldType:  common.FieldType{BaseType: "string", ComposedType: "*"},
+			validation: "eq=abc",
+			want: `if !(obj.field != nil && *obj.field == "abc") {
+errs = append(errs, types.NewValidationError("field must be equal to 'abc'"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "bool", ComposedType: "*"},
+			validation: "eq=true",
+			want: `if !(obj.field != nil && *obj.field == true) {
+errs = append(errs, types.NewValidationError("field must be equal to true"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "int", ComposedType: "*"},
+			validation: "eq=5",
+			want: `if !(obj.field != nil && *obj.field == 5) {
+errs = append(errs, types.NewValidationError("field must be equal to 5"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "float32", ComposedType: "*"},
+			validation: "eq=5.0",
+			want: `if !(obj.field != nil && *obj.field == 5.0) {
+errs = append(errs, types.NewValidationError("field must be equal to 5.0"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "bool", ComposedType: "*"},
+			validation: "eq=true",
+			want: `if !(obj.field != nil && *obj.field == true) {
+errs = append(errs, types.NewValidationError("field must be equal to true"))
+}
+`,
+		},
+
+		// Slice pointer types.
+		{
+			fieldType:  common.FieldType{BaseType: "string", ComposedType: "*[]"},
+			validation: "required",
+			want: `if !(obj.field != nil && len(*obj.field) != 0) {
+errs = append(errs, types.NewValidationError("field must not be empty"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "int", ComposedType: "*[]"},
+			validation: "min=10",
+			want: `if !(obj.field != nil && len(*obj.field) >= 10) {
+errs = append(errs, types.NewValidationError("field must have at least 10 elements"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "float32", ComposedType: "*[]"},
+			validation: "in=10.0 12.0 14.0",
+			want: `if !(obj.field != nil && types.SliceOnlyContains(*obj.field, []float32{10.0, 12.0, 14.0})) {
+errs = append(errs, types.NewValidationError("field elements must be one of '10.0' '12.0' '14.0'"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "bool", ComposedType: "*[]"},
+			validation: "min=3",
+			want: `if !(obj.field != nil && len(*obj.field) >= 3) {
+errs = append(errs, types.NewValidationError("field must have at least 3 elements"))
+}
+`,
+		},
+
+		// Array pointer types.
+		{
+			fieldType:  common.FieldType{BaseType: "string", ComposedType: "*[N]"},
+			validation: "in=a b c",
+			want: `if !(obj.field != nil && types.SliceOnlyContains(obj.field[:], []string{"a", "b", "c"})) {
+errs = append(errs, types.NewValidationError("field elements must be one of 'a' 'b' 'c'"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "int", ComposedType: "*[N]"},
+			validation: "in=1 2 3",
+			want: `if !(obj.field != nil && types.SliceOnlyContains(obj.field[:], []int{1, 2, 3})) {
+errs = append(errs, types.NewValidationError("field elements must be one of '1' '2' '3'"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "float32", ComposedType: "*[N]"},
+			validation: "in=1.1 2.2 3.3",
+			want: `if !(obj.field != nil && types.SliceOnlyContains(obj.field[:], []float32{1.1, 2.2, 3.3})) {
+errs = append(errs, types.NewValidationError("field elements must be one of '1.1' '2.2' '3.3'"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "bool", ComposedType: "*[N]"},
+			validation: "in=true",
+			want: `if !(obj.field != nil && types.SliceOnlyContains(obj.field[:], []bool{true})) {
+errs = append(errs, types.NewValidationError("field elements must be one of 'true'"))
+}
+`,
+		},
+
+		// Map pointer types.
+		{
+			fieldType:  common.FieldType{BaseType: "string", ComposedType: "*map"},
+			validation: "len=3",
+			want: `if !(obj.field != nil && len(*obj.field) == 3) {
+errs = append(errs, types.NewValidationError("field must have exactly 3 elements"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "int", ComposedType: "*map"},
+			validation: "len=3",
+			want: `if !(obj.field != nil && len(*obj.field) == 3) {
+errs = append(errs, types.NewValidationError("field must have exactly 3 elements"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "float32", ComposedType: "*map"},
+			validation: "len=3",
+			want: `if !(obj.field != nil && len(*obj.field) == 3) {
+errs = append(errs, types.NewValidationError("field must have exactly 3 elements"))
+}
+`,
+		},
+		{
+			fieldType:  common.FieldType{BaseType: "bool", ComposedType: "*map"},
+			validation: "len=3",
+			want: `if !(obj.field != nil && len(*obj.field) == 3) {
+errs = append(errs, types.NewValidationError("field must have exactly 3 elements"))
+}
+`,
+		},
+	}
+
+	for _, tt := range tests {
+		testName := fmt.Sprintf("validation: %s with %s (%s)", tt.validation, tt.fieldType.ToGenericType(), tt.fieldType.ToNormalizedString())
+		t.Run(testName, func(t *testing.T) {
+			gv := genValidations{}
+			validation := AssertParserValidation(t, tt.validation)
+			got, err := gv.buildValidationCode("field", tt.fieldType, []*analyzer.Validation{validation})
+			if err != nil {
+				t.Errorf("buildValidationCode() error = %v, wantErr %v", err, nil)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("buildValidationCode() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/codegenerator/condition_table.go b/internal/codegenerator/condition_table.go
index 9bc8132..71688eb 100644
--- a/internal/codegenerator/condition_table.go
+++ b/internal/codegenerator/condition_table.go
@@ -45,6 +45,22 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be equal to {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} == "{{.Target}}"`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be equal to '{{.Target}}'",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>", "*<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} == {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be equal to {{.Target}}",
+				},
+			},
 		},
 	},
 	"required": {
@@ -66,13 +82,61 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+				AcceptedTypes: []string{"<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != false`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} is required",
+				},
+			},
+			{
+				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `len(obj.{{.Name}}) != 0`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} must not be empty",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} != ""`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} is required",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} != 0`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} is required",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} != false`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} is required",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) != 0`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must not be empty",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[N]<STRING>", "*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must not be empty",
+				},
+			},
 		},
 	},
 	"gte": {
@@ -85,6 +149,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be >= {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} >= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be >= {{.Target}}",
+				},
+			},
 		},
 	},
 	"gt": {
@@ -97,6 +169,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be > {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} > {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be > {{.Target}}",
+				},
+			},
 		},
 	},
 	"lte": {
@@ -109,6 +189,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be <= {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} <= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be <= {{.Target}}",
+				},
+			},
 		},
 	},
 	"lt": {
@@ -121,6 +209,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be < {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} < {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be < {{.Target}}",
+				},
+			},
 		},
 	},
 	"min": {
@@ -134,13 +230,29 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `len(obj.{{.Name}}) >= {{.Target}}`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} must have at least {{.Target}} elements",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) >= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} length must be >= {{.Target}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) >= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must have at least {{.Target}} elements",
+				},
+			},
 		},
 	},
 	"max": {
@@ -154,13 +266,29 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) <= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} length must be <= {{.Target}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `len(obj.{{.Name}}) <= {{.Target}}`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} must have at most {{.Target}} elements",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) <= {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must have at most {{.Target}} elements",
+				},
+			},
 		},
 	},
 	"eq_ignore_case": {
@@ -173,6 +301,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be equal to '{{.Target}}'",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.EqualFold(*obj.{{.Name}}, "{{.Target}}")`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be equal to '{{.Target}}'",
+				},
+			},
 		},
 	},
 	"len": {
@@ -186,13 +322,29 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "map[<STRING>]", "map[<INT>]"},
+				AcceptedTypes: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `len(obj.{{.Name}}) == {{.Target}}`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} must have exactly {{.Target}} elements",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) == {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} length must be {{.Target}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && len(*obj.{{.Name}}) == {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must have exactly {{.Target}} elements",
+				},
+			},
 		},
 	},
 	"neq": {
@@ -213,6 +365,22 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must not be equal to {{.Target}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} != "{{.Target}}"`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must not be equal to '{{.Target}}'",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>", "*<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && *obj.{{.Name}} != {{.Target}}`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must not be equal to {{.Target}}",
+				},
+			},
 		},
 	},
 	"neq_ignore_case": {
@@ -225,6 +393,14 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must not be equal to '{{.Target}}'",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && !types.EqualFold(*obj.{{.Name}}, "{{.Target}}")`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must not be equal to '{{.Target}}'",
+				},
+			},
 		},
 	},
 	"in": {
@@ -238,7 +414,7 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>", "<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} == {{.Target}}`,
 					concatOperator: "||",
@@ -254,23 +430,23 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[N]<STRING>"},
+				AcceptedTypes: []string{"[]<INT>", "[]<FLOAT>", "[]<BOOL>"},
 				ConditionTable: ConditionTable{
-					operation:      `types.SliceOnlyContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
+					operation:      `types.SliceOnlyContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<INT>"},
+				AcceptedTypes: []string{"[N]<STRING>"},
 				ConditionTable: ConditionTable{
-					operation:      `types.SliceOnlyContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					operation:      `types.SliceOnlyContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
 				},
 			},
 			{
-				AcceptedTypes: []string{"[N]<INT>"},
+				AcceptedTypes: []string{"[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `types.SliceOnlyContains(obj.{{.Name}}[:], {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
@@ -286,13 +462,77 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"map[<INT>]"},
+				AcceptedTypes: []string{"map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `types.MapOnlyContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `(obj.{{.Name}} != nil && *obj.{{.Name}} == "{{.Target}}")`,
+					concatOperator: "||",
+					errorMessage:   "{{.Name}} must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>", "*<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `(obj.{{.Name}} != nil && *obj.{{.Name}} == {{.Target}})`,
+					concatOperator: "||",
+					errorMessage:   "{{.Name}} must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceOnlyContains(*obj.{{.Name}}, {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceOnlyContains(*obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[N]<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceOnlyContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceOnlyContains(obj.{{.Name}}[:], {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*map[<STRING>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.MapOnlyContains(*obj.{{.Name}}, {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.MapOnlyContains(*obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must be one of {{.Targets}}",
+				},
+			},
 		},
 	},
 	"nin": {
@@ -306,7 +546,7 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>", "<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} != {{.Target}}`,
 					concatOperator: "&&",
@@ -322,23 +562,23 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"[N]<STRING>"},
+				AcceptedTypes: []string{"[]<INT>", "[]<FLOAT>", "[]<BOOL>"},
 				ConditionTable: ConditionTable{
-					operation:      `types.SliceNotContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
+					operation:      `types.SliceNotContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
 				},
 			},
 			{
-				AcceptedTypes: []string{"[]<INT>"},
+				AcceptedTypes: []string{"[N]<STRING>"},
 				ConditionTable: ConditionTable{
-					operation:      `types.SliceNotContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					operation:      `types.SliceNotContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
 				},
 			},
 			{
-				AcceptedTypes: []string{"[N]<INT>"},
+				AcceptedTypes: []string{"[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `types.SliceNotContains(obj.{{.Name}}[:], {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
@@ -354,13 +594,77 @@ var conditionTable = map[string]Operation{
 				},
 			},
 			{
-				AcceptedTypes: []string{"map[<INT>]"},
+				AcceptedTypes: []string{"map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
 				ConditionTable: ConditionTable{
 					operation:      `types.MapNotContains(obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
 					concatOperator: "",
 					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `(obj.{{.Name}} != nil && *obj.{{.Name}} != "{{.Target}}")`,
+					concatOperator: "&&",
+					errorMessage:   "{{.Name}} must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*<INT>", "*<FLOAT>", "*<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `(obj.{{.Name}} != nil && *obj.{{.Name}} != {{.Target}})`,
+					concatOperator: "&&",
+					errorMessage:   "{{.Name}} must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceNotContains(*obj.{{.Name}}, {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceNotContains(*obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[N]<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceNotContains(obj.{{.Name}}[:], {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.SliceNotContains(obj.{{.Name}}[:], {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*map[<STRING>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.MapNotContains(*obj.{{.Name}}, {{.TargetsAsStringSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
+			{
+				AcceptedTypes: []string{"*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.MapNotContains(*obj.{{.Name}}, {{.TargetsAsNumericSlice}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} elements must not be one of {{.Targets}}",
+				},
+			},
 		},
 	},
 	"email": {
@@ -373,12 +677,20 @@ var conditionTable = map[string]Operation{
 					errorMessage:   "{{.Name}} must be a valid email",
 				},
 			},
+			{
+				AcceptedTypes: []string{"*<STRING>"},
+				ConditionTable: ConditionTable{
+					operation:      `obj.{{.Name}} != nil && types.IsValidEmail(*obj.{{.Name}})`,
+					concatOperator: "",
+					errorMessage:   "{{.Name}} must be a valid email",
+				},
+			},
 		},
 	},
 	"eqfield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<STRING>", "<INT>", "<BOOL>"},
+				AcceptedTypes: []string{"<STRING>", "<INT>", "<FLOAT>", "<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} == obj.{{.Target}}`,
 					concatOperator: "",
@@ -390,7 +702,7 @@ var conditionTable = map[string]Operation{
 	"neqfield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<STRING>", "<INT>", "<BOOL>"},
+				AcceptedTypes: []string{"<STRING>", "<INT>", "<FLOAT>", "<BOOL>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} != obj.{{.Target}}`,
 					concatOperator: "",
@@ -402,7 +714,7 @@ var conditionTable = map[string]Operation{
 	"gtefield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<INT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} >= obj.{{.Target}}`,
 					concatOperator: "",
@@ -414,7 +726,7 @@ var conditionTable = map[string]Operation{
 	"gtfield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<INT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} > obj.{{.Target}}`,
 					concatOperator: "",
@@ -426,7 +738,7 @@ var conditionTable = map[string]Operation{
 	"ltefield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<INT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} <= obj.{{.Target}}`,
 					concatOperator: "",
@@ -438,7 +750,7 @@ var conditionTable = map[string]Operation{
 	"ltfield": {
 		ConditionByTypes: []ConditionByType{
 			{
-				AcceptedTypes: []string{"<INT>"},
+				AcceptedTypes: []string{"<INT>", "<FLOAT>"},
 				ConditionTable: ConditionTable{
 					operation:      `obj.{{.Name}} < obj.{{.Target}}`,
 					concatOperator: "",
@@ -455,11 +767,12 @@ func GetConditionTable(operation string, fieldType common.FieldType) (ConditionT
 		return ConditionTable{}, types.NewValidationError("INTERNAL ERROR: unsupported operation %s", operation)
 	}
 
+	normalizedType := fieldType.ToNormalizedString()
 	for _, conditionByType := range op.ConditionByTypes {
-		if slices.Contains(conditionByType.AcceptedTypes, fieldType.ToNormalizedString()) {
+		if slices.Contains(conditionByType.AcceptedTypes, normalizedType) {
 			return conditionByType.ConditionTable, nil
 		}
 	}
 
-	return ConditionTable{}, types.NewValidationError("INTERNAL ERROR: unsupported operation %s type %s", operation, fieldType.BaseType)
+	return ConditionTable{}, types.NewValidationError("INTERNAL ERROR: unsupported operation %s type %s (%s)", operation, normalizedType, fieldType.BaseType)
 }
diff --git a/internal/codegenerator/get_test_elements_all_types_test.go b/internal/codegenerator/get_test_elements_all_types_test.go
new file mode 100644
index 0000000..8590870
--- /dev/null
+++ b/internal/codegenerator/get_test_elements_all_types_test.go
@@ -0,0 +1,1189 @@
+package codegenerator
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/opencodeco/validgen/internal/common"
+)
+
+func TestDefineTestElementsWithAllTypes(t *testing.T) {
+	type check struct {
+		types []string
+		value string
+		want  TestElements
+	}
+	tests := []struct {
+		validation string
+		checks     []check
+	}{
+		// required
+		{
+			validation: "required",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != ""`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"<INT>", "<FLOAT>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != 0`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"<BOOL>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != false`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
+					want: TestElements{
+						conditions:     []string{`len(obj.field) != 0`},
+						concatOperator: "",
+						errorMessage:   "field must not be empty",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != ""`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"*<INT>", "*<FLOAT>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != 0`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"*<BOOL>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != false`},
+						concatOperator: "",
+						errorMessage:   "field is required",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) != 0`},
+						concatOperator: "",
+						errorMessage:   "field must not be empty",
+					},
+				},
+				{
+					types: []string{"*[N]<STRING>", "*[N]<INT>", "*[N]<FLOAT>", "*[N]<BOOL>"},
+					want: TestElements{
+						conditions:     []string{`obj.field != nil`},
+						concatOperator: "",
+						errorMessage:   "field must not be empty",
+					},
+				},
+			},
+		},
+
+		// email
+		{
+			validation: "email",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					want: TestElements{
+						conditions:     []string{`types.IsValidEmail(obj.field)`},
+						concatOperator: "",
+						errorMessage:   "field must be a valid email",
+					},
+				},
+			},
+		},
+
+		// eq
+		{
+			validation: "eq={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field == "abc"`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field == 123`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field == 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 123.45",
+					},
+				},
+				{
+					types: []string{"<BOOL>"},
+					value: "true",
+					want: TestElements{
+						conditions:     []string{`obj.field == true`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to true",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field == "abc"`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field == 123`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 123",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field == 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 123.45",
+					},
+				},
+				{
+					types: []string{"*<BOOL>"},
+					value: "true",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field == true`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to true",
+					},
+				},
+			},
+		},
+
+		// neq
+		{
+			validation: "neq={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field != "abc"`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != 123`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 123.45",
+					},
+				},
+				{
+					types: []string{"<BOOL>"},
+					value: "true",
+					want: TestElements{
+						conditions:     []string{`obj.field != true`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to true",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != "abc"`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != 123`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 123",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 123.45",
+					},
+				},
+				{
+					types: []string{"*<BOOL>"},
+					value: "true",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field != true`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to true",
+					},
+				},
+			},
+		},
+
+		// eq_ignore_case
+		{
+			validation: "eq_ignore_case={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`types.EqualFold(obj.field, "abc")`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.EqualFold(*obj.field, "abc")`},
+						concatOperator: "",
+						errorMessage:   "field must be equal to 'abc'",
+					},
+				},
+			},
+		},
+
+		// neq_ignore_case
+		{
+			validation: "neq_ignore_case={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`!types.EqualFold(obj.field, "abc")`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 'abc'",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && !types.EqualFold(*obj.field, "abc")`},
+						concatOperator: "",
+						errorMessage:   "field must not be equal to 'abc'",
+					},
+				},
+			},
+		},
+
+		// gt
+		{
+			validation: "gt={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field > 123`},
+						concatOperator: "",
+						errorMessage:   "field must be > 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field > 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be > 123.45",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field > 123`},
+						concatOperator: "",
+						errorMessage:   "field must be > 123",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field > 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be > 123.45",
+					},
+				},
+			},
+		},
+
+		// gte
+		{
+			validation: "gte={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field >= 123`},
+						concatOperator: "",
+						errorMessage:   "field must be >= 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field >= 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be >= 123.45",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field >= 123`},
+						concatOperator: "",
+						errorMessage:   "field must be >= 123",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field >= 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be >= 123.45",
+					},
+				},
+			},
+		},
+
+		// lt
+		{
+			validation: "lt={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field < 123`},
+						concatOperator: "",
+						errorMessage:   "field must be < 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field < 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be < 123.45",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field < 123`},
+						concatOperator: "",
+						errorMessage:   "field must be < 123",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field < 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be < 123.45",
+					},
+				},
+			},
+		},
+
+		// lte
+		{
+			validation: "lte={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<INT>"},
+					value: "123",
+					want: TestElements{
+						conditions:     []string{`obj.field <= 123`},
+						concatOperator: "",
+						errorMessage:   "field must be <= 123",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field <= 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be <= 123.45",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field <= 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be <= 123.45",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "123.45",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && *obj.field <= 123.45`},
+						concatOperator: "",
+						errorMessage:   "field must be <= 123.45",
+					},
+				},
+			},
+		},
+
+		// len
+		{
+			validation: "len={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "8",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) == 8`},
+						concatOperator: "",
+						errorMessage:   "field length must be 8",
+					},
+				},
+				{
+					types: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
+					value: "5",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) == 5`},
+						concatOperator: "",
+						errorMessage:   "field must have exactly 5 elements",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "8",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) == 8`},
+						concatOperator: "",
+						errorMessage:   "field length must be 8",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+					value: "5",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) == 5`},
+						concatOperator: "",
+						errorMessage:   "field must have exactly 5 elements",
+					},
+				},
+			},
+		},
+
+		// min
+		{
+			validation: "min={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "8",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) >= 8`},
+						concatOperator: "",
+						errorMessage:   "field length must be >= 8",
+					},
+				},
+				{
+					types: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
+					value: "5",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) >= 5`},
+						concatOperator: "",
+						errorMessage:   "field must have at least 5 elements",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "8",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) >= 8`},
+						concatOperator: "",
+						errorMessage:   "field length must be >= 8",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+					value: "5",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) >= 5`},
+						concatOperator: "",
+						errorMessage:   "field must have at least 5 elements",
+					},
+				},
+			},
+		},
+
+		// max
+		{
+			validation: "max={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "20",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) <= 20`},
+						concatOperator: "",
+						errorMessage:   "field length must be <= 20",
+					},
+				},
+				{
+					types: []string{"[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>", "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"},
+					value: "50",
+					want: TestElements{
+						conditions:     []string{`len(obj.field) <= 50`},
+						concatOperator: "",
+						errorMessage:   "field must have at most 50 elements",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "20",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) <= 20`},
+						concatOperator: "",
+						errorMessage:   "field length must be <= 20",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>", "*[]<INT>", "*[]<FLOAT>", "*[]<BOOL>", "*map[<STRING>]", "*map[<INT>]", "*map[<FLOAT>]", "*map[<BOOL>]"},
+					value: "50",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && len(*obj.field) <= 50`},
+						concatOperator: "",
+						errorMessage:   "field must have at most 50 elements",
+					},
+				},
+			},
+		},
+
+		// in
+		{
+			validation: "in={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field == "abc"`, `obj.field == "def"`, `obj.field == "ghi"`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field == 123`, `obj.field == 456`, `obj.field == 789`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field == 1.23`, `obj.field == 4.56`, `obj.field == 7.89`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field == true`, `obj.field == false`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"[]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`types.SliceOnlyContains(obj.field, []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"[]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`types.SliceOnlyContains(obj.field, []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"[]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`types.SliceOnlyContains(obj.field, []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"[]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`types.SliceOnlyContains(obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"map[<STRING>]"},
+					value: "key1,key2,key3",
+					want: TestElements{
+						conditions:     []string{`types.MapOnlyContains(obj.field, []string{"key1", "key2", "key3"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'key1' 'key2' 'key3'",
+					},
+				},
+				{
+					types: []string{"map[<INT>]"},
+					value: "1,2,3",
+					want: TestElements{
+						conditions:     []string{`types.MapOnlyContains(obj.field, []{{.BaseType}}{1, 2, 3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1' '2' '3'",
+					},
+				},
+				{
+					types: []string{"map[<FLOAT>]"},
+					value: "1.1,2.2,3.3",
+					want: TestElements{
+						conditions:     []string{`types.MapOnlyContains(obj.field, []{{.BaseType}}{1.1, 2.2, 3.3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1.1' '2.2' '3.3'",
+					},
+				},
+				{
+					types: []string{"map[<BOOL>]"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`types.MapOnlyContains(obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field == "abc")`, `(obj.field != nil && *obj.field == "def")`, `(obj.field != nil && *obj.field == "ghi")`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field == 123)`, `(obj.field != nil && *obj.field == 456)`, `(obj.field != nil && *obj.field == 789)`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field == 1.23)`, `(obj.field != nil && *obj.field == 4.56)`, `(obj.field != nil && *obj.field == 7.89)`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field == true)`, `(obj.field != nil && *obj.field == false)`},
+						concatOperator: "||",
+						errorMessage:   "field must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(*obj.field, []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*[]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(*obj.field, []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*[]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(*obj.field, []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*[]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(*obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*[N]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(obj.field[:], []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*[N]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(obj.field[:], []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*[N]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(obj.field[:], []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*[N]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceOnlyContains(obj.field[:], []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*map[<STRING>]"},
+					value: "key1,key2,key3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapOnlyContains(*obj.field, []string{"key1", "key2", "key3"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'key1' 'key2' 'key3'",
+					},
+				},
+				{
+					types: []string{"*map[<INT>]"},
+					value: "1,2,3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapOnlyContains(*obj.field, []{{.BaseType}}{1, 2, 3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1' '2' '3'",
+					},
+				},
+				{
+					types: []string{"*map[<FLOAT>]"},
+					value: "1.1,2.2,3.3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapOnlyContains(*obj.field, []{{.BaseType}}{1.1, 2.2, 3.3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of '1.1' '2.2' '3.3'",
+					},
+				},
+				{
+					types: []string{"*map[<BOOL>]"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapOnlyContains(*obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must be one of 'true' 'false'",
+					},
+				},
+			},
+		},
+
+		// nin
+		{
+			validation: "nin={{.Value}}",
+			checks: []check{
+				{
+					types: []string{"<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field != "abc"`, `obj.field != "def"`, `obj.field != "ghi"`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field != 123`, `obj.field != 456`, `obj.field != 789`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field != 1.23`, `obj.field != 4.56`, `obj.field != 7.89`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != true`, `obj.field != false`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"[]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`types.SliceNotContains(obj.field, []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"[]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`types.SliceNotContains(obj.field, []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"[]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`types.SliceNotContains(obj.field, []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"[]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`types.SliceNotContains(obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"map[<STRING>]"},
+					value: "key1,key2,key3",
+					want: TestElements{
+						conditions:     []string{`types.MapNotContains(obj.field, []string{"key1", "key2", "key3"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'key1' 'key2' 'key3'",
+					},
+				},
+				{
+					types: []string{"map[<INT>]"},
+					value: "1,2,3",
+					want: TestElements{
+						conditions:     []string{`types.MapNotContains(obj.field, []{{.BaseType}}{1, 2, 3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1' '2' '3'",
+					},
+				},
+				{
+					types: []string{"map[<FLOAT>]"},
+					value: "1.1,2.2,3.3",
+					want: TestElements{
+						conditions:     []string{`types.MapNotContains(obj.field, []{{.BaseType}}{1.1, 2.2, 3.3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1.1' '2.2' '3.3'",
+					},
+				},
+				{
+					types: []string{"map[<BOOL>]"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`types.MapNotContains(obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field != "abc")`, `(obj.field != nil && *obj.field != "def")`, `(obj.field != nil && *obj.field != "ghi")`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field != 123)`, `(obj.field != nil && *obj.field != 456)`, `(obj.field != nil && *obj.field != 789)`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field != 1.23)`, `(obj.field != nil && *obj.field != 4.56)`, `(obj.field != nil && *obj.field != 7.89)`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`(obj.field != nil && *obj.field != true)`, `(obj.field != nil && *obj.field != false)`},
+						concatOperator: "&&",
+						errorMessage:   "field must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*[]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(*obj.field, []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*[]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(*obj.field, []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*[]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(*obj.field, []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*[]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(*obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*[N]<STRING>"},
+					value: "abc,def,ghi",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(obj.field[:], []string{"abc", "def", "ghi"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'abc' 'def' 'ghi'",
+					},
+				},
+				{
+					types: []string{"*[N]<INT>"},
+					value: "123,456,789",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(obj.field[:], []{{.BaseType}}{123, 456, 789})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '123' '456' '789'",
+					},
+				},
+				{
+					types: []string{"*[N]<FLOAT>"},
+					value: "1.23,4.56,7.89",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(obj.field[:], []{{.BaseType}}{1.23, 4.56, 7.89})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1.23' '4.56' '7.89'",
+					},
+				},
+				{
+					types: []string{"*[N]<BOOL>"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.SliceNotContains(obj.field[:], []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'true' 'false'",
+					},
+				},
+				{
+					types: []string{"*map[<STRING>]"},
+					value: "key1,key2,key3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapNotContains(*obj.field, []string{"key1", "key2", "key3"})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'key1' 'key2' 'key3'",
+					},
+				},
+				{
+					types: []string{"*map[<INT>]"},
+					value: "1,2,3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapNotContains(*obj.field, []{{.BaseType}}{1, 2, 3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1' '2' '3'",
+					},
+				},
+				{
+					types: []string{"*map[<FLOAT>]"},
+					value: "1.1,2.2,3.3",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapNotContains(*obj.field, []{{.BaseType}}{1.1, 2.2, 3.3})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of '1.1' '2.2' '3.3'",
+					},
+				},
+				{
+					types: []string{"*map[<BOOL>]"},
+					value: "true,false",
+					want: TestElements{
+						conditions:     []string{`obj.field != nil && types.MapNotContains(*obj.field, []bool{true, false})`},
+						concatOperator: "",
+						errorMessage:   "field elements must not be one of 'true' 'false'",
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		for _, check := range tt.checks {
+			for _, acceptedType := range check.types {
+				fieldTypes, err := common.HelperFromNormalizedToFieldTypes(acceptedType)
+				if err != nil {
+					t.Errorf("HelperFromNormalizedToFieldTypes() error = %v", err)
+					return
+				}
+				for _, fieldType := range fieldTypes {
+					// op, _, _ := strings.Cut(tt.validation, "=")
+					validation := replaceValidationValue(tt.validation, check.value)
+					want := TestElements{
+						concatOperator: check.want.concatOperator,
+						errorMessage:   check.want.errorMessage,
+					}
+					want.conditions = make([]string, len(check.want.conditions))
+					copy(want.conditions, check.want.conditions)
+
+					for i := range want.conditions {
+						want.conditions[i] = strings.ReplaceAll(want.conditions[i], "{{.BaseType}}", fieldType.BaseType)
+					}
+
+					testName := fmt.Sprintf("validation(%s) type(%s)", validation, fieldType)
+					t.Run(testName, func(t *testing.T) {
+						validation := AssertParserValidation(t, validation)
+						got, err := DefineTestElements("field", fieldType, validation)
+						if err != nil {
+							t.Errorf("DefineTestElements() error = %v", err)
+							return
+						}
+						if !reflect.DeepEqual(got, want) {
+							t.Errorf("DefineTestElements() = %+v, want %+v", got, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func replaceValidationValue(text, value string) string {
+
+	text = strings.ReplaceAll(text, "{{.Value}}", value)
+
+	return text
+}
diff --git a/internal/codegenerator/get_test_elements_array_test.go b/internal/codegenerator/get_test_elements_array_test.go
index a4a1902..188f003 100644
--- a/internal/codegenerator/get_test_elements_array_test.go
+++ b/internal/codegenerator/get_test_elements_array_test.go
@@ -9,7 +9,6 @@ import (
 
 func TestDefineTestElementsWithArrayFields(t *testing.T) {
 	type args struct {
-		fieldName       string
 		fieldType       common.FieldType
 		fieldValidation string
 	}
@@ -21,7 +20,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "In array string with spaces",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "string", ComposedType: "[N]"},
 				fieldValidation: "in=a b c",
 			},
@@ -34,7 +32,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "In array string with '",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "string", ComposedType: "[N]"},
 				fieldValidation: "in=' a ' ' b ' ' c '",
 			},
@@ -47,7 +44,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "Not in array string with spaces",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "string", ComposedType: "[N]"},
 				fieldValidation: "nin=a b c",
 			},
@@ -60,7 +56,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "Not in array string with '",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "string", ComposedType: "[N]"},
 				fieldValidation: "nin=' a ' ' b ' ' c '",
 			},
@@ -73,7 +68,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "In array int",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "uint8", ComposedType: "[N]"},
 				fieldValidation: "in=1 2 3",
 			},
@@ -86,7 +80,6 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 		{
 			name: "Not in array int",
 			args: args{
-				fieldName:       "myfield",
 				fieldType:       common.FieldType{BaseType: "uint8", ComposedType: "[N]"},
 				fieldValidation: "nin=1 2 3",
 			},
@@ -96,13 +89,63 @@ func TestDefineTestElementsWithArrayFields(t *testing.T) {
 				errorMessage:   "myfield elements must not be one of '1' '2' '3'",
 			},
 		},
+
+		// Pointer types.
+		{
+			name: "In pointer array string",
+			args: args{
+				fieldType:       common.FieldType{BaseType: "string", ComposedType: "*[N]"},
+				fieldValidation: "in=a b c",
+			},
+			want: TestElements{
+				conditions:     []string{`obj.myfield != nil && types.SliceOnlyContains(obj.myfield[:], []string{"a", "b", "c"})`},
+				concatOperator: "",
+				errorMessage:   "myfield elements must be one of 'a' 'b' 'c'",
+			},
+		},
+		{
+			name: "Not in pointer array string",
+			args: args{
+				fieldType:       common.FieldType{BaseType: "string", ComposedType: "*[N]"},
+				fieldValidation: "nin=a b c",
+			},
+			want: TestElements{
+				conditions:     []string{`obj.myfield != nil && types.SliceNotContains(obj.myfield[:], []string{"a", "b", "c"})`},
+				concatOperator: "",
+				errorMessage:   "myfield elements must not be one of 'a' 'b' 'c'",
+			},
+		},
+		{
+			name: "In pointer array int",
+			args: args{
+				fieldType:       common.FieldType{BaseType: "uint8", ComposedType: "*[N]"},
+				fieldValidation: "in=1 2 3",
+			},
+			want: TestElements{
+				conditions:     []string{`obj.myfield != nil && types.SliceOnlyContains(obj.myfield[:], []uint8{1, 2, 3})`},
+				concatOperator: "",
+				errorMessage:   "myfield elements must be one of '1' '2' '3'",
+			},
+		},
+		{
+			name: "Not in pointer array int",
+			args: args{
+				fieldType:       common.FieldType{BaseType: "uint8", ComposedType: "*[N]"},
+				fieldValidation: "nin=1 2 3",
+			},
+			want: TestElements{
+				conditions:     []string{`obj.myfield != nil && types.SliceNotContains(obj.myfield[:], []uint8{1, 2, 3})`},
+				concatOperator: "",
+				errorMessage:   "myfield elements must not be one of '1' '2' '3'",
+			},
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			wantErr := false
 			validation := AssertParserValidation(t, tt.args.fieldValidation)
-			got, err := DefineTestElements(tt.args.fieldName, tt.args.fieldType, validation)
+			got, err := DefineTestElements("myfield", tt.args.fieldType, validation)
 			if (err != nil) != wantErr {
 				t.Errorf("DefineTestElements() error = %v, wantErr %v", err, wantErr)
 				return
diff --git a/internal/codegenerator/get_test_elements_between_fields_test.go b/internal/codegenerator/get_test_elements_between_fields_test.go
index 1ec8225..5380316 100644
--- a/internal/codegenerator/get_test_elements_between_fields_test.go
+++ b/internal/codegenerator/get_test_elements_between_fields_test.go
@@ -18,6 +18,7 @@ func TestDefineTestElementsBetweenInnerFields(t *testing.T) {
 		args args
 		want TestElements
 	}{
+		// <STRING>
 		{
 			name: "inner string fields must be equal",
 			args: args{
@@ -44,6 +45,8 @@ func TestDefineTestElementsBetweenInnerFields(t *testing.T) {
 				errorMessage:   "myfield1 must not be equal to myfield2",
 			},
 		},
+
+		// <INT>
 		{
 			name: "inner uint8 fields must be equal",
 			args: args{
@@ -123,6 +126,7 @@ func TestDefineTestElementsBetweenInnerFields(t *testing.T) {
 			},
 		},
 
+		// <BOOL>
 		{
 			name: "inner bool fields must be equal",
 			args: args{
diff --git a/internal/codegenerator/get_test_elements_errors_test.go b/internal/codegenerator/get_test_elements_errors_test.go
index ea1cd84..7affbd4 100644
--- a/internal/codegenerator/get_test_elements_errors_test.go
+++ b/internal/codegenerator/get_test_elements_errors_test.go
@@ -26,7 +26,7 @@ func TestDefineTestElementsWithInvalidOperations(t *testing.T) {
 				fieldType:       common.FieldType{BaseType: "uint8"},
 				fieldValidation: "min=1 2 3",
 			},
-			expectedErr: types.NewValidationError("INTERNAL ERROR: unsupported operation min type uint8"),
+			expectedErr: types.NewValidationError("INTERNAL ERROR: unsupported operation min type <INT> (uint8)"),
 		},
 	}
 
diff --git a/internal/codegenerator/get_test_elements_pointer_test.go b/internal/codegenerator/get_test_elements_pointer_test.go
new file mode 100644
index 0000000..6ea6d1a
--- /dev/null
+++ b/internal/codegenerator/get_test_elements_pointer_test.go
@@ -0,0 +1,112 @@
+package codegenerator
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/opencodeco/validgen/internal/common"
+)
+
+func TestDefineTestElementsWithStringPointerFields(t *testing.T) {
+	tests := []struct {
+		validation string
+		want       TestElements
+	}{
+		{
+			validation: "eq=abc",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && *obj.Field == "abc"`},
+				errorMessage: "Field must be equal to 'abc'",
+			},
+		},
+		{
+			validation: "required",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && *obj.Field != ""`},
+				errorMessage: "Field is required",
+			},
+		},
+		{
+			validation: "min=5",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && len(*obj.Field) >= 5`},
+				errorMessage: "Field length must be >= 5",
+			},
+		},
+		{
+			validation: "max=10",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && len(*obj.Field) <= 10`},
+				errorMessage: "Field length must be <= 10",
+			},
+		},
+		{
+			validation: "eq_ignore_case=AbC",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && types.EqualFold(*obj.Field, "AbC")`},
+				errorMessage: "Field must be equal to 'AbC'",
+			},
+		},
+		{
+			validation: "len=8",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && len(*obj.Field) == 8`},
+				errorMessage: "Field length must be 8",
+			},
+		},
+		{
+			validation: "neq=abc",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && *obj.Field != "abc"`},
+				errorMessage: "Field must not be equal to 'abc'",
+			},
+		},
+		{
+			validation: "neq_ignore_case=AbC",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && !types.EqualFold(*obj.Field, "AbC")`},
+				errorMessage: "Field must not be equal to 'AbC'",
+			},
+		},
+		{
+			validation: "in=a b c",
+			want: TestElements{
+				conditions:     []string{`(obj.Field != nil && *obj.Field == "a")`, `(obj.Field != nil && *obj.Field == "b")`, `(obj.Field != nil && *obj.Field == "c")`},
+				concatOperator: "||",
+				errorMessage:   "Field must be one of 'a' 'b' 'c'",
+			},
+		},
+		{
+			validation: "nin=a b c",
+			want: TestElements{
+				conditions:     []string{`(obj.Field != nil && *obj.Field != "a")`, `(obj.Field != nil && *obj.Field != "b")`, `(obj.Field != nil && *obj.Field != "c")`},
+				concatOperator: "&&",
+				errorMessage:   "Field must not be one of 'a' 'b' 'c'",
+			},
+		},
+		{
+			validation: "email",
+			want: TestElements{
+				conditions:   []string{`obj.Field != nil && types.IsValidEmail(*obj.Field)`},
+				errorMessage: "Field must be a valid email",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		testName := fmt.Sprintf("validation: %s with *string", tt.validation)
+		t.Run(testName, func(t *testing.T) {
+			fieldType := common.FieldType{BaseType: "string", ComposedType: "*"}
+			validation := AssertParserValidation(t, tt.validation)
+			got, err := DefineTestElements("Field", fieldType, validation)
+			if err != nil {
+				t.Errorf("DefineTestElements() error = %v, wantErr %v", err, nil)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("DefineTestElements() = %+v, want %+v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/common/field_type.go b/internal/common/field_type.go
index 9a6623c..6230caf 100644
--- a/internal/common/field_type.go
+++ b/internal/common/field_type.go
@@ -1,6 +1,11 @@
 package common
 
-import "fmt"
+import (
+	"fmt"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
 
 type FieldType struct {
 	ComposedType string // array ([N]), map (map) or slice ([])
@@ -9,7 +14,7 @@ type FieldType struct {
 }
 
 func (ft FieldType) IsGoType() bool {
-	if ft.ComposedType == "map" {
+	if ft.ComposedType == "map" || ft.ComposedType == "*map" {
 		return true
 	}
 
@@ -78,7 +83,15 @@ func (ft FieldType) ToType() string {
 	case "[]":
 		return "[]" + ft.BaseType
 	case "map":
-		return "map[" + ft.BaseType + "]"
+		return "map[" + ft.BaseType + "]" + ft.BaseType
+	case "*":
+		return "*" + ft.BaseType
+	case "*[N]":
+		return fmt.Sprintf("*[%s]%s", ft.Size, ft.BaseType)
+	case "*[]":
+		return "*[]" + ft.BaseType
+	case "*map":
+		return "*map[" + ft.BaseType + "]" + ft.BaseType
 	}
 
 	return ft.BaseType
@@ -92,7 +105,38 @@ func (ft FieldType) ToNormalizedString() string {
 		return "[]" + ft.NormalizeBaseType().String()
 	case "map":
 		return "map[" + ft.NormalizeBaseType().String() + "]"
+	case "*[N]":
+		return "*[N]" + ft.NormalizeBaseType().String()
+	case "*[]":
+		return "*[]" + ft.NormalizeBaseType().String()
+	case "*map":
+		return "*map[" + ft.NormalizeBaseType().String() + "]"
+	case "*":
+		return "*" + ft.NormalizeBaseType().String()
 	}
 
 	return ft.NormalizeBaseType().String()
 }
+
+func (ft FieldType) ToStringName() string {
+	result := ""
+
+	switch ft.ComposedType {
+	case "[N]":
+		result = "Array"
+	case "[]":
+		result = "Slice"
+	case "map":
+		result = "Map"
+	case "*[N]":
+		result = "ArrayPointer"
+	case "*[]":
+		result = "SlicePointer"
+	case "*map":
+		result = "MapPointer"
+	case "*":
+		result = "Pointer"
+	}
+
+	return cases.Title(language.Und).String(ft.BaseType) + result
+}
diff --git a/internal/common/field_type_test.go b/internal/common/field_type_test.go
index 05bf396..e335985 100644
--- a/internal/common/field_type_test.go
+++ b/internal/common/field_type_test.go
@@ -167,7 +167,7 @@ func TestFieldTypeIsGoType(t *testing.T) {
 	}
 }
 
-func TestFieldType_NormalizeBaseType(t *testing.T) {
+func TestFieldTypeNormalizeBaseType(t *testing.T) {
 	type fields struct {
 		BaseType string
 	}
@@ -295,3 +295,333 @@ func TestFieldType_NormalizeBaseType(t *testing.T) {
 		})
 	}
 }
+
+func TestFieldTypeToStringName(t *testing.T) {
+	type fields struct {
+		ComposedType string
+		BaseType     string
+		Size         string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		// Base types.
+		{
+			name: "string type",
+			fields: fields{
+				ComposedType: "",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "String",
+		},
+		{
+			name: "int type",
+			fields: fields{
+				ComposedType: "",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "Int",
+		},
+		{
+			name: "float64 type",
+			fields: fields{
+				ComposedType: "",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64",
+		},
+		{
+			name: "bool type",
+			fields: fields{
+				ComposedType: "",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "Bool",
+		},
+
+		// Array type.
+		{
+			name: "array string type",
+			fields: fields{
+				ComposedType: "[N]",
+				BaseType:     "string",
+				Size:         "5",
+			},
+			want: "StringArray",
+		},
+		{
+			name: "array int type",
+			fields: fields{
+				ComposedType: "[N]",
+				BaseType:     "int",
+				Size:         "5",
+			},
+			want: "IntArray",
+		},
+		{
+			name: "array float type",
+			fields: fields{
+				ComposedType: "[N]",
+				BaseType:     "float64",
+				Size:         "5",
+			},
+			want: "Float64Array",
+		},
+		{
+			name: "array bool type",
+			fields: fields{
+				ComposedType: "[N]",
+				BaseType:     "bool",
+				Size:         "5",
+			},
+			want: "BoolArray",
+		},
+
+		// Slice type.
+		{
+			name: "slice string type",
+			fields: fields{
+				ComposedType: "[]",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "StringSlice",
+		},
+		{
+			name: "slice int type",
+			fields: fields{
+				ComposedType: "[]",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "IntSlice",
+		},
+		{
+			name: "slice float type",
+			fields: fields{
+				ComposedType: "[]",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64Slice",
+		},
+		{
+			name: "slice bool type",
+			fields: fields{
+				ComposedType: "[]",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "BoolSlice",
+		},
+
+		// Map type.
+		{
+			name: "map string type",
+			fields: fields{
+				ComposedType: "map",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "StringMap",
+		},
+		{
+			name: "map int type",
+			fields: fields{
+				ComposedType: "map",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "IntMap",
+		},
+		{
+			name: "map float type",
+			fields: fields{
+				ComposedType: "map",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64Map",
+		},
+		{
+			name: "map bool type",
+			fields: fields{
+				ComposedType: "map",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "BoolMap",
+		},
+
+		// Base pointer types.
+		{
+			name: "string pointer type",
+			fields: fields{
+				ComposedType: "*",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "StringPointer",
+		},
+		{
+			name: "int pointer type",
+			fields: fields{
+				ComposedType: "*",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "IntPointer",
+		},
+		{
+			name: "float64 pointer type",
+			fields: fields{
+				ComposedType: "*",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64Pointer",
+		},
+		{
+			name: "bool pointer type",
+			fields: fields{
+				ComposedType: "*",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "BoolPointer",
+		},
+
+		// Array pointer type.
+		{
+			name: "array string pointer type",
+			fields: fields{
+				ComposedType: "*[N]",
+				BaseType:     "string",
+				Size:         "5",
+			},
+			want: "StringArrayPointer",
+		},
+		{
+			name: "array int pointer type",
+			fields: fields{
+				ComposedType: "*[N]",
+				BaseType:     "int",
+				Size:         "5",
+			},
+			want: "IntArrayPointer",
+		},
+		{
+			name: "array float pointer type",
+			fields: fields{
+				ComposedType: "*[N]",
+				BaseType:     "float64",
+				Size:         "5",
+			},
+			want: "Float64ArrayPointer",
+		},
+		{
+			name: "array bool pointer type",
+			fields: fields{
+				ComposedType: "*[N]",
+				BaseType:     "bool",
+				Size:         "5",
+			},
+			want: "BoolArrayPointer",
+		},
+
+		// Slice pointer type.
+		{
+			name: "slice string pointer type",
+			fields: fields{
+				ComposedType: "*[]",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "StringSlicePointer",
+		},
+		{
+			name: "slice int pointer type",
+			fields: fields{
+				ComposedType: "*[]",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "IntSlicePointer",
+		},
+		{
+			name: "slice float pointer type",
+			fields: fields{
+				ComposedType: "*[]",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64SlicePointer",
+		},
+		{
+			name: "slice bool pointer type",
+			fields: fields{
+				ComposedType: "*[]",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "BoolSlicePointer",
+		},
+
+		// Map type.
+		{
+			name: "map string pointer type",
+			fields: fields{
+				ComposedType: "*map",
+				BaseType:     "string",
+				Size:         "",
+			},
+			want: "StringMapPointer",
+		},
+		{
+			name: "map int pointer type",
+			fields: fields{
+				ComposedType: "*map",
+				BaseType:     "int",
+				Size:         "",
+			},
+			want: "IntMapPointer",
+		},
+		{
+			name: "map float pointer type",
+			fields: fields{
+				ComposedType: "*map",
+				BaseType:     "float64",
+				Size:         "",
+			},
+			want: "Float64MapPointer",
+		},
+		{
+			name: "map bool pointer type",
+			fields: fields{
+				ComposedType: "*map",
+				BaseType:     "bool",
+				Size:         "",
+			},
+			want: "BoolMapPointer",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ft := FieldType{
+				ComposedType: tt.fields.ComposedType,
+				BaseType:     tt.fields.BaseType,
+				Size:         tt.fields.Size,
+			}
+			if got := ft.ToStringName(); got != tt.want {
+				t.Errorf("FieldType.ToStringName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/common/helpers.go b/internal/common/helpers.go
index 340192b..11ad0c2 100644
--- a/internal/common/helpers.go
+++ b/internal/common/helpers.go
@@ -20,14 +20,30 @@ func HelperFromNormalizedToBasicTypes(t string) []string {
 	return result
 }
 
+func HelperFromNormalizedToStringNames(t string) []string {
+	fieldTypes, err := HelperFromNormalizedToFieldTypes(t)
+	if err != nil {
+		return []string{"invalid"}
+	}
+
+	result := []string{}
+	for _, ft := range fieldTypes {
+		result = append(result, ft.ToStringName())
+	}
+
+	return result
+}
+
 func HelperFromNormalizedToFieldTypes(t string) ([]FieldType, error) {
+	fieldTypes := []FieldType{}
+	t, isPointer := strings.CutPrefix(t, "*")
 	switch t {
 	case "<STRING>":
-		return []FieldType{{BaseType: "string"}}, nil
+		fieldTypes = []FieldType{{BaseType: "string"}}
 	case "<BOOL>":
-		return []FieldType{{BaseType: "bool"}}, nil
+		fieldTypes = []FieldType{{BaseType: "bool"}}
 	case "<INT>":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "int"},
 			{BaseType: "int8"},
 			{BaseType: "int16"},
@@ -38,18 +54,18 @@ func HelperFromNormalizedToFieldTypes(t string) ([]FieldType, error) {
 			{BaseType: "uint16"},
 			{BaseType: "uint32"},
 			{BaseType: "uint64"},
-		}, nil
+		}
 	case "<FLOAT>":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "float32"},
 			{BaseType: "float64"},
-		}, nil
+		}
 	case "map[<STRING>]":
-		return []FieldType{{BaseType: "string", ComposedType: "map"}}, nil
+		fieldTypes = []FieldType{{BaseType: "string", ComposedType: "map"}}
 	case "map[<BOOL>]":
-		return []FieldType{{BaseType: "bool", ComposedType: "map"}}, nil
+		fieldTypes = []FieldType{{BaseType: "bool", ComposedType: "map"}}
 	case "map[<INT>]":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "int", ComposedType: "map"},
 			{BaseType: "int8", ComposedType: "map"},
 			{BaseType: "int16", ComposedType: "map"},
@@ -60,18 +76,18 @@ func HelperFromNormalizedToFieldTypes(t string) ([]FieldType, error) {
 			{BaseType: "uint16", ComposedType: "map"},
 			{BaseType: "uint32", ComposedType: "map"},
 			{BaseType: "uint64", ComposedType: "map"},
-		}, nil
+		}
 	case "map[<FLOAT>]":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "float32", ComposedType: "map"},
 			{BaseType: "float64", ComposedType: "map"},
-		}, nil
+		}
 	case "[]<STRING>":
-		return []FieldType{{BaseType: "string", ComposedType: "[]"}}, nil
+		fieldTypes = []FieldType{{BaseType: "string", ComposedType: "[]"}}
 	case "[]<BOOL>":
-		return []FieldType{{BaseType: "bool", ComposedType: "[]"}}, nil
+		fieldTypes = []FieldType{{BaseType: "bool", ComposedType: "[]"}}
 	case "[]<INT>":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "int", ComposedType: "[]"},
 			{BaseType: "int8", ComposedType: "[]"},
 			{BaseType: "int16", ComposedType: "[]"},
@@ -82,49 +98,43 @@ func HelperFromNormalizedToFieldTypes(t string) ([]FieldType, error) {
 			{BaseType: "uint16", ComposedType: "[]"},
 			{BaseType: "uint32", ComposedType: "[]"},
 			{BaseType: "uint64", ComposedType: "[]"},
-		}, nil
+		}
 	case "[]<FLOAT>":
-		return []FieldType{
+		fieldTypes = []FieldType{
 			{BaseType: "float32", ComposedType: "[]"},
 			{BaseType: "float64", ComposedType: "[]"},
-		}, nil
-	}
-
-	// Try to remove [N] (array size)
-	if len(t) > 0 && t[0] == '[' {
-		closeBracketIndex := strings.Index(t, "]")
-		if closeBracketIndex == -1 {
-			return nil, types.NewValidationError("invalid array size %s", t)
 		}
+	case "[N]<STRING>":
+		fieldTypes = []FieldType{{BaseType: "string", ComposedType: "[N]", Size: "3"}}
+	case "[N]<BOOL>":
+		fieldTypes = []FieldType{{BaseType: "bool", ComposedType: "[N]", Size: "3"}}
+	case "[N]<INT>":
+		fieldTypes = []FieldType{
+			{BaseType: "int", ComposedType: "[N]", Size: "3"},
+			{BaseType: "int8", ComposedType: "[N]", Size: "3"},
+			{BaseType: "int16", ComposedType: "[N]", Size: "3"},
+			{BaseType: "int32", ComposedType: "[N]", Size: "3"},
+			{BaseType: "int64", ComposedType: "[N]", Size: "3"},
+			{BaseType: "uint", ComposedType: "[N]", Size: "3"},
+			{BaseType: "uint8", ComposedType: "[N]", Size: "3"},
+			{BaseType: "uint16", ComposedType: "[N]", Size: "3"},
+			{BaseType: "uint32", ComposedType: "[N]", Size: "3"},
+			{BaseType: "uint64", ComposedType: "[N]", Size: "3"},
+		}
+	case "[N]<FLOAT>":
+		fieldTypes = []FieldType{
+			{BaseType: "float32", ComposedType: "[N]", Size: "3"},
+			{BaseType: "float64", ComposedType: "[N]", Size: "3"},
+		}
+	}
 
-		size := t[1:closeBracketIndex]
-		basicType := t[closeBracketIndex+1:]
-		switch basicType {
-		case "<STRING>":
-			return []FieldType{{BaseType: "string", ComposedType: "[N]", Size: size}}, nil
-		case "<BOOL>":
-			return []FieldType{{BaseType: "bool", ComposedType: "[N]", Size: size}}, nil
-		case "<INT>":
-			return []FieldType{
-				{BaseType: "int", ComposedType: "[N]", Size: size},
-				{BaseType: "int8", ComposedType: "[N]", Size: size},
-				{BaseType: "int16", ComposedType: "[N]", Size: size},
-				{BaseType: "int32", ComposedType: "[N]", Size: size},
-				{BaseType: "int64", ComposedType: "[N]", Size: size},
-				{BaseType: "uint", ComposedType: "[N]", Size: size},
-				{BaseType: "uint8", ComposedType: "[N]", Size: size},
-				{BaseType: "uint16", ComposedType: "[N]", Size: size},
-				{BaseType: "uint32", ComposedType: "[N]", Size: size},
-				{BaseType: "uint64", ComposedType: "[N]", Size: size},
-			}, nil
-		case "<FLOAT>":
-			return []FieldType{
-				{BaseType: "float32", ComposedType: "[N]", Size: size},
-				{BaseType: "float64", ComposedType: "[N]", Size: size},
-			}, nil
-		default:
-			return nil, types.NewValidationError("invalid array base type %s", basicType)
+	if len(fieldTypes) > 0 {
+		if isPointer {
+			for i := range fieldTypes {
+				fieldTypes[i].ComposedType = "*" + fieldTypes[i].ComposedType
+			}
 		}
+		return fieldTypes, nil
 	}
 
 	return nil, types.NewValidationError("unknown normalized type %s", t)
diff --git a/internal/common/helpers_test.go b/internal/common/helpers_test.go
index 0b82221..a5c44f2 100644
--- a/internal/common/helpers_test.go
+++ b/internal/common/helpers_test.go
@@ -17,6 +17,7 @@ func TestFromNormalizedToBasicTypes(t *testing.T) {
 		args args
 		want []string
 	}{
+		// Without pointer.
 		{
 			name: "string type",
 			args: args{t: "<STRING>"},
@@ -40,22 +41,22 @@ func TestFromNormalizedToBasicTypes(t *testing.T) {
 		{
 			name: "map string type",
 			args: args{t: "map[<STRING>]"},
-			want: []string{"map[string]"},
+			want: []string{"map[string]string"},
 		},
 		{
 			name: "map bool type",
 			args: args{t: "map[<BOOL>]"},
-			want: []string{"map[bool]"},
+			want: []string{"map[bool]bool"},
 		},
 		{
 			name: "map int type",
 			args: args{t: "map[<INT>]"},
-			want: []string{"map[int]", "map[int8]", "map[int16]", "map[int32]", "map[int64]", "map[uint]", "map[uint8]", "map[uint16]", "map[uint32]", "map[uint64]"},
+			want: []string{"map[int]int", "map[int8]int8", "map[int16]int16", "map[int32]int32", "map[int64]int64", "map[uint]uint", "map[uint8]uint8", "map[uint16]uint16", "map[uint32]uint32", "map[uint64]uint64"},
 		},
 		{
 			name: "map float type",
 			args: args{t: "map[<FLOAT>]"},
-			want: []string{"map[float32]", "map[float64]"},
+			want: []string{"map[float32]float32", "map[float64]float64"},
 		},
 		{
 			name: "slice string type",
@@ -79,24 +80,108 @@ func TestFromNormalizedToBasicTypes(t *testing.T) {
 		},
 		{
 			name: "array string type",
-			args: args{t: "[3]<STRING>"},
+			args: args{t: "[N]<STRING>"},
 			want: []string{"[3]string"},
 		},
 		{
 			name: "array bool type",
-			args: args{t: "[3]<BOOL>"},
+			args: args{t: "[N]<BOOL>"},
 			want: []string{"[3]bool"},
 		},
 		{
 			name: "array int type",
-			args: args{t: "[3]<INT>"},
+			args: args{t: "[N]<INT>"},
 			want: []string{"[3]int", "[3]int8", "[3]int16", "[3]int32", "[3]int64", "[3]uint", "[3]uint8", "[3]uint16", "[3]uint32", "[3]uint64"},
 		},
 		{
 			name: "array float type",
-			args: args{t: "[3]<FLOAT>"},
+			args: args{t: "[N]<FLOAT>"},
 			want: []string{"[3]float32", "[3]float64"},
 		},
+
+		// With pointer.
+		{
+			name: "pointer string type",
+			args: args{t: "*<STRING>"},
+			want: []string{"*string"},
+		},
+		{
+			name: "pointer bool type",
+			args: args{t: "*<BOOL>"},
+			want: []string{"*bool"},
+		},
+		{
+			name: "pointer int type",
+			args: args{t: "*<INT>"},
+			want: []string{"*int", "*int8", "*int16", "*int32", "*int64", "*uint", "*uint8", "*uint16", "*uint32", "*uint64"},
+		},
+		{
+			name: "pointer float type",
+			args: args{t: "*<FLOAT>"},
+			want: []string{"*float32", "*float64"},
+		},
+		{
+			name: "pointer map string type",
+			args: args{t: "*map[<STRING>]"},
+			want: []string{"*map[string]string"},
+		},
+		{
+			name: "pointer map bool type",
+			args: args{t: "*map[<BOOL>]"},
+			want: []string{"*map[bool]bool"},
+		},
+		{
+			name: "pointer map int type",
+			args: args{t: "*map[<INT>]"},
+			want: []string{"*map[int]int", "*map[int8]int8", "*map[int16]int16", "*map[int32]int32", "*map[int64]int64", "*map[uint]uint", "*map[uint8]uint8", "*map[uint16]uint16", "*map[uint32]uint32", "*map[uint64]uint64"},
+		},
+		{
+			name: "pointer map float type",
+			args: args{t: "*map[<FLOAT>]"},
+			want: []string{"*map[float32]float32", "*map[float64]float64"},
+		},
+		{
+			name: "pointer slice string type",
+			args: args{t: "*[]<STRING>"},
+			want: []string{"*[]string"},
+		},
+		{
+			name: "pointer slice bool type",
+			args: args{t: "*[]<BOOL>"},
+			want: []string{"*[]bool"},
+		},
+		{
+			name: "pointer slice int type",
+			args: args{t: "*[]<INT>"},
+			want: []string{"*[]int", "*[]int8", "*[]int16", "*[]int32", "*[]int64", "*[]uint", "*[]uint8", "*[]uint16", "*[]uint32", "*[]uint64"},
+		},
+		{
+			name: "pointer slice float type",
+			args: args{t: "*[]<FLOAT>"},
+			want: []string{"*[]float32", "*[]float64"},
+		},
+		{
+			name: "pointer array string type",
+			args: args{t: "*[N]<STRING>"},
+			want: []string{"*[3]string"},
+		},
+		{
+			name: "pointer array bool type",
+			args: args{t: "*[N]<BOOL>"},
+			want: []string{"*[3]bool"},
+		},
+		{
+			name: "pointer array int type",
+			args: args{t: "*[N]<INT>"},
+			want: []string{"*[3]int", "*[3]int8", "*[3]int16", "*[3]int32", "*[3]int64", "*[3]uint", "*[3]uint8", "*[3]uint16", "*[3]uint32", "*[3]uint64"},
+		},
+		{
+			name: "pointer array float type",
+			args: args{t: "*[N]<FLOAT>"},
+			want: []string{"*[3]float32", "*[3]float64"},
+		},
+
+		// Invalid type.
 		{
 			name: "invalid type",
 			args: args{t: "<INVALID>"},
@@ -120,6 +205,7 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 		want           []FieldType
 		err            error
 	}{
+		// Without pointer.
 		{
 			"string type",
 			"<STRING>",
@@ -247,7 +333,7 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 		},
 		{
 			"array string type",
-			"[3]<STRING>",
+			"[N]<STRING>",
 			[]FieldType{
 				{BaseType: "string", ComposedType: "[N]", Size: "3"},
 			},
@@ -255,7 +341,7 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 		},
 		{
 			"array bool type",
-			"[3]<BOOL>",
+			"[N]<BOOL>",
 			[]FieldType{
 				{BaseType: "bool", ComposedType: "[N]", Size: "3"},
 			},
@@ -263,7 +349,7 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 		},
 		{
 			"array int type",
-			"[3]<INT>",
+			"[N]<INT>",
 			[]FieldType{
 				{BaseType: "int", ComposedType: "[N]", Size: "3"},
 				{BaseType: "int8", ComposedType: "[N]", Size: "3"},
@@ -280,13 +366,185 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 		},
 		{
 			"array float type",
-			"[3]<FLOAT>",
+			"[N]<FLOAT>",
 			[]FieldType{
 				{BaseType: "float32", ComposedType: "[N]", Size: "3"},
 				{BaseType: "float64", ComposedType: "[N]", Size: "3"},
 			},
 			nil,
 		},
+
+		// With pointer.
+		{
+			"pointer string type",
+			"*<STRING>",
+			[]FieldType{
+				{BaseType: "string", ComposedType: "*", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer bool type",
+			"*<BOOL>",
+			[]FieldType{
+				{BaseType: "bool", ComposedType: "*", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer int type",
+			"*<INT>",
+			[]FieldType{
+				{BaseType: "int", ComposedType: "*", Size: ""},
+				{BaseType: "int8", ComposedType: "*", Size: ""},
+				{BaseType: "int16", ComposedType: "*", Size: ""},
+				{BaseType: "int32", ComposedType: "*", Size: ""},
+				{BaseType: "int64", ComposedType: "*", Size: ""},
+				{BaseType: "uint", ComposedType: "*", Size: ""},
+				{BaseType: "uint8", ComposedType: "*", Size: ""},
+				{BaseType: "uint16", ComposedType: "*", Size: ""},
+				{BaseType: "uint32", ComposedType: "*", Size: ""},
+				{BaseType: "uint64", ComposedType: "*", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer float type",
+			"*<FLOAT>",
+			[]FieldType{
+				{BaseType: "float32", ComposedType: "*", Size: ""},
+				{BaseType: "float64", ComposedType: "*", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer map string type",
+			"*map[<STRING>]",
+			[]FieldType{
+				{BaseType: "string", ComposedType: "*map", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer map bool type",
+			"*map[<BOOL>]",
+			[]FieldType{
+				{BaseType: "bool", ComposedType: "*map", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer map int type",
+			"*map[<INT>]",
+			[]FieldType{
+				{BaseType: "int", ComposedType: "*map", Size: ""},
+				{BaseType: "int8", ComposedType: "*map", Size: ""},
+				{BaseType: "int16", ComposedType: "*map", Size: ""},
+				{BaseType: "int32", ComposedType: "*map", Size: ""},
+				{BaseType: "int64", ComposedType: "*map", Size: ""},
+				{BaseType: "uint", ComposedType: "*map", Size: ""},
+				{BaseType: "uint8", ComposedType: "*map", Size: ""},
+				{BaseType: "uint16", ComposedType: "*map", Size: ""},
+				{BaseType: "uint32", ComposedType: "*map", Size: ""},
+				{BaseType: "uint64", ComposedType: "*map", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer map float type",
+			"*map[<FLOAT>]",
+			[]FieldType{
+				{BaseType: "float32", ComposedType: "*map", Size: ""},
+				{BaseType: "float64", ComposedType: "*map", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer slice string type",
+			"*[]<STRING>",
+			[]FieldType{
+				{BaseType: "string", ComposedType: "*[]", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer slice bool type",
+			"*[]<BOOL>",
+			[]FieldType{
+				{BaseType: "bool", ComposedType: "*[]", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer slice int type",
+			"*[]<INT>",
+			[]FieldType{
+				{BaseType: "int", ComposedType: "*[]", Size: ""},
+				{BaseType: "int8", ComposedType: "*[]", Size: ""},
+				{BaseType: "int16", ComposedType: "*[]", Size: ""},
+				{BaseType: "int32", ComposedType: "*[]", Size: ""},
+				{BaseType: "int64", ComposedType: "*[]", Size: ""},
+				{BaseType: "uint", ComposedType: "*[]", Size: ""},
+				{BaseType: "uint8", ComposedType: "*[]", Size: ""},
+				{BaseType: "uint16", ComposedType: "*[]", Size: ""},
+				{BaseType: "uint32", ComposedType: "*[]", Size: ""},
+				{BaseType: "uint64", ComposedType: "*[]", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer slice float type",
+			"*[]<FLOAT>",
+			[]FieldType{
+				{BaseType: "float32", ComposedType: "*[]", Size: ""},
+				{BaseType: "float64", ComposedType: "*[]", Size: ""},
+			},
+			nil,
+		},
+		{
+			"pointer array string type",
+			"*[N]<STRING>",
+			[]FieldType{
+				{BaseType: "string", ComposedType: "*[N]", Size: "3"},
+			},
+			nil,
+		},
+		{
+			"pointer array bool type",
+			"*[N]<BOOL>",
+			[]FieldType{
+				{BaseType: "bool", ComposedType: "*[N]", Size: "3"},
+			},
+			nil,
+		},
+		{
+			"pointer array int type",
+			"*[N]<INT>",
+			[]FieldType{
+				{BaseType: "int", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "int8", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "int16", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "int32", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "int64", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "uint", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "uint8", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "uint16", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "uint32", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "uint64", ComposedType: "*[N]", Size: "3"},
+			},
+			nil,
+		},
+		{
+			"pointer array float type",
+			"*[N]<FLOAT>",
+			[]FieldType{
+				{BaseType: "float32", ComposedType: "*[N]", Size: "3"},
+				{BaseType: "float64", ComposedType: "*[N]", Size: "3"},
+			},
+			nil,
+		},
+
+		// Invalid types.
 		{
 			"invalid type",
 			"<XPTO>",
@@ -297,13 +555,13 @@ func TestFromNormalizedToFieldTypes(t *testing.T) {
 			"invalid array type",
 			"[3]<XPTO>",
 			nil,
-			types.NewValidationError("invalid array base type <XPTO>"),
+			types.NewValidationError("unknown normalized type [3]<XPTO>"),
 		},
 		{
 			"malformed array type",
 			"[3)<STRING>",
 			nil,
-			types.NewValidationError("invalid array size [3)<STRING>"),
+			types.NewValidationError("unknown normalized type [3)<STRING>"),
 		},
 	}
 
diff --git a/internal/parser/parser.go b/internal/parser/parser.go
index a18d193..e0b22e1 100644
--- a/internal/parser/parser.go
+++ b/internal/parser/parser.go
@@ -99,7 +99,7 @@ func parseStructs(fullpath, src string) ([]*Struct, error) {
 		case (*ast.TypeSpec):
 			currentStruct = extractStructDefinition(v.Name.Name, fullpath, packageName, imports)
 		case (*ast.StructType):
-			err = appendFields(v, packageName, currentStruct)
+			err = extractAndAppendStructFields(v, packageName, currentStruct)
 			if err != nil {
 				return false
 			}
@@ -145,70 +145,28 @@ func extractStructDefinition(name, fullpath, packageName string, imports map[str
 	}
 }
 
-func appendFields(structType *ast.StructType, packageName string, cstruct *Struct) error {
+func extractAndAppendStructFields(structType *ast.StructType, packageName string, cstruct *Struct) error {
 	if structType.Fields == nil {
 		return nil
 	}
 
 	for _, field := range structType.Fields.List {
-		appendFieldNames := false
-		fieldType := common.FieldType{}
 		fieldTag := ""
 		if field.Tag != nil {
 			fieldTag = field.Tag.Value
 		}
 
-		switch v := field.Type.(type) {
-		case *ast.Ident:
-			fieldType.BaseType = v.Name
-			fieldType, fieldTag = extractFieldTypeAndTag(packageName, fieldType, fieldTag)
-			appendFieldNames = true
-
-		case *ast.ArrayType:
-			fieldType.ComposedType = "[]"
-			ident, ok := v.Elt.(*ast.Ident)
-			if !ok {
-				return fmt.Errorf("cannot find the identifier: %T", v.Elt)
-			}
-
-			fieldType.BaseType = ident.Name
-			fieldType.Size = ""
-			if v.Len != nil {
-				// Array with fixed size
-				basicLit, ok := v.Len.(*ast.BasicLit)
-				if !ok {
-					return fmt.Errorf("cannot find the basic literal: %T", v.Len)
-				}
-
-				fieldType.Size = basicLit.Value
-				fieldType.ComposedType = "[N]"
-			}
-			fieldType, fieldTag = extractFieldTypeAndTag(packageName, fieldType, fieldTag)
-			appendFieldNames = true
-
-		case *ast.SelectorExpr:
-			ident, ok := v.X.(*ast.Ident)
-			if !ok {
-				return fmt.Errorf("cannot find the identifier: %T", v.X)
-			}
-
-			nestedPkgName := ident.Name
-			fieldType, fieldTag = extractNestedFieldTypeAndTag(nestedPkgName, v.Sel.Name, fieldTag)
-			appendFieldNames = true
-
-		case *ast.MapType:
-			ident, ok := v.Key.(*ast.Ident)
-			if !ok {
-				return fmt.Errorf("cannot find the identifier: %T", v.Key)
-			}
+		fieldTag, err := extractTag(fieldTag)
+		if err != nil {
+			return err
+		}
 
-			fieldType.ComposedType = "map"
-			fieldType.BaseType = ident.Name
-			_, fieldTag = extractFieldTypeAndTag(packageName, fieldType, fieldTag)
-			appendFieldNames = true
+		fieldType, err := extractCompleteType(common.FieldType{}, field.Type, packageName)
+		if err != nil {
+			return err
 		}
 
-		if appendFieldNames {
+		if fieldType.BaseType != "" {
 			for _, name := range field.Names {
 				cstruct.Fields = append(cstruct.Fields, Field{
 					FieldName: name.Name,
@@ -222,29 +180,91 @@ func appendFields(structType *ast.StructType, packageName string, cstruct *Struc
 	return nil
 }
 
-func extractFieldTypeAndTag(packageName string, fieldType common.FieldType, fieldTag string) (common.FieldType, string) {
-	rFieldType := fieldType
+func extractCompleteType(fType common.FieldType, expr ast.Expr, packageName string) (common.FieldType, error) {
+	var err error
+
+	switch v := expr.(type) {
+	case *ast.Ident:
+		// Single type (string, int, etc.)
+		fType.BaseType = v.Name
+		if !fType.IsGoType() {
+			fType.BaseType = common.KeyPath(packageName, fType.BaseType)
+		}
+		return fType, nil
+	case *ast.ArrayType:
+		// Slice or array type
+		fType, err = extractCompleteType(fType, v.Elt, packageName)
+		if err != nil {
+			return common.FieldType{}, err
+		}
 
-	if !fieldType.IsGoType() {
-		rFieldType.BaseType = common.KeyPath(packageName, fieldType.BaseType)
+		fType.Size = ""
+		if v.Len != nil {
+			// Array with fixed size
+			basicLit, ok := v.Len.(*ast.BasicLit)
+			if !ok {
+				return common.FieldType{}, fmt.Errorf("cannot find the basic literal: %T", v.Len)
+			}
+
+			fType.Size = basicLit.Value
+			fType.ComposedType += "[N]"
+		} else {
+			fType.ComposedType += "[]"
+		}
+		return fType, nil
+	case *ast.SelectorExpr:
+		// Nested type from another package
+		typeID, ok := v.X.(*ast.Ident)
+		if !ok {
+			return common.FieldType{}, fmt.Errorf("cannot find the type id: %T", v.X)
+		}
+
+		nestedPkgName := typeID.Name
+		fType = extractNestedFieldType(nestedPkgName, v.Sel.Name)
+		return fType, nil
+
+	case *ast.MapType:
+		// Map type
+		fType.ComposedType += "map"
+		fType, err = extractCompleteType(fType, v.Key, packageName)
+		if err != nil {
+			return common.FieldType{}, err
+		}
+
+		return fType, nil
+	case *ast.StarExpr:
+		// Pointer type
+		fType.ComposedType += "*"
+		fType, err = extractCompleteType(fType, v.X, packageName)
+		if err != nil {
+			return common.FieldType{}, err
+		}
+
+		return fType, nil
+	}
+
+	return common.FieldType{}, nil
+}
+
+func extractTag(fieldTag string) (string, error) {
+
+	if fieldTag == "" {
+		return "", nil
 	}
 
-	rFieldTag := ""
-	if fieldTag != "" {
-		rFieldTag = fieldTag
-		rFieldTag, _ = strconv.Unquote(rFieldTag)
+	rFieldTag, err := strconv.Unquote(fieldTag)
+	if err != nil {
+		return "", err
 	}
 
-	return rFieldType, rFieldTag
+	return rFieldTag, nil
 }
 
-func extractNestedFieldTypeAndTag(nestedPkgName, baseType, fieldTag string) (common.FieldType, string) {
-	rFieldType := common.KeyPath(nestedPkgName, baseType)
-	rFieldTag, _ := strconv.Unquote(fieldTag)
+func extractNestedFieldType(nestedPkgName, baseType string) common.FieldType {
 
 	return common.FieldType{
-		BaseType:     rFieldType,
+		BaseType:     common.KeyPath(nestedPkgName, baseType),
 		ComposedType: "",
 		Size:         "",
-	}, rFieldTag
+	}
 }
diff --git a/internal/parser/parser_test.go b/internal/parser/parser_test.go
index b9e4266..b91d1bf 100644
--- a/internal/parser/parser_test.go
+++ b/internal/parser/parser_test.go
@@ -505,6 +505,65 @@ func TestParseStructsOk(t *testing.T) {
 				},
 			},
 		},
+
+		{
+			name: "Pointers type",
+			args: args{
+				fullpath: "example/main.go",
+				src: "package main\n" +
+					"type AllTypes struct {\n" +
+					"	StringPointer   *string          `valid:\"eq=abc\"`\n" +
+					"	IntPointer      *int64           `valid:\"neq=1234\"`\n" +
+					"	BoolPointer     *bool            `valid:\"eq=true\"`\n" +
+					"	MapPointer      *map[string]bool `valid:\"min=2\"`\n" +
+					"	SliceIntPointer []*int64 `valid:\"min=2\"`\n" +
+					"	ArrayIntPointer [5]*int64 `valid:\"max=4\"`\n" +
+					"}\n" +
+
+					"func main() {\n" +
+					"}\n",
+			},
+			want: []*Struct{
+				{
+					StructName:  "AllTypes",
+					Path:        "./example",
+					PackageName: "main",
+					Fields: []Field{
+						{
+							FieldName: "StringPointer",
+							Type:      common.FieldType{BaseType: "string", ComposedType: "*", Size: ""},
+							Tag:       "valid:\"eq=abc\"",
+						},
+						{
+							FieldName: "IntPointer",
+							Type:      common.FieldType{BaseType: "int64", ComposedType: "*", Size: ""},
+							Tag:       "valid:\"neq=1234\"",
+						},
+						{
+							FieldName: "BoolPointer",
+							Type:      common.FieldType{BaseType: "bool", ComposedType: "*", Size: ""},
+							Tag:       "valid:\"eq=true\"",
+						},
+						{
+							FieldName: "MapPointer",
+							Type:      common.FieldType{BaseType: "string", ComposedType: "*map", Size: ""},
+							Tag:       "valid:\"min=2\"",
+						},
+						{
+							FieldName: "SliceIntPointer",
+							Type:      common.FieldType{BaseType: "int64", ComposedType: "*[]", Size: ""},
+							Tag:       "valid:\"min=2\"",
+						},
+						{
+							FieldName: "ArrayIntPointer",
+							Type:      common.FieldType{BaseType: "int64", ComposedType: "*[5]", Size: ""},
+							Tag:       "valid:\"max=4\"",
+						},
+					},
+					Imports: map[string]Import{},
+				},
+			},
+		},
 	}
 
 	for _, tt := range tests {
diff --git a/tests/endtoend/generate_tests/generate_numeric_tests_main.go b/tests/endtoend/generate_tests/generate_numeric_tests.go
similarity index 71%
rename from tests/endtoend/generate_tests/generate_numeric_tests_main.go
rename to tests/endtoend/generate_tests/generate_numeric_tests.go
index 7491f71..6c10b1c 100644
--- a/tests/endtoend/generate_tests/generate_numeric_tests_main.go
+++ b/tests/endtoend/generate_tests/generate_numeric_tests.go
@@ -16,21 +16,21 @@ type NumericTests struct {
 	FieldTypes []string
 }
 
-func main() {
-	log.Println("Generating numeric test file")
+func generateNumericTests() {
+	log.Println("Generating numeric test files")
 
 	numericTests := NumericTests{}
 	numericTests.FieldTypes = common.HelperFromNormalizedToBasicTypes("<INT>")
 
-	if err := numericTests.GenerateFile("numeric_int.tpl", "./numeric_int.go"); err != nil {
-		log.Fatalf("error generation numeric int file %s", err)
+	if err := numericTests.GenerateFile("numeric_int.tpl", "./generated_numeric_int_tests.go"); err != nil {
+		log.Fatalf("error generating numeric int file %s", err)
 	}
 
 	numericTests = NumericTests{}
 	numericTests.FieldTypes = common.HelperFromNormalizedToBasicTypes("<FLOAT>")
 
-	if err := numericTests.GenerateFile("numeric_float.tpl", "./numeric_float.go"); err != nil {
-		log.Fatalf("error generation numeric float file %s", err)
+	if err := numericTests.GenerateFile("numeric_float.tpl", "./generated_numeric_float_tests.go"); err != nil {
+		log.Fatalf("error generating numeric float file %s", err)
 	}
 
 	log.Println("Generating done")
diff --git a/tests/endtoend/generate_tests/generate_tests.go b/tests/endtoend/generate_tests/generate_tests.go
new file mode 100644
index 0000000..da1d2c0
--- /dev/null
+++ b/tests/endtoend/generate_tests/generate_tests.go
@@ -0,0 +1,14 @@
+package main
+
+import (
+	"log"
+)
+
+func main() {
+	log.Println("Generating tests files")
+
+	generateNumericTests()
+	generateTestCases()
+
+	log.Println("Generating done")
+}
diff --git a/tests/endtoend/generate_tests/generate_usecase_tests.go b/tests/endtoend/generate_tests/generate_usecase_tests.go
new file mode 100644
index 0000000..16a63e2
--- /dev/null
+++ b/tests/endtoend/generate_tests/generate_usecase_tests.go
@@ -0,0 +1,947 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"log"
+	"os"
+	"strings"
+	"text/template"
+
+	"github.com/opencodeco/validgen/internal/common"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+type testCase struct {
+	validation     string
+	normalizedType string
+	validCase      string
+	invalidCase    string
+	errorMessage   string
+	generateOnly   string
+}
+
+var testCases = []struct {
+	operation string
+	testCases []testCase
+}{
+	// email operations
+	{
+		operation: "email",
+		testCases: []testCase{
+			{
+				// email: "<STRING>"
+				validation:     `email`,
+				normalizedType: `<STRING>`,
+				validCase:      `"abcde@example.com"`,
+				invalidCase:    `"abcde@example"`,
+				errorMessage:   `{{.FieldName}} must be a valid email`,
+			},
+		},
+	},
+
+	// required operations
+	{
+		operation: "required",
+		testCases: []testCase{
+			// required: "<STRING>", "<INT>", "<FLOAT>", "<BOOL>"
+			{
+				validation:     `required`,
+				normalizedType: `<STRING>`,
+				validCase:      `"abcde"`,
+				invalidCase:    `""`,
+				errorMessage:   `{{.FieldName}} is required`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `<INT>`,
+				validCase:      `32`,
+				invalidCase:    `0`,
+				errorMessage:   `{{.FieldName}} is required`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.34`,
+				invalidCase:    `0`,
+				errorMessage:   `{{.FieldName}} is required`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `<BOOL>`,
+				validCase:      `true`,
+				invalidCase:    `false`,
+				errorMessage:   `{{.FieldName}} is required`,
+			},
+
+			// required: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `required`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"abcde"}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{32}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{12.34}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{true}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+
+			// required: "[N]<STRING>", "[N]<INT>", "[N]<FLOAT>", "[N]<BOOL>"
+			{
+				validation:     `required`,
+				normalizedType: `[N]<STRING>`,
+				validCase:      `{{.BasicType}}{"abcde"}`,
+				invalidCase:    `--`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+				generateOnly:   "pointer",
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[N]<INT>`,
+				validCase:      `{{.BasicType}}{32}`,
+				invalidCase:    `--`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+				generateOnly:   "pointer",
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[N]<FLOAT>`,
+				validCase:      `{{.BasicType}}{12.34}`,
+				invalidCase:    `--`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+				generateOnly:   "pointer",
+			},
+			{
+				validation:     `required`,
+				normalizedType: `[N]<BOOL>`,
+				validCase:      `{{.BasicType}}{true}`,
+				invalidCase:    `--`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+				generateOnly:   "pointer",
+			},
+
+			// required: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `required`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"abcde":"value"}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{32:64}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{12.34:56.78}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+			{
+				validation:     `required`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{true:true}`,
+				invalidCase:    `{{.BasicType}}{}`,
+				errorMessage:   `{{.FieldName}} must not be empty`,
+			},
+		},
+	},
+
+	// eq operations
+	{
+		operation: "eq",
+		testCases: []testCase{
+			// eq: "<STRING>", "<INT>", "<FLOAT>", "<BOOL>"
+			{
+				validation:     `eq=abcde`,
+				normalizedType: `<STRING>`,
+				validCase:      `"abcde"`,
+				invalidCase:    `"fghij"`,
+				errorMessage:   `{{.FieldName}} must be equal to 'abcde'`,
+			},
+			{
+				validation:     `eq=32`,
+				normalizedType: `<INT>`,
+				validCase:      `32`,
+				invalidCase:    `64`,
+				errorMessage:   `{{.FieldName}} must be equal to 32`,
+			},
+			{
+				validation:     `eq=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.34`,
+				invalidCase:    `34.56`,
+				errorMessage:   `{{.FieldName}} must be equal to 12.34`,
+			},
+			{
+				validation:     `eq=true`,
+				normalizedType: `<BOOL>`,
+				validCase:      `true`,
+				invalidCase:    `false`,
+				errorMessage:   `{{.FieldName}} must be equal to true`,
+			},
+		},
+	},
+
+	// neq operations
+	{
+		operation: "neq",
+		testCases: []testCase{
+			// neq: "<STRING>", "<INT>", "<FLOAT>", "<BOOL>"
+			{
+				validation:     `neq=abcde`,
+				normalizedType: `<STRING>`,
+				validCase:      `"fghij"`,
+				invalidCase:    `"abcde"`,
+				errorMessage:   `{{.FieldName}} must not be equal to 'abcde'`,
+			},
+			{
+				validation:     `neq=32`,
+				normalizedType: `<INT>`,
+				validCase:      `64`,
+				invalidCase:    `32`,
+				errorMessage:   `{{.FieldName}} must not be equal to 32`,
+			},
+			{
+				validation:     `neq=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `34.56`,
+				invalidCase:    `12.34`,
+				errorMessage:   `{{.FieldName}} must not be equal to 12.34`,
+			},
+			{
+				validation:     `neq=true`,
+				normalizedType: `<BOOL>`,
+				validCase:      `false`,
+				invalidCase:    `true`,
+				errorMessage:   `{{.FieldName}} must not be equal to true`,
+			},
+		},
+	},
+
+	// gt operations
+	{
+		operation: "gt",
+		testCases: []testCase{
+			// gt: "<INT>", "<FLOAT>"
+			{
+				validation:     `gt=32`,
+				normalizedType: `<INT>`,
+				validCase:      `33`,
+				invalidCase:    `31`,
+				errorMessage:   `{{.FieldName}} must be > 32`,
+			},
+			{
+				validation:     `gt=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.35`,
+				invalidCase:    `12.34`,
+				errorMessage:   `{{.FieldName}} must be > 12.34`,
+			},
+		},
+	},
+
+	// gte operations
+	{
+		operation: "gte",
+		testCases: []testCase{
+			// gte: "<INT>", "<FLOAT>"
+			{
+				validation:     `gte=32`,
+				normalizedType: `<INT>`,
+				validCase:      `32`,
+				invalidCase:    `31`,
+				errorMessage:   `{{.FieldName}} must be >= 32`,
+			},
+			{
+				validation:     `gte=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.34`,
+				invalidCase:    `12.33`,
+				errorMessage:   `{{.FieldName}} must be >= 12.34`,
+			},
+		},
+	},
+
+	// lt operations
+	{
+		operation: "lt",
+		testCases: []testCase{
+			// lt: "<INT>", "<FLOAT>"
+			{
+				validation:     `lt=32`,
+				normalizedType: `<INT>`,
+				validCase:      `31`,
+				invalidCase:    `33`,
+				errorMessage:   `{{.FieldName}} must be < 32`,
+			},
+			{
+				validation:     `lt=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.33`,
+				invalidCase:    `12.35`,
+				errorMessage:   `{{.FieldName}} must be < 12.34`,
+			},
+		},
+	},
+
+	// lte operations
+	{
+		operation: "lte",
+		testCases: []testCase{
+			// lte: "<INT>", "<FLOAT>"
+			{
+				validation:     `lte=32`,
+				normalizedType: `<INT>`,
+				validCase:      `32`,
+				invalidCase:    `33`,
+				errorMessage:   `{{.FieldName}} must be <= 32`,
+			},
+			{
+				validation:     `lte=12.34`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `12.34`,
+				invalidCase:    `12.35`,
+				errorMessage:   `{{.FieldName}} must be <= 12.34`,
+			},
+		},
+	},
+
+	// min operations
+	{
+		operation: "min",
+		testCases: []testCase{
+			// min: "<STRING>"
+			{
+				validation:     `min=5`,
+				normalizedType: `<STRING>`,
+				validCase:      `"abcde"`,
+				invalidCase:    `"abc"`,
+				errorMessage:   `{{.FieldName}} length must be >= 5`,
+			},
+
+			// min: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `min=2`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"abc", "def"}`,
+				invalidCase:    `{{.BasicType}}{"abc"}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{65, 67}`,
+				invalidCase:    `{{.BasicType}}{65}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{65.65, 67.67}`,
+				invalidCase:    `{{.BasicType}}{65.65}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{true, false}`,
+				invalidCase:    `{{.BasicType}}{true}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+
+			// min: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `min=2`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"a": "1", "b": "2"}`,
+				invalidCase:    `{{.BasicType}}{"a": "1"}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{1: 65, 2: 67}`,
+				invalidCase:    `{{.BasicType}}{1: 65}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{1: 65.65, 2: 67.67}`,
+				invalidCase:    `{{.BasicType}}{1: 65.65}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+			{
+				validation:     `min=2`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{true: true, false: false}`,
+				invalidCase:    `{{.BasicType}}{true: true}`,
+				errorMessage:   `{{.FieldName}} must have at least 2 elements`,
+			},
+		},
+	},
+
+	// max operations
+	{
+		operation: "max",
+		testCases: []testCase{
+			// max: "<STRING>"
+			{
+				validation:     `max=3`,
+				normalizedType: `<STRING>`,
+				validCase:      `"abc"`,
+				invalidCase:    `"abcde"`,
+				errorMessage:   `{{.FieldName}} length must be <= 3`,
+			},
+
+			// max: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `max=2`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"abc", "def"}`,
+				invalidCase:    `{{.BasicType}}{"abc", "def", "ghi"}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=2`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{65, 67}`,
+				invalidCase:    `{{.BasicType}}{65, 66, 67}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=2`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{65.65, 67.67}`,
+				invalidCase:    `{{.BasicType}}{65.65, 66.66, 67.67}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=2`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{true, false}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+
+			// max: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `max=2`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"a": "1", "b": "2"}`,
+				invalidCase:    `{{.BasicType}}{"a": "1", "b": "2", "c": "3"}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=2`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{1: 65, 2: 67}`,
+				invalidCase:    `{{.BasicType}}{1: 65, 2: 67, 3: 68}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=2`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{1: 65.65, 2: 67.67}`,
+				invalidCase:    `{{.BasicType}}{1: 65.65, 2: 66.66, 3: 67.67}`,
+				errorMessage:   `{{.FieldName}} must have at most 2 elements`,
+			},
+			{
+				validation:     `max=1`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{true: true}`,
+				invalidCase:    `{{.BasicType}}{true: true, false: false}`,
+				errorMessage:   `{{.FieldName}} must have at most 1 elements`,
+			},
+		},
+	},
+
+	// eq_ignore_case operations
+	{
+		operation: "eq_ignore_case",
+		testCases: []testCase{
+			// eq_ignore_case: "<STRING>"
+			{
+				validation:     `eq_ignore_case=abcde`,
+				normalizedType: `<STRING>`,
+				validCase:      `"AbCdE"`,
+				invalidCase:    `"a1b2c3"`,
+				errorMessage:   `{{.FieldName}} must be equal to 'abcde'`,
+			},
+		},
+	},
+
+	// neq_ignore_case operations
+	{
+		operation: "neq_ignore_case",
+		testCases: []testCase{
+			// neq_ignore_case: "<STRING>"
+			{
+				validation:     `neq_ignore_case=abcde`,
+				normalizedType: `<STRING>`,
+				validCase:      `"a1b2c3"`,
+				invalidCase:    `"AbCdE"`,
+				errorMessage:   `{{.FieldName}} must not be equal to 'abcde'`,
+			},
+		},
+	},
+
+	// len operations
+	{
+		operation: "len",
+		testCases: []testCase{
+			// len: "<STRING>"
+			{
+				validation:     `len=2`,
+				normalizedType: `<STRING>`,
+				validCase:      `"ab"`,
+				invalidCase:    `"abcde"`,
+				errorMessage:   `{{.FieldName}} length must be 2`,
+			},
+
+			// len: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `len=2`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"abc", "def"}`,
+				invalidCase:    `{{.BasicType}}{"abc", "def", "ghi"}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{65, 67}`,
+				invalidCase:    `{{.BasicType}}{65, 66, 67}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{65.65, 67.67}`,
+				invalidCase:    `{{.BasicType}}{65.65, 66.66, 67.67}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{true, false}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+
+			// len: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `len=2`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"a": "1", "b": "2"}`,
+				invalidCase:    `{{.BasicType}}{"a": "1", "b": "2", "c": "3"}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{1: 65, 2: 67}`,
+				invalidCase:    `{{.BasicType}}{1: 65, 2: 67, 3: 68}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{1: 65.65, 2: 67.67}`,
+				invalidCase:    `{{.BasicType}}{1: 65.65, 2: 66.66, 3: 67.67}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+			{
+				validation:     `len=2`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{true: true, false: false}`,
+				invalidCase:    `{{.BasicType}}{true: true}`,
+				errorMessage:   `{{.FieldName}} must have exactly 2 elements`,
+			},
+		},
+	},
+
+	// in operations
+	{
+		operation: "in",
+		testCases: []testCase{
+			// in: "<STRING>", "<INT>", "<FLOAT>", "<BOOL>"
+			{
+				validation:     `in=ab cd ef`,
+				normalizedType: `<STRING>`,
+				validCase:      `"cd"`,
+				invalidCase:    `"fg"`,
+				errorMessage:   `{{.FieldName}} must be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `in=12 34 56`,
+				normalizedType: `<INT>`,
+				validCase:      `34`,
+				invalidCase:    `78`,
+				errorMessage:   `{{.FieldName}} must be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `in=11.11 22.22 33.33`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `22.22`,
+				invalidCase:    `44.44`,
+				errorMessage:   `{{.FieldName}} must be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `in=true`,
+				normalizedType: `<BOOL>`,
+				validCase:      `true`,
+				invalidCase:    `false`,
+				errorMessage:   `{{.FieldName}} must be one of 'true'`,
+			},
+
+			// in: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `in=ab cd ef`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"ab", "ef"}`,
+				invalidCase:    `{{.BasicType}}{"ab", "gh", "ef"}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `in=12 34 56`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{12, 56}`,
+				invalidCase:    `{{.BasicType}}{12, 78, 56}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `in=11.11 22.22 33.33`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{11.11, 22.22}`,
+				invalidCase:    `{{.BasicType}}{11.11, 44.44, 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `in=true`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{true, true}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'true'`,
+			},
+
+			// in: "[<N>]<STRING>", "[<N>]<INT>", "[<N>]<FLOAT>", "[<N>]<BOOL>"
+			{
+				validation:     `in=ab cd ef`,
+				normalizedType: `[N]<STRING>`,
+				validCase:      `{{.BasicType}}{"ab", "ef", "ab"}`,
+				invalidCase:    `{{.BasicType}}{"ab", "gh", "ef"}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `in=12 34 56`,
+				normalizedType: `[N]<INT>`,
+				validCase:      `{{.BasicType}}{12, 56, 12}`,
+				invalidCase:    `{{.BasicType}}{12, 78, 56}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `in=11.11 22.22 33.33`,
+				normalizedType: `[N]<FLOAT>`,
+				validCase:      `{{.BasicType}}{11.11, 22.22, 11.11}`,
+				invalidCase:    `{{.BasicType}}{11.11, 44.44, 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `in=true`,
+				normalizedType: `[N]<BOOL>`,
+				validCase:      `{{.BasicType}}{true, true, true}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'true'`,
+			},
+
+			// in: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `in=a b c`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"a": "1", "b": "2", "c": "3"}`,
+				invalidCase:    `{{.BasicType}}{"a": "1", "d": "9", "c": "3"}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'a' 'b' 'c'`,
+			},
+			{
+				validation:     `in=1 2 3`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{1: 65, 2: 67, 3: 68}`,
+				invalidCase:    `{{.BasicType}}{1: 65, 4: 69, 3: 68}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '1' '2' '3'`,
+			},
+			{
+				validation:     `in=11.11 22.22 33.33`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{11.11: 11.11, 22.22: 22.22, 33.33: 33.33}`,
+				invalidCase:    `{{.BasicType}}{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `in=false`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{false: false}`,
+				invalidCase:    `{{.BasicType}}{true: true, false: false}`,
+				errorMessage:   `{{.FieldName}} elements must be one of 'false'`,
+			},
+		},
+	},
+
+	// nin operations
+	{
+		operation: "nin",
+		testCases: []testCase{
+			// nin: "[<STRING>]", "[<INT>]", "[<FLOAT>]", "[<BOOL>]"
+			{
+				validation:     `nin=ab cd ef`,
+				normalizedType: `<STRING>`,
+				validCase:      `"fg"`,
+				invalidCase:    `"cd"`,
+				errorMessage:   `{{.FieldName}} must not be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `nin=12 34 56`,
+				normalizedType: `<INT>`,
+				validCase:      `78`,
+				invalidCase:    `34`,
+				errorMessage:   `{{.FieldName}} must not be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `nin=11.11 22.22 33.33`,
+				normalizedType: `<FLOAT>`,
+				validCase:      `44.44`,
+				invalidCase:    `22.22`,
+				errorMessage:   `{{.FieldName}} must not be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `nin=true`,
+				normalizedType: `<BOOL>`,
+				validCase:      `false`,
+				invalidCase:    `true`,
+				errorMessage:   `{{.FieldName}} must not be one of 'true'`,
+			},
+
+			// nin: "[]<STRING>", "[]<INT>", "[]<FLOAT>", "[]<BOOL>"
+			{
+				validation:     `nin=ab cd ef`,
+				normalizedType: `[]<STRING>`,
+				validCase:      `{{.BasicType}}{"gh", "ij", "kl"}`,
+				invalidCase:    `{{.BasicType}}{"ab", "ef"}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `nin=12 34 56`,
+				normalizedType: `[]<INT>`,
+				validCase:      `{{.BasicType}}{78, 91}`,
+				invalidCase:    `{{.BasicType}}{12, 78, 56}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `nin=11.11 22.22 33.33`,
+				normalizedType: `[]<FLOAT>`,
+				validCase:      `{{.BasicType}}{44.44, 55.55, 66.66}`,
+				invalidCase:    `{{.BasicType}}{11.11, 44.44, 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `nin=true`,
+				normalizedType: `[]<BOOL>`,
+				validCase:      `{{.BasicType}}{false, false, false}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'true'`,
+			},
+
+			// nin: "[<N>]<STRING>", "[<N>]<INT>", "[<N>]<FLOAT>", "[<N>]<BOOL>"
+			{
+				validation:     `nin=ab cd ef`,
+				normalizedType: `[N]<STRING>`,
+				validCase:      `{{.BasicType}}{"gh", "ij", "kl"}`,
+				invalidCase:    `{{.BasicType}}{"ab", "gh", "ef"}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'ab' 'cd' 'ef'`,
+			},
+			{
+				validation:     `nin=12 34 56`,
+				normalizedType: `[N]<INT>`,
+				validCase:      `{{.BasicType}}{78, 91, 23}`,
+				invalidCase:    `{{.BasicType}}{12, 78, 56}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '12' '34' '56'`,
+			},
+			{
+				validation:     `nin=11.11 22.22 33.33`,
+				normalizedType: `[N]<FLOAT>`,
+				validCase:      `{{.BasicType}}{44.44, 55.55, 66.66}`,
+				invalidCase:    `{{.BasicType}}{11.11, 44.44, 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `nin=true`,
+				normalizedType: `[N]<BOOL>`,
+				validCase:      `{{.BasicType}}{false, false, false}`,
+				invalidCase:    `{{.BasicType}}{true, false, true}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'true'`,
+			},
+
+			// nin: "map[<STRING>]", "map[<INT>]", "map[<FLOAT>]", "map[<BOOL>]"
+			{
+				validation:     `nin=a b c`,
+				normalizedType: `map[<STRING>]`,
+				validCase:      `{{.BasicType}}{"d": "1", "e": "2", "f": "3"}`,
+				invalidCase:    `{{.BasicType}}{"a": "1", "d": "9", "c": "3"}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'a' 'b' 'c'`,
+			},
+			{
+				validation:     `nin=1 2 3`,
+				normalizedType: `map[<INT>]`,
+				validCase:      `{{.BasicType}}{5: 55, 6: 66, 7: 77}`,
+				invalidCase:    `{{.BasicType}}{1: 11, 4: 44, 3: 33}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '1' '2' '3'`,
+			},
+			{
+				validation:     `nin=11.11 22.22 33.33`,
+				normalizedType: `map[<FLOAT>]`,
+				validCase:      `{{.BasicType}}{44.44: 44.44, 55.55: 55.55, 66.66: 66.66}`,
+				invalidCase:    `{{.BasicType}}{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of '11.11' '22.22' '33.33'`,
+			},
+			{
+				validation:     `nin=false`,
+				normalizedType: `map[<BOOL>]`,
+				validCase:      `{{.BasicType}}{true: true}`,
+				invalidCase:    `{{.BasicType}}{true: true, false: false}`,
+				errorMessage:   `{{.FieldName}} elements must not be one of 'false'`,
+			},
+		},
+	},
+}
+
+type AllTestCasesToGenerate struct {
+	TestCases []TestCaseToGenerate
+}
+
+type TestCaseToGenerate struct {
+	StructName string
+	Tests      []TestCase
+}
+
+type TestCase struct {
+	FieldName    string
+	Validation   string
+	FieldType    string
+	BasicType    string
+	ValidCase    string
+	InvalidCase  string
+	ErrorMessage string
+}
+
+func generateTestCases() {
+	generateTestCasesFile("no_pointer_tests.tpl", "generated_no_pointer_tests.go", false)
+	generateTestCasesFile("pointer_tests.tpl", "generated_pointer_tests.go", true)
+}
+
+func generateTestCasesFile(tpl, dest string, pointer bool) {
+	log.Printf("Generating test cases file: tpl[%s] dest[%s] pointer[%v]\n", tpl, dest, pointer)
+
+	allTestsToGenerate := AllTestCasesToGenerate{}
+
+	for _, testCase := range testCases {
+		structName := testCase.operation + "StructFields"
+		if pointer {
+			structName += "Pointer"
+		}
+		allTestsToGenerate.TestCases = append(allTestsToGenerate.TestCases, TestCaseToGenerate{
+			StructName: structName,
+		})
+		for _, toGenerate := range testCase.testCases {
+			// Default ("") gen no pointer and pointer test.
+			if toGenerate.generateOnly != "" {
+				if toGenerate.generateOnly == "pointer" && !pointer {
+					continue
+				}
+				if toGenerate.generateOnly == "nopointer" && pointer {
+					continue
+				}
+			}
+			normalizedType := toGenerate.normalizedType
+			if pointer {
+				normalizedType = "*" + normalizedType
+			}
+			fTypes := common.HelperFromNormalizedToBasicTypes(normalizedType)
+			sNames := common.HelperFromNormalizedToStringNames(normalizedType)
+			for i := range fTypes {
+				op, _, _ := strings.Cut(toGenerate.validation, "=")
+				fieldName := "Field" + cases.Title(language.Und).String(op) + sNames[i]
+				basicType, _ := strings.CutPrefix(fTypes[i], "*")
+				allTestsToGenerate.TestCases[len(allTestsToGenerate.TestCases)-1].Tests = append(allTestsToGenerate.TestCases[len(allTestsToGenerate.TestCases)-1].Tests, TestCase{
+					FieldName:    fieldName,
+					Validation:   toGenerate.validation,
+					FieldType:    fTypes[i],
+					BasicType:    basicType,
+					ValidCase:    strings.ReplaceAll(toGenerate.validCase, "{{.BasicType}}", basicType),
+					InvalidCase:  strings.ReplaceAll(toGenerate.invalidCase, "{{.BasicType}}", basicType),
+					ErrorMessage: strings.ReplaceAll(toGenerate.errorMessage, "{{.FieldName}}", fieldName),
+				})
+			}
+		}
+	}
+
+	if err := allTestsToGenerate.GenerateFile(tpl, dest); err != nil {
+		log.Fatalf("error generation usecases file %s", err)
+
+	}
+
+	log.Printf("Generating %s done\n", dest)
+}
+
+func (at *AllTestCasesToGenerate) GenerateFile(tplFile, output string) error {
+	tpl, err := os.ReadFile(tplFile)
+	if err != nil {
+		return fmt.Errorf("error reading %s: %s", tplFile, err)
+	}
+
+	tmpl, err := template.New("UsecaseTests").Parse(string(tpl))
+	if err != nil {
+		return err
+	}
+
+	code := new(bytes.Buffer)
+	if err := tmpl.Execute(code, at); err != nil {
+		return err
+	}
+
+	formattedCode, err := format.Source(code.Bytes())
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(output, formattedCode, 0644); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/tests/endtoend/generate_tests/no_pointer_tests.tpl b/tests/endtoend/generate_tests/no_pointer_tests.tpl
new file mode 100644
index 0000000..8badfdf
--- /dev/null
+++ b/tests/endtoend/generate_tests/no_pointer_tests.tpl
@@ -0,0 +1,50 @@
+// Code generated by TestGenerator. DO NOT EDIT.
+
+package main
+
+import (
+	"log"
+)
+
+func noPointerTests() {
+{{range .TestCases}}{{.StructName}}Tests()
+{{end}}
+}
+
+{{range .TestCases}}
+
+type {{.StructName}} struct {
+	{{range .Tests}}{{.FieldName}} {{.FieldType}} `valid:"{{.Validation}}"`
+	{{end}}
+}
+
+func {{.StructName}}Tests() {
+	log.Println("starting {{.StructName}} types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &{{.StructName}}{}
+	expectedMsgErrors = []string{
+		{{range .Tests}}"{{.ErrorMessage}}",
+		{{end}}
+	}
+
+	{{range .Tests}}{{ if ne .InvalidCase "--" }}v.{{.FieldName}} = {{.InvalidCase}}{{end}}
+	{{end}}
+	errs = {{.StructName}}Validate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &{{.StructName}}{}
+	{{range .Tests}}v.{{.FieldName}} = {{.ValidCase}}
+	{{end}}
+	expectedMsgErrors = nil
+	errs = {{.StructName}}Validate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("{{.StructName}} types tests ok")
+}
+
+{{end}}
\ No newline at end of file
diff --git a/tests/endtoend/generate_tests/numeric_float.tpl b/tests/endtoend/generate_tests/numeric_float.tpl
index df12a75..ff3d884 100644
--- a/tests/endtoend/generate_tests/numeric_float.tpl
+++ b/tests/endtoend/generate_tests/numeric_float.tpl
@@ -1,4 +1,4 @@
-// Code generated by NumericTestGenerator. DO NOT EDIT.
+// Code generated by TestGenerator. DO NOT EDIT.
 
 package main
 
diff --git a/tests/endtoend/generate_tests/numeric_int.tpl b/tests/endtoend/generate_tests/numeric_int.tpl
index 2f6c13f..cc28723 100644
--- a/tests/endtoend/generate_tests/numeric_int.tpl
+++ b/tests/endtoend/generate_tests/numeric_int.tpl
@@ -1,4 +1,4 @@
-// Code generated by NumericTestGenerator. DO NOT EDIT.
+// Code generated by TestGenerator. DO NOT EDIT.
 
 package main
 
diff --git a/tests/endtoend/generate_tests/pointer_tests.tpl b/tests/endtoend/generate_tests/pointer_tests.tpl
new file mode 100644
index 0000000..6528758
--- /dev/null
+++ b/tests/endtoend/generate_tests/pointer_tests.tpl
@@ -0,0 +1,58 @@
+// Code generated by TestGenerator. DO NOT EDIT.
+
+package main
+
+import (
+	"log"
+)
+
+func pointerTests() {
+{{range .TestCases}}{{.StructName}}Tests()
+{{end}}
+}
+
+{{range .TestCases}}
+
+type {{.StructName}} struct {
+	{{range .Tests}}{{.FieldName}} {{.FieldType}} `valid:"{{.Validation}}"`
+	{{end}}
+}
+
+func {{.StructName}}Tests() {
+	log.Println("starting {{.StructName}} types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &{{.StructName}}{}
+	expectedMsgErrors = []string{
+		{{range .Tests}}"{{.ErrorMessage}}",
+		{{end}}
+	}
+	errs = {{.StructName}}Validate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	{{range .Tests}}{{ if ne .InvalidCase "--" }}var Invalid{{.FieldName}} {{.BasicType}} = {{.InvalidCase}}{{end}}
+	{{end}}
+	v = &{{.StructName}}{}
+	{{range .Tests}}{{ if ne .InvalidCase "--" }}v.{{.FieldName}} = &Invalid{{.FieldName}}{{end}}
+	{{end}}
+	errs = {{.StructName}}Validate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	{{range .Tests}}var Valid{{.FieldName}} {{.BasicType}} = {{.ValidCase}}
+	{{end}}
+	v = &{{.StructName}}{}
+	{{range .Tests}}v.{{.FieldName}} = &Valid{{.FieldName}}
+	{{end}}
+	expectedMsgErrors = nil
+	errs = {{.StructName}}Validate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("{{.StructName}} types tests ok")
+}
+
+{{end}}
\ No newline at end of file
diff --git a/tests/endtoend/generated_no_pointer_tests.go b/tests/endtoend/generated_no_pointer_tests.go
new file mode 100644
index 0000000..cc8c5b6
--- /dev/null
+++ b/tests/endtoend/generated_no_pointer_tests.go
@@ -0,0 +1,1726 @@
+// Code generated by TestGenerator. DO NOT EDIT.
+
+package main
+
+import (
+	"log"
+)
+
+func noPointerTests() {
+	emailStructFieldsTests()
+	requiredStructFieldsTests()
+	eqStructFieldsTests()
+	neqStructFieldsTests()
+	gtStructFieldsTests()
+	gteStructFieldsTests()
+	ltStructFieldsTests()
+	lteStructFieldsTests()
+	minStructFieldsTests()
+	maxStructFieldsTests()
+	eq_ignore_caseStructFieldsTests()
+	neq_ignore_caseStructFieldsTests()
+	lenStructFieldsTests()
+	inStructFieldsTests()
+	ninStructFieldsTests()
+
+}
+
+type emailStructFields struct {
+	FieldEmailString string `valid:"email"`
+}
+
+func emailStructFieldsTests() {
+	log.Println("starting emailStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &emailStructFields{}
+	expectedMsgErrors = []string{
+		"FieldEmailString must be a valid email",
+	}
+
+	v.FieldEmailString = "abcde@example"
+
+	errs = emailStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &emailStructFields{}
+	v.FieldEmailString = "abcde@example.com"
+
+	expectedMsgErrors = nil
+	errs = emailStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("emailStructFields types tests ok")
+}
+
+type requiredStructFields struct {
+	FieldRequiredString       string              `valid:"required"`
+	FieldRequiredInt          int                 `valid:"required"`
+	FieldRequiredInt8         int8                `valid:"required"`
+	FieldRequiredInt16        int16               `valid:"required"`
+	FieldRequiredInt32        int32               `valid:"required"`
+	FieldRequiredInt64        int64               `valid:"required"`
+	FieldRequiredUint         uint                `valid:"required"`
+	FieldRequiredUint8        uint8               `valid:"required"`
+	FieldRequiredUint16       uint16              `valid:"required"`
+	FieldRequiredUint32       uint32              `valid:"required"`
+	FieldRequiredUint64       uint64              `valid:"required"`
+	FieldRequiredFloat32      float32             `valid:"required"`
+	FieldRequiredFloat64      float64             `valid:"required"`
+	FieldRequiredBool         bool                `valid:"required"`
+	FieldRequiredStringSlice  []string            `valid:"required"`
+	FieldRequiredIntSlice     []int               `valid:"required"`
+	FieldRequiredInt8Slice    []int8              `valid:"required"`
+	FieldRequiredInt16Slice   []int16             `valid:"required"`
+	FieldRequiredInt32Slice   []int32             `valid:"required"`
+	FieldRequiredInt64Slice   []int64             `valid:"required"`
+	FieldRequiredUintSlice    []uint              `valid:"required"`
+	FieldRequiredUint8Slice   []uint8             `valid:"required"`
+	FieldRequiredUint16Slice  []uint16            `valid:"required"`
+	FieldRequiredUint32Slice  []uint32            `valid:"required"`
+	FieldRequiredUint64Slice  []uint64            `valid:"required"`
+	FieldRequiredFloat32Slice []float32           `valid:"required"`
+	FieldRequiredFloat64Slice []float64           `valid:"required"`
+	FieldRequiredBoolSlice    []bool              `valid:"required"`
+	FieldRequiredStringMap    map[string]string   `valid:"required"`
+	FieldRequiredIntMap       map[int]int         `valid:"required"`
+	FieldRequiredInt8Map      map[int8]int8       `valid:"required"`
+	FieldRequiredInt16Map     map[int16]int16     `valid:"required"`
+	FieldRequiredInt32Map     map[int32]int32     `valid:"required"`
+	FieldRequiredInt64Map     map[int64]int64     `valid:"required"`
+	FieldRequiredUintMap      map[uint]uint       `valid:"required"`
+	FieldRequiredUint8Map     map[uint8]uint8     `valid:"required"`
+	FieldRequiredUint16Map    map[uint16]uint16   `valid:"required"`
+	FieldRequiredUint32Map    map[uint32]uint32   `valid:"required"`
+	FieldRequiredUint64Map    map[uint64]uint64   `valid:"required"`
+	FieldRequiredFloat32Map   map[float32]float32 `valid:"required"`
+	FieldRequiredFloat64Map   map[float64]float64 `valid:"required"`
+	FieldRequiredBoolMap      map[bool]bool       `valid:"required"`
+}
+
+func requiredStructFieldsTests() {
+	log.Println("starting requiredStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &requiredStructFields{}
+	expectedMsgErrors = []string{
+		"FieldRequiredString is required",
+		"FieldRequiredInt is required",
+		"FieldRequiredInt8 is required",
+		"FieldRequiredInt16 is required",
+		"FieldRequiredInt32 is required",
+		"FieldRequiredInt64 is required",
+		"FieldRequiredUint is required",
+		"FieldRequiredUint8 is required",
+		"FieldRequiredUint16 is required",
+		"FieldRequiredUint32 is required",
+		"FieldRequiredUint64 is required",
+		"FieldRequiredFloat32 is required",
+		"FieldRequiredFloat64 is required",
+		"FieldRequiredBool is required",
+		"FieldRequiredStringSlice must not be empty",
+		"FieldRequiredIntSlice must not be empty",
+		"FieldRequiredInt8Slice must not be empty",
+		"FieldRequiredInt16Slice must not be empty",
+		"FieldRequiredInt32Slice must not be empty",
+		"FieldRequiredInt64Slice must not be empty",
+		"FieldRequiredUintSlice must not be empty",
+		"FieldRequiredUint8Slice must not be empty",
+		"FieldRequiredUint16Slice must not be empty",
+		"FieldRequiredUint32Slice must not be empty",
+		"FieldRequiredUint64Slice must not be empty",
+		"FieldRequiredFloat32Slice must not be empty",
+		"FieldRequiredFloat64Slice must not be empty",
+		"FieldRequiredBoolSlice must not be empty",
+		"FieldRequiredStringMap must not be empty",
+		"FieldRequiredIntMap must not be empty",
+		"FieldRequiredInt8Map must not be empty",
+		"FieldRequiredInt16Map must not be empty",
+		"FieldRequiredInt32Map must not be empty",
+		"FieldRequiredInt64Map must not be empty",
+		"FieldRequiredUintMap must not be empty",
+		"FieldRequiredUint8Map must not be empty",
+		"FieldRequiredUint16Map must not be empty",
+		"FieldRequiredUint32Map must not be empty",
+		"FieldRequiredUint64Map must not be empty",
+		"FieldRequiredFloat32Map must not be empty",
+		"FieldRequiredFloat64Map must not be empty",
+		"FieldRequiredBoolMap must not be empty",
+	}
+
+	v.FieldRequiredString = ""
+	v.FieldRequiredInt = 0
+	v.FieldRequiredInt8 = 0
+	v.FieldRequiredInt16 = 0
+	v.FieldRequiredInt32 = 0
+	v.FieldRequiredInt64 = 0
+	v.FieldRequiredUint = 0
+	v.FieldRequiredUint8 = 0
+	v.FieldRequiredUint16 = 0
+	v.FieldRequiredUint32 = 0
+	v.FieldRequiredUint64 = 0
+	v.FieldRequiredFloat32 = 0
+	v.FieldRequiredFloat64 = 0
+	v.FieldRequiredBool = false
+	v.FieldRequiredStringSlice = []string{}
+	v.FieldRequiredIntSlice = []int{}
+	v.FieldRequiredInt8Slice = []int8{}
+	v.FieldRequiredInt16Slice = []int16{}
+	v.FieldRequiredInt32Slice = []int32{}
+	v.FieldRequiredInt64Slice = []int64{}
+	v.FieldRequiredUintSlice = []uint{}
+	v.FieldRequiredUint8Slice = []uint8{}
+	v.FieldRequiredUint16Slice = []uint16{}
+	v.FieldRequiredUint32Slice = []uint32{}
+	v.FieldRequiredUint64Slice = []uint64{}
+	v.FieldRequiredFloat32Slice = []float32{}
+	v.FieldRequiredFloat64Slice = []float64{}
+	v.FieldRequiredBoolSlice = []bool{}
+	v.FieldRequiredStringMap = map[string]string{}
+	v.FieldRequiredIntMap = map[int]int{}
+	v.FieldRequiredInt8Map = map[int8]int8{}
+	v.FieldRequiredInt16Map = map[int16]int16{}
+	v.FieldRequiredInt32Map = map[int32]int32{}
+	v.FieldRequiredInt64Map = map[int64]int64{}
+	v.FieldRequiredUintMap = map[uint]uint{}
+	v.FieldRequiredUint8Map = map[uint8]uint8{}
+	v.FieldRequiredUint16Map = map[uint16]uint16{}
+	v.FieldRequiredUint32Map = map[uint32]uint32{}
+	v.FieldRequiredUint64Map = map[uint64]uint64{}
+	v.FieldRequiredFloat32Map = map[float32]float32{}
+	v.FieldRequiredFloat64Map = map[float64]float64{}
+	v.FieldRequiredBoolMap = map[bool]bool{}
+
+	errs = requiredStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &requiredStructFields{}
+	v.FieldRequiredString = "abcde"
+	v.FieldRequiredInt = 32
+	v.FieldRequiredInt8 = 32
+	v.FieldRequiredInt16 = 32
+	v.FieldRequiredInt32 = 32
+	v.FieldRequiredInt64 = 32
+	v.FieldRequiredUint = 32
+	v.FieldRequiredUint8 = 32
+	v.FieldRequiredUint16 = 32
+	v.FieldRequiredUint32 = 32
+	v.FieldRequiredUint64 = 32
+	v.FieldRequiredFloat32 = 12.34
+	v.FieldRequiredFloat64 = 12.34
+	v.FieldRequiredBool = true
+	v.FieldRequiredStringSlice = []string{"abcde"}
+	v.FieldRequiredIntSlice = []int{32}
+	v.FieldRequiredInt8Slice = []int8{32}
+	v.FieldRequiredInt16Slice = []int16{32}
+	v.FieldRequiredInt32Slice = []int32{32}
+	v.FieldRequiredInt64Slice = []int64{32}
+	v.FieldRequiredUintSlice = []uint{32}
+	v.FieldRequiredUint8Slice = []uint8{32}
+	v.FieldRequiredUint16Slice = []uint16{32}
+	v.FieldRequiredUint32Slice = []uint32{32}
+	v.FieldRequiredUint64Slice = []uint64{32}
+	v.FieldRequiredFloat32Slice = []float32{12.34}
+	v.FieldRequiredFloat64Slice = []float64{12.34}
+	v.FieldRequiredBoolSlice = []bool{true}
+	v.FieldRequiredStringMap = map[string]string{"abcde": "value"}
+	v.FieldRequiredIntMap = map[int]int{32: 64}
+	v.FieldRequiredInt8Map = map[int8]int8{32: 64}
+	v.FieldRequiredInt16Map = map[int16]int16{32: 64}
+	v.FieldRequiredInt32Map = map[int32]int32{32: 64}
+	v.FieldRequiredInt64Map = map[int64]int64{32: 64}
+	v.FieldRequiredUintMap = map[uint]uint{32: 64}
+	v.FieldRequiredUint8Map = map[uint8]uint8{32: 64}
+	v.FieldRequiredUint16Map = map[uint16]uint16{32: 64}
+	v.FieldRequiredUint32Map = map[uint32]uint32{32: 64}
+	v.FieldRequiredUint64Map = map[uint64]uint64{32: 64}
+	v.FieldRequiredFloat32Map = map[float32]float32{12.34: 56.78}
+	v.FieldRequiredFloat64Map = map[float64]float64{12.34: 56.78}
+	v.FieldRequiredBoolMap = map[bool]bool{true: true}
+
+	expectedMsgErrors = nil
+	errs = requiredStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("requiredStructFields types tests ok")
+}
+
+type eqStructFields struct {
+	FieldEqString  string  `valid:"eq=abcde"`
+	FieldEqInt     int     `valid:"eq=32"`
+	FieldEqInt8    int8    `valid:"eq=32"`
+	FieldEqInt16   int16   `valid:"eq=32"`
+	FieldEqInt32   int32   `valid:"eq=32"`
+	FieldEqInt64   int64   `valid:"eq=32"`
+	FieldEqUint    uint    `valid:"eq=32"`
+	FieldEqUint8   uint8   `valid:"eq=32"`
+	FieldEqUint16  uint16  `valid:"eq=32"`
+	FieldEqUint32  uint32  `valid:"eq=32"`
+	FieldEqUint64  uint64  `valid:"eq=32"`
+	FieldEqFloat32 float32 `valid:"eq=12.34"`
+	FieldEqFloat64 float64 `valid:"eq=12.34"`
+	FieldEqBool    bool    `valid:"eq=true"`
+}
+
+func eqStructFieldsTests() {
+	log.Println("starting eqStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &eqStructFields{}
+	expectedMsgErrors = []string{
+		"FieldEqString must be equal to 'abcde'",
+		"FieldEqInt must be equal to 32",
+		"FieldEqInt8 must be equal to 32",
+		"FieldEqInt16 must be equal to 32",
+		"FieldEqInt32 must be equal to 32",
+		"FieldEqInt64 must be equal to 32",
+		"FieldEqUint must be equal to 32",
+		"FieldEqUint8 must be equal to 32",
+		"FieldEqUint16 must be equal to 32",
+		"FieldEqUint32 must be equal to 32",
+		"FieldEqUint64 must be equal to 32",
+		"FieldEqFloat32 must be equal to 12.34",
+		"FieldEqFloat64 must be equal to 12.34",
+		"FieldEqBool must be equal to true",
+	}
+
+	v.FieldEqString = "fghij"
+	v.FieldEqInt = 64
+	v.FieldEqInt8 = 64
+	v.FieldEqInt16 = 64
+	v.FieldEqInt32 = 64
+	v.FieldEqInt64 = 64
+	v.FieldEqUint = 64
+	v.FieldEqUint8 = 64
+	v.FieldEqUint16 = 64
+	v.FieldEqUint32 = 64
+	v.FieldEqUint64 = 64
+	v.FieldEqFloat32 = 34.56
+	v.FieldEqFloat64 = 34.56
+	v.FieldEqBool = false
+
+	errs = eqStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &eqStructFields{}
+	v.FieldEqString = "abcde"
+	v.FieldEqInt = 32
+	v.FieldEqInt8 = 32
+	v.FieldEqInt16 = 32
+	v.FieldEqInt32 = 32
+	v.FieldEqInt64 = 32
+	v.FieldEqUint = 32
+	v.FieldEqUint8 = 32
+	v.FieldEqUint16 = 32
+	v.FieldEqUint32 = 32
+	v.FieldEqUint64 = 32
+	v.FieldEqFloat32 = 12.34
+	v.FieldEqFloat64 = 12.34
+	v.FieldEqBool = true
+
+	expectedMsgErrors = nil
+	errs = eqStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("eqStructFields types tests ok")
+}
+
+type neqStructFields struct {
+	FieldNeqString  string  `valid:"neq=abcde"`
+	FieldNeqInt     int     `valid:"neq=32"`
+	FieldNeqInt8    int8    `valid:"neq=32"`
+	FieldNeqInt16   int16   `valid:"neq=32"`
+	FieldNeqInt32   int32   `valid:"neq=32"`
+	FieldNeqInt64   int64   `valid:"neq=32"`
+	FieldNeqUint    uint    `valid:"neq=32"`
+	FieldNeqUint8   uint8   `valid:"neq=32"`
+	FieldNeqUint16  uint16  `valid:"neq=32"`
+	FieldNeqUint32  uint32  `valid:"neq=32"`
+	FieldNeqUint64  uint64  `valid:"neq=32"`
+	FieldNeqFloat32 float32 `valid:"neq=12.34"`
+	FieldNeqFloat64 float64 `valid:"neq=12.34"`
+	FieldNeqBool    bool    `valid:"neq=true"`
+}
+
+func neqStructFieldsTests() {
+	log.Println("starting neqStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &neqStructFields{}
+	expectedMsgErrors = []string{
+		"FieldNeqString must not be equal to 'abcde'",
+		"FieldNeqInt must not be equal to 32",
+		"FieldNeqInt8 must not be equal to 32",
+		"FieldNeqInt16 must not be equal to 32",
+		"FieldNeqInt32 must not be equal to 32",
+		"FieldNeqInt64 must not be equal to 32",
+		"FieldNeqUint must not be equal to 32",
+		"FieldNeqUint8 must not be equal to 32",
+		"FieldNeqUint16 must not be equal to 32",
+		"FieldNeqUint32 must not be equal to 32",
+		"FieldNeqUint64 must not be equal to 32",
+		"FieldNeqFloat32 must not be equal to 12.34",
+		"FieldNeqFloat64 must not be equal to 12.34",
+		"FieldNeqBool must not be equal to true",
+	}
+
+	v.FieldNeqString = "abcde"
+	v.FieldNeqInt = 32
+	v.FieldNeqInt8 = 32
+	v.FieldNeqInt16 = 32
+	v.FieldNeqInt32 = 32
+	v.FieldNeqInt64 = 32
+	v.FieldNeqUint = 32
+	v.FieldNeqUint8 = 32
+	v.FieldNeqUint16 = 32
+	v.FieldNeqUint32 = 32
+	v.FieldNeqUint64 = 32
+	v.FieldNeqFloat32 = 12.34
+	v.FieldNeqFloat64 = 12.34
+	v.FieldNeqBool = true
+
+	errs = neqStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &neqStructFields{}
+	v.FieldNeqString = "fghij"
+	v.FieldNeqInt = 64
+	v.FieldNeqInt8 = 64
+	v.FieldNeqInt16 = 64
+	v.FieldNeqInt32 = 64
+	v.FieldNeqInt64 = 64
+	v.FieldNeqUint = 64
+	v.FieldNeqUint8 = 64
+	v.FieldNeqUint16 = 64
+	v.FieldNeqUint32 = 64
+	v.FieldNeqUint64 = 64
+	v.FieldNeqFloat32 = 34.56
+	v.FieldNeqFloat64 = 34.56
+	v.FieldNeqBool = false
+
+	expectedMsgErrors = nil
+	errs = neqStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("neqStructFields types tests ok")
+}
+
+type gtStructFields struct {
+	FieldGtInt     int     `valid:"gt=32"`
+	FieldGtInt8    int8    `valid:"gt=32"`
+	FieldGtInt16   int16   `valid:"gt=32"`
+	FieldGtInt32   int32   `valid:"gt=32"`
+	FieldGtInt64   int64   `valid:"gt=32"`
+	FieldGtUint    uint    `valid:"gt=32"`
+	FieldGtUint8   uint8   `valid:"gt=32"`
+	FieldGtUint16  uint16  `valid:"gt=32"`
+	FieldGtUint32  uint32  `valid:"gt=32"`
+	FieldGtUint64  uint64  `valid:"gt=32"`
+	FieldGtFloat32 float32 `valid:"gt=12.34"`
+	FieldGtFloat64 float64 `valid:"gt=12.34"`
+}
+
+func gtStructFieldsTests() {
+	log.Println("starting gtStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &gtStructFields{}
+	expectedMsgErrors = []string{
+		"FieldGtInt must be > 32",
+		"FieldGtInt8 must be > 32",
+		"FieldGtInt16 must be > 32",
+		"FieldGtInt32 must be > 32",
+		"FieldGtInt64 must be > 32",
+		"FieldGtUint must be > 32",
+		"FieldGtUint8 must be > 32",
+		"FieldGtUint16 must be > 32",
+		"FieldGtUint32 must be > 32",
+		"FieldGtUint64 must be > 32",
+		"FieldGtFloat32 must be > 12.34",
+		"FieldGtFloat64 must be > 12.34",
+	}
+
+	v.FieldGtInt = 31
+	v.FieldGtInt8 = 31
+	v.FieldGtInt16 = 31
+	v.FieldGtInt32 = 31
+	v.FieldGtInt64 = 31
+	v.FieldGtUint = 31
+	v.FieldGtUint8 = 31
+	v.FieldGtUint16 = 31
+	v.FieldGtUint32 = 31
+	v.FieldGtUint64 = 31
+	v.FieldGtFloat32 = 12.34
+	v.FieldGtFloat64 = 12.34
+
+	errs = gtStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &gtStructFields{}
+	v.FieldGtInt = 33
+	v.FieldGtInt8 = 33
+	v.FieldGtInt16 = 33
+	v.FieldGtInt32 = 33
+	v.FieldGtInt64 = 33
+	v.FieldGtUint = 33
+	v.FieldGtUint8 = 33
+	v.FieldGtUint16 = 33
+	v.FieldGtUint32 = 33
+	v.FieldGtUint64 = 33
+	v.FieldGtFloat32 = 12.35
+	v.FieldGtFloat64 = 12.35
+
+	expectedMsgErrors = nil
+	errs = gtStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("gtStructFields types tests ok")
+}
+
+type gteStructFields struct {
+	FieldGteInt     int     `valid:"gte=32"`
+	FieldGteInt8    int8    `valid:"gte=32"`
+	FieldGteInt16   int16   `valid:"gte=32"`
+	FieldGteInt32   int32   `valid:"gte=32"`
+	FieldGteInt64   int64   `valid:"gte=32"`
+	FieldGteUint    uint    `valid:"gte=32"`
+	FieldGteUint8   uint8   `valid:"gte=32"`
+	FieldGteUint16  uint16  `valid:"gte=32"`
+	FieldGteUint32  uint32  `valid:"gte=32"`
+	FieldGteUint64  uint64  `valid:"gte=32"`
+	FieldGteFloat32 float32 `valid:"gte=12.34"`
+	FieldGteFloat64 float64 `valid:"gte=12.34"`
+}
+
+func gteStructFieldsTests() {
+	log.Println("starting gteStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &gteStructFields{}
+	expectedMsgErrors = []string{
+		"FieldGteInt must be >= 32",
+		"FieldGteInt8 must be >= 32",
+		"FieldGteInt16 must be >= 32",
+		"FieldGteInt32 must be >= 32",
+		"FieldGteInt64 must be >= 32",
+		"FieldGteUint must be >= 32",
+		"FieldGteUint8 must be >= 32",
+		"FieldGteUint16 must be >= 32",
+		"FieldGteUint32 must be >= 32",
+		"FieldGteUint64 must be >= 32",
+		"FieldGteFloat32 must be >= 12.34",
+		"FieldGteFloat64 must be >= 12.34",
+	}
+
+	v.FieldGteInt = 31
+	v.FieldGteInt8 = 31
+	v.FieldGteInt16 = 31
+	v.FieldGteInt32 = 31
+	v.FieldGteInt64 = 31
+	v.FieldGteUint = 31
+	v.FieldGteUint8 = 31
+	v.FieldGteUint16 = 31
+	v.FieldGteUint32 = 31
+	v.FieldGteUint64 = 31
+	v.FieldGteFloat32 = 12.33
+	v.FieldGteFloat64 = 12.33
+
+	errs = gteStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &gteStructFields{}
+	v.FieldGteInt = 32
+	v.FieldGteInt8 = 32
+	v.FieldGteInt16 = 32
+	v.FieldGteInt32 = 32
+	v.FieldGteInt64 = 32
+	v.FieldGteUint = 32
+	v.FieldGteUint8 = 32
+	v.FieldGteUint16 = 32
+	v.FieldGteUint32 = 32
+	v.FieldGteUint64 = 32
+	v.FieldGteFloat32 = 12.34
+	v.FieldGteFloat64 = 12.34
+
+	expectedMsgErrors = nil
+	errs = gteStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("gteStructFields types tests ok")
+}
+
+type ltStructFields struct {
+	FieldLtInt     int     `valid:"lt=32"`
+	FieldLtInt8    int8    `valid:"lt=32"`
+	FieldLtInt16   int16   `valid:"lt=32"`
+	FieldLtInt32   int32   `valid:"lt=32"`
+	FieldLtInt64   int64   `valid:"lt=32"`
+	FieldLtUint    uint    `valid:"lt=32"`
+	FieldLtUint8   uint8   `valid:"lt=32"`
+	FieldLtUint16  uint16  `valid:"lt=32"`
+	FieldLtUint32  uint32  `valid:"lt=32"`
+	FieldLtUint64  uint64  `valid:"lt=32"`
+	FieldLtFloat32 float32 `valid:"lt=12.34"`
+	FieldLtFloat64 float64 `valid:"lt=12.34"`
+}
+
+func ltStructFieldsTests() {
+	log.Println("starting ltStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &ltStructFields{}
+	expectedMsgErrors = []string{
+		"FieldLtInt must be < 32",
+		"FieldLtInt8 must be < 32",
+		"FieldLtInt16 must be < 32",
+		"FieldLtInt32 must be < 32",
+		"FieldLtInt64 must be < 32",
+		"FieldLtUint must be < 32",
+		"FieldLtUint8 must be < 32",
+		"FieldLtUint16 must be < 32",
+		"FieldLtUint32 must be < 32",
+		"FieldLtUint64 must be < 32",
+		"FieldLtFloat32 must be < 12.34",
+		"FieldLtFloat64 must be < 12.34",
+	}
+
+	v.FieldLtInt = 33
+	v.FieldLtInt8 = 33
+	v.FieldLtInt16 = 33
+	v.FieldLtInt32 = 33
+	v.FieldLtInt64 = 33
+	v.FieldLtUint = 33
+	v.FieldLtUint8 = 33
+	v.FieldLtUint16 = 33
+	v.FieldLtUint32 = 33
+	v.FieldLtUint64 = 33
+	v.FieldLtFloat32 = 12.35
+	v.FieldLtFloat64 = 12.35
+
+	errs = ltStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &ltStructFields{}
+	v.FieldLtInt = 31
+	v.FieldLtInt8 = 31
+	v.FieldLtInt16 = 31
+	v.FieldLtInt32 = 31
+	v.FieldLtInt64 = 31
+	v.FieldLtUint = 31
+	v.FieldLtUint8 = 31
+	v.FieldLtUint16 = 31
+	v.FieldLtUint32 = 31
+	v.FieldLtUint64 = 31
+	v.FieldLtFloat32 = 12.33
+	v.FieldLtFloat64 = 12.33
+
+	expectedMsgErrors = nil
+	errs = ltStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("ltStructFields types tests ok")
+}
+
+type lteStructFields struct {
+	FieldLteInt     int     `valid:"lte=32"`
+	FieldLteInt8    int8    `valid:"lte=32"`
+	FieldLteInt16   int16   `valid:"lte=32"`
+	FieldLteInt32   int32   `valid:"lte=32"`
+	FieldLteInt64   int64   `valid:"lte=32"`
+	FieldLteUint    uint    `valid:"lte=32"`
+	FieldLteUint8   uint8   `valid:"lte=32"`
+	FieldLteUint16  uint16  `valid:"lte=32"`
+	FieldLteUint32  uint32  `valid:"lte=32"`
+	FieldLteUint64  uint64  `valid:"lte=32"`
+	FieldLteFloat32 float32 `valid:"lte=12.34"`
+	FieldLteFloat64 float64 `valid:"lte=12.34"`
+}
+
+func lteStructFieldsTests() {
+	log.Println("starting lteStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &lteStructFields{}
+	expectedMsgErrors = []string{
+		"FieldLteInt must be <= 32",
+		"FieldLteInt8 must be <= 32",
+		"FieldLteInt16 must be <= 32",
+		"FieldLteInt32 must be <= 32",
+		"FieldLteInt64 must be <= 32",
+		"FieldLteUint must be <= 32",
+		"FieldLteUint8 must be <= 32",
+		"FieldLteUint16 must be <= 32",
+		"FieldLteUint32 must be <= 32",
+		"FieldLteUint64 must be <= 32",
+		"FieldLteFloat32 must be <= 12.34",
+		"FieldLteFloat64 must be <= 12.34",
+	}
+
+	v.FieldLteInt = 33
+	v.FieldLteInt8 = 33
+	v.FieldLteInt16 = 33
+	v.FieldLteInt32 = 33
+	v.FieldLteInt64 = 33
+	v.FieldLteUint = 33
+	v.FieldLteUint8 = 33
+	v.FieldLteUint16 = 33
+	v.FieldLteUint32 = 33
+	v.FieldLteUint64 = 33
+	v.FieldLteFloat32 = 12.35
+	v.FieldLteFloat64 = 12.35
+
+	errs = lteStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &lteStructFields{}
+	v.FieldLteInt = 32
+	v.FieldLteInt8 = 32
+	v.FieldLteInt16 = 32
+	v.FieldLteInt32 = 32
+	v.FieldLteInt64 = 32
+	v.FieldLteUint = 32
+	v.FieldLteUint8 = 32
+	v.FieldLteUint16 = 32
+	v.FieldLteUint32 = 32
+	v.FieldLteUint64 = 32
+	v.FieldLteFloat32 = 12.34
+	v.FieldLteFloat64 = 12.34
+
+	expectedMsgErrors = nil
+	errs = lteStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("lteStructFields types tests ok")
+}
+
+type minStructFields struct {
+	FieldMinString       string              `valid:"min=5"`
+	FieldMinStringSlice  []string            `valid:"min=2"`
+	FieldMinIntSlice     []int               `valid:"min=2"`
+	FieldMinInt8Slice    []int8              `valid:"min=2"`
+	FieldMinInt16Slice   []int16             `valid:"min=2"`
+	FieldMinInt32Slice   []int32             `valid:"min=2"`
+	FieldMinInt64Slice   []int64             `valid:"min=2"`
+	FieldMinUintSlice    []uint              `valid:"min=2"`
+	FieldMinUint8Slice   []uint8             `valid:"min=2"`
+	FieldMinUint16Slice  []uint16            `valid:"min=2"`
+	FieldMinUint32Slice  []uint32            `valid:"min=2"`
+	FieldMinUint64Slice  []uint64            `valid:"min=2"`
+	FieldMinFloat32Slice []float32           `valid:"min=2"`
+	FieldMinFloat64Slice []float64           `valid:"min=2"`
+	FieldMinBoolSlice    []bool              `valid:"min=2"`
+	FieldMinStringMap    map[string]string   `valid:"min=2"`
+	FieldMinIntMap       map[int]int         `valid:"min=2"`
+	FieldMinInt8Map      map[int8]int8       `valid:"min=2"`
+	FieldMinInt16Map     map[int16]int16     `valid:"min=2"`
+	FieldMinInt32Map     map[int32]int32     `valid:"min=2"`
+	FieldMinInt64Map     map[int64]int64     `valid:"min=2"`
+	FieldMinUintMap      map[uint]uint       `valid:"min=2"`
+	FieldMinUint8Map     map[uint8]uint8     `valid:"min=2"`
+	FieldMinUint16Map    map[uint16]uint16   `valid:"min=2"`
+	FieldMinUint32Map    map[uint32]uint32   `valid:"min=2"`
+	FieldMinUint64Map    map[uint64]uint64   `valid:"min=2"`
+	FieldMinFloat32Map   map[float32]float32 `valid:"min=2"`
+	FieldMinFloat64Map   map[float64]float64 `valid:"min=2"`
+	FieldMinBoolMap      map[bool]bool       `valid:"min=2"`
+}
+
+func minStructFieldsTests() {
+	log.Println("starting minStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &minStructFields{}
+	expectedMsgErrors = []string{
+		"FieldMinString length must be >= 5",
+		"FieldMinStringSlice must have at least 2 elements",
+		"FieldMinIntSlice must have at least 2 elements",
+		"FieldMinInt8Slice must have at least 2 elements",
+		"FieldMinInt16Slice must have at least 2 elements",
+		"FieldMinInt32Slice must have at least 2 elements",
+		"FieldMinInt64Slice must have at least 2 elements",
+		"FieldMinUintSlice must have at least 2 elements",
+		"FieldMinUint8Slice must have at least 2 elements",
+		"FieldMinUint16Slice must have at least 2 elements",
+		"FieldMinUint32Slice must have at least 2 elements",
+		"FieldMinUint64Slice must have at least 2 elements",
+		"FieldMinFloat32Slice must have at least 2 elements",
+		"FieldMinFloat64Slice must have at least 2 elements",
+		"FieldMinBoolSlice must have at least 2 elements",
+		"FieldMinStringMap must have at least 2 elements",
+		"FieldMinIntMap must have at least 2 elements",
+		"FieldMinInt8Map must have at least 2 elements",
+		"FieldMinInt16Map must have at least 2 elements",
+		"FieldMinInt32Map must have at least 2 elements",
+		"FieldMinInt64Map must have at least 2 elements",
+		"FieldMinUintMap must have at least 2 elements",
+		"FieldMinUint8Map must have at least 2 elements",
+		"FieldMinUint16Map must have at least 2 elements",
+		"FieldMinUint32Map must have at least 2 elements",
+		"FieldMinUint64Map must have at least 2 elements",
+		"FieldMinFloat32Map must have at least 2 elements",
+		"FieldMinFloat64Map must have at least 2 elements",
+		"FieldMinBoolMap must have at least 2 elements",
+	}
+
+	v.FieldMinString = "abc"
+	v.FieldMinStringSlice = []string{"abc"}
+	v.FieldMinIntSlice = []int{65}
+	v.FieldMinInt8Slice = []int8{65}
+	v.FieldMinInt16Slice = []int16{65}
+	v.FieldMinInt32Slice = []int32{65}
+	v.FieldMinInt64Slice = []int64{65}
+	v.FieldMinUintSlice = []uint{65}
+	v.FieldMinUint8Slice = []uint8{65}
+	v.FieldMinUint16Slice = []uint16{65}
+	v.FieldMinUint32Slice = []uint32{65}
+	v.FieldMinUint64Slice = []uint64{65}
+	v.FieldMinFloat32Slice = []float32{65.65}
+	v.FieldMinFloat64Slice = []float64{65.65}
+	v.FieldMinBoolSlice = []bool{true}
+	v.FieldMinStringMap = map[string]string{"a": "1"}
+	v.FieldMinIntMap = map[int]int{1: 65}
+	v.FieldMinInt8Map = map[int8]int8{1: 65}
+	v.FieldMinInt16Map = map[int16]int16{1: 65}
+	v.FieldMinInt32Map = map[int32]int32{1: 65}
+	v.FieldMinInt64Map = map[int64]int64{1: 65}
+	v.FieldMinUintMap = map[uint]uint{1: 65}
+	v.FieldMinUint8Map = map[uint8]uint8{1: 65}
+	v.FieldMinUint16Map = map[uint16]uint16{1: 65}
+	v.FieldMinUint32Map = map[uint32]uint32{1: 65}
+	v.FieldMinUint64Map = map[uint64]uint64{1: 65}
+	v.FieldMinFloat32Map = map[float32]float32{1: 65.65}
+	v.FieldMinFloat64Map = map[float64]float64{1: 65.65}
+	v.FieldMinBoolMap = map[bool]bool{true: true}
+
+	errs = minStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &minStructFields{}
+	v.FieldMinString = "abcde"
+	v.FieldMinStringSlice = []string{"abc", "def"}
+	v.FieldMinIntSlice = []int{65, 67}
+	v.FieldMinInt8Slice = []int8{65, 67}
+	v.FieldMinInt16Slice = []int16{65, 67}
+	v.FieldMinInt32Slice = []int32{65, 67}
+	v.FieldMinInt64Slice = []int64{65, 67}
+	v.FieldMinUintSlice = []uint{65, 67}
+	v.FieldMinUint8Slice = []uint8{65, 67}
+	v.FieldMinUint16Slice = []uint16{65, 67}
+	v.FieldMinUint32Slice = []uint32{65, 67}
+	v.FieldMinUint64Slice = []uint64{65, 67}
+	v.FieldMinFloat32Slice = []float32{65.65, 67.67}
+	v.FieldMinFloat64Slice = []float64{65.65, 67.67}
+	v.FieldMinBoolSlice = []bool{true, false}
+	v.FieldMinStringMap = map[string]string{"a": "1", "b": "2"}
+	v.FieldMinIntMap = map[int]int{1: 65, 2: 67}
+	v.FieldMinInt8Map = map[int8]int8{1: 65, 2: 67}
+	v.FieldMinInt16Map = map[int16]int16{1: 65, 2: 67}
+	v.FieldMinInt32Map = map[int32]int32{1: 65, 2: 67}
+	v.FieldMinInt64Map = map[int64]int64{1: 65, 2: 67}
+	v.FieldMinUintMap = map[uint]uint{1: 65, 2: 67}
+	v.FieldMinUint8Map = map[uint8]uint8{1: 65, 2: 67}
+	v.FieldMinUint16Map = map[uint16]uint16{1: 65, 2: 67}
+	v.FieldMinUint32Map = map[uint32]uint32{1: 65, 2: 67}
+	v.FieldMinUint64Map = map[uint64]uint64{1: 65, 2: 67}
+	v.FieldMinFloat32Map = map[float32]float32{1: 65.65, 2: 67.67}
+	v.FieldMinFloat64Map = map[float64]float64{1: 65.65, 2: 67.67}
+	v.FieldMinBoolMap = map[bool]bool{true: true, false: false}
+
+	expectedMsgErrors = nil
+	errs = minStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("minStructFields types tests ok")
+}
+
+type maxStructFields struct {
+	FieldMaxString       string              `valid:"max=3"`
+	FieldMaxStringSlice  []string            `valid:"max=2"`
+	FieldMaxIntSlice     []int               `valid:"max=2"`
+	FieldMaxInt8Slice    []int8              `valid:"max=2"`
+	FieldMaxInt16Slice   []int16             `valid:"max=2"`
+	FieldMaxInt32Slice   []int32             `valid:"max=2"`
+	FieldMaxInt64Slice   []int64             `valid:"max=2"`
+	FieldMaxUintSlice    []uint              `valid:"max=2"`
+	FieldMaxUint8Slice   []uint8             `valid:"max=2"`
+	FieldMaxUint16Slice  []uint16            `valid:"max=2"`
+	FieldMaxUint32Slice  []uint32            `valid:"max=2"`
+	FieldMaxUint64Slice  []uint64            `valid:"max=2"`
+	FieldMaxFloat32Slice []float32           `valid:"max=2"`
+	FieldMaxFloat64Slice []float64           `valid:"max=2"`
+	FieldMaxBoolSlice    []bool              `valid:"max=2"`
+	FieldMaxStringMap    map[string]string   `valid:"max=2"`
+	FieldMaxIntMap       map[int]int         `valid:"max=2"`
+	FieldMaxInt8Map      map[int8]int8       `valid:"max=2"`
+	FieldMaxInt16Map     map[int16]int16     `valid:"max=2"`
+	FieldMaxInt32Map     map[int32]int32     `valid:"max=2"`
+	FieldMaxInt64Map     map[int64]int64     `valid:"max=2"`
+	FieldMaxUintMap      map[uint]uint       `valid:"max=2"`
+	FieldMaxUint8Map     map[uint8]uint8     `valid:"max=2"`
+	FieldMaxUint16Map    map[uint16]uint16   `valid:"max=2"`
+	FieldMaxUint32Map    map[uint32]uint32   `valid:"max=2"`
+	FieldMaxUint64Map    map[uint64]uint64   `valid:"max=2"`
+	FieldMaxFloat32Map   map[float32]float32 `valid:"max=2"`
+	FieldMaxFloat64Map   map[float64]float64 `valid:"max=2"`
+	FieldMaxBoolMap      map[bool]bool       `valid:"max=1"`
+}
+
+func maxStructFieldsTests() {
+	log.Println("starting maxStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &maxStructFields{}
+	expectedMsgErrors = []string{
+		"FieldMaxString length must be <= 3",
+		"FieldMaxStringSlice must have at most 2 elements",
+		"FieldMaxIntSlice must have at most 2 elements",
+		"FieldMaxInt8Slice must have at most 2 elements",
+		"FieldMaxInt16Slice must have at most 2 elements",
+		"FieldMaxInt32Slice must have at most 2 elements",
+		"FieldMaxInt64Slice must have at most 2 elements",
+		"FieldMaxUintSlice must have at most 2 elements",
+		"FieldMaxUint8Slice must have at most 2 elements",
+		"FieldMaxUint16Slice must have at most 2 elements",
+		"FieldMaxUint32Slice must have at most 2 elements",
+		"FieldMaxUint64Slice must have at most 2 elements",
+		"FieldMaxFloat32Slice must have at most 2 elements",
+		"FieldMaxFloat64Slice must have at most 2 elements",
+		"FieldMaxBoolSlice must have at most 2 elements",
+		"FieldMaxStringMap must have at most 2 elements",
+		"FieldMaxIntMap must have at most 2 elements",
+		"FieldMaxInt8Map must have at most 2 elements",
+		"FieldMaxInt16Map must have at most 2 elements",
+		"FieldMaxInt32Map must have at most 2 elements",
+		"FieldMaxInt64Map must have at most 2 elements",
+		"FieldMaxUintMap must have at most 2 elements",
+		"FieldMaxUint8Map must have at most 2 elements",
+		"FieldMaxUint16Map must have at most 2 elements",
+		"FieldMaxUint32Map must have at most 2 elements",
+		"FieldMaxUint64Map must have at most 2 elements",
+		"FieldMaxFloat32Map must have at most 2 elements",
+		"FieldMaxFloat64Map must have at most 2 elements",
+		"FieldMaxBoolMap must have at most 1 elements",
+	}
+
+	v.FieldMaxString = "abcde"
+	v.FieldMaxStringSlice = []string{"abc", "def", "ghi"}
+	v.FieldMaxIntSlice = []int{65, 66, 67}
+	v.FieldMaxInt8Slice = []int8{65, 66, 67}
+	v.FieldMaxInt16Slice = []int16{65, 66, 67}
+	v.FieldMaxInt32Slice = []int32{65, 66, 67}
+	v.FieldMaxInt64Slice = []int64{65, 66, 67}
+	v.FieldMaxUintSlice = []uint{65, 66, 67}
+	v.FieldMaxUint8Slice = []uint8{65, 66, 67}
+	v.FieldMaxUint16Slice = []uint16{65, 66, 67}
+	v.FieldMaxUint32Slice = []uint32{65, 66, 67}
+	v.FieldMaxUint64Slice = []uint64{65, 66, 67}
+	v.FieldMaxFloat32Slice = []float32{65.65, 66.66, 67.67}
+	v.FieldMaxFloat64Slice = []float64{65.65, 66.66, 67.67}
+	v.FieldMaxBoolSlice = []bool{true, false, true}
+	v.FieldMaxStringMap = map[string]string{"a": "1", "b": "2", "c": "3"}
+	v.FieldMaxIntMap = map[int]int{1: 65, 2: 67, 3: 68}
+	v.FieldMaxInt8Map = map[int8]int8{1: 65, 2: 67, 3: 68}
+	v.FieldMaxInt16Map = map[int16]int16{1: 65, 2: 67, 3: 68}
+	v.FieldMaxInt32Map = map[int32]int32{1: 65, 2: 67, 3: 68}
+	v.FieldMaxInt64Map = map[int64]int64{1: 65, 2: 67, 3: 68}
+	v.FieldMaxUintMap = map[uint]uint{1: 65, 2: 67, 3: 68}
+	v.FieldMaxUint8Map = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	v.FieldMaxUint16Map = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	v.FieldMaxUint32Map = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	v.FieldMaxUint64Map = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	v.FieldMaxFloat32Map = map[float32]float32{1: 65.65, 2: 66.66, 3: 67.67}
+	v.FieldMaxFloat64Map = map[float64]float64{1: 65.65, 2: 66.66, 3: 67.67}
+	v.FieldMaxBoolMap = map[bool]bool{true: true, false: false}
+
+	errs = maxStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &maxStructFields{}
+	v.FieldMaxString = "abc"
+	v.FieldMaxStringSlice = []string{"abc", "def"}
+	v.FieldMaxIntSlice = []int{65, 67}
+	v.FieldMaxInt8Slice = []int8{65, 67}
+	v.FieldMaxInt16Slice = []int16{65, 67}
+	v.FieldMaxInt32Slice = []int32{65, 67}
+	v.FieldMaxInt64Slice = []int64{65, 67}
+	v.FieldMaxUintSlice = []uint{65, 67}
+	v.FieldMaxUint8Slice = []uint8{65, 67}
+	v.FieldMaxUint16Slice = []uint16{65, 67}
+	v.FieldMaxUint32Slice = []uint32{65, 67}
+	v.FieldMaxUint64Slice = []uint64{65, 67}
+	v.FieldMaxFloat32Slice = []float32{65.65, 67.67}
+	v.FieldMaxFloat64Slice = []float64{65.65, 67.67}
+	v.FieldMaxBoolSlice = []bool{true, false}
+	v.FieldMaxStringMap = map[string]string{"a": "1", "b": "2"}
+	v.FieldMaxIntMap = map[int]int{1: 65, 2: 67}
+	v.FieldMaxInt8Map = map[int8]int8{1: 65, 2: 67}
+	v.FieldMaxInt16Map = map[int16]int16{1: 65, 2: 67}
+	v.FieldMaxInt32Map = map[int32]int32{1: 65, 2: 67}
+	v.FieldMaxInt64Map = map[int64]int64{1: 65, 2: 67}
+	v.FieldMaxUintMap = map[uint]uint{1: 65, 2: 67}
+	v.FieldMaxUint8Map = map[uint8]uint8{1: 65, 2: 67}
+	v.FieldMaxUint16Map = map[uint16]uint16{1: 65, 2: 67}
+	v.FieldMaxUint32Map = map[uint32]uint32{1: 65, 2: 67}
+	v.FieldMaxUint64Map = map[uint64]uint64{1: 65, 2: 67}
+	v.FieldMaxFloat32Map = map[float32]float32{1: 65.65, 2: 67.67}
+	v.FieldMaxFloat64Map = map[float64]float64{1: 65.65, 2: 67.67}
+	v.FieldMaxBoolMap = map[bool]bool{true: true}
+
+	expectedMsgErrors = nil
+	errs = maxStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("maxStructFields types tests ok")
+}
+
+type eq_ignore_caseStructFields struct {
+	FieldEq_ignore_caseString string `valid:"eq_ignore_case=abcde"`
+}
+
+func eq_ignore_caseStructFieldsTests() {
+	log.Println("starting eq_ignore_caseStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &eq_ignore_caseStructFields{}
+	expectedMsgErrors = []string{
+		"FieldEq_ignore_caseString must be equal to 'abcde'",
+	}
+
+	v.FieldEq_ignore_caseString = "a1b2c3"
+
+	errs = eq_ignore_caseStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &eq_ignore_caseStructFields{}
+	v.FieldEq_ignore_caseString = "AbCdE"
+
+	expectedMsgErrors = nil
+	errs = eq_ignore_caseStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("eq_ignore_caseStructFields types tests ok")
+}
+
+type neq_ignore_caseStructFields struct {
+	FieldNeq_ignore_caseString string `valid:"neq_ignore_case=abcde"`
+}
+
+func neq_ignore_caseStructFieldsTests() {
+	log.Println("starting neq_ignore_caseStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &neq_ignore_caseStructFields{}
+	expectedMsgErrors = []string{
+		"FieldNeq_ignore_caseString must not be equal to 'abcde'",
+	}
+
+	v.FieldNeq_ignore_caseString = "AbCdE"
+
+	errs = neq_ignore_caseStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &neq_ignore_caseStructFields{}
+	v.FieldNeq_ignore_caseString = "a1b2c3"
+
+	expectedMsgErrors = nil
+	errs = neq_ignore_caseStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("neq_ignore_caseStructFields types tests ok")
+}
+
+type lenStructFields struct {
+	FieldLenString       string              `valid:"len=2"`
+	FieldLenStringSlice  []string            `valid:"len=2"`
+	FieldLenIntSlice     []int               `valid:"len=2"`
+	FieldLenInt8Slice    []int8              `valid:"len=2"`
+	FieldLenInt16Slice   []int16             `valid:"len=2"`
+	FieldLenInt32Slice   []int32             `valid:"len=2"`
+	FieldLenInt64Slice   []int64             `valid:"len=2"`
+	FieldLenUintSlice    []uint              `valid:"len=2"`
+	FieldLenUint8Slice   []uint8             `valid:"len=2"`
+	FieldLenUint16Slice  []uint16            `valid:"len=2"`
+	FieldLenUint32Slice  []uint32            `valid:"len=2"`
+	FieldLenUint64Slice  []uint64            `valid:"len=2"`
+	FieldLenFloat32Slice []float32           `valid:"len=2"`
+	FieldLenFloat64Slice []float64           `valid:"len=2"`
+	FieldLenBoolSlice    []bool              `valid:"len=2"`
+	FieldLenStringMap    map[string]string   `valid:"len=2"`
+	FieldLenIntMap       map[int]int         `valid:"len=2"`
+	FieldLenInt8Map      map[int8]int8       `valid:"len=2"`
+	FieldLenInt16Map     map[int16]int16     `valid:"len=2"`
+	FieldLenInt32Map     map[int32]int32     `valid:"len=2"`
+	FieldLenInt64Map     map[int64]int64     `valid:"len=2"`
+	FieldLenUintMap      map[uint]uint       `valid:"len=2"`
+	FieldLenUint8Map     map[uint8]uint8     `valid:"len=2"`
+	FieldLenUint16Map    map[uint16]uint16   `valid:"len=2"`
+	FieldLenUint32Map    map[uint32]uint32   `valid:"len=2"`
+	FieldLenUint64Map    map[uint64]uint64   `valid:"len=2"`
+	FieldLenFloat32Map   map[float32]float32 `valid:"len=2"`
+	FieldLenFloat64Map   map[float64]float64 `valid:"len=2"`
+	FieldLenBoolMap      map[bool]bool       `valid:"len=2"`
+}
+
+func lenStructFieldsTests() {
+	log.Println("starting lenStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &lenStructFields{}
+	expectedMsgErrors = []string{
+		"FieldLenString length must be 2",
+		"FieldLenStringSlice must have exactly 2 elements",
+		"FieldLenIntSlice must have exactly 2 elements",
+		"FieldLenInt8Slice must have exactly 2 elements",
+		"FieldLenInt16Slice must have exactly 2 elements",
+		"FieldLenInt32Slice must have exactly 2 elements",
+		"FieldLenInt64Slice must have exactly 2 elements",
+		"FieldLenUintSlice must have exactly 2 elements",
+		"FieldLenUint8Slice must have exactly 2 elements",
+		"FieldLenUint16Slice must have exactly 2 elements",
+		"FieldLenUint32Slice must have exactly 2 elements",
+		"FieldLenUint64Slice must have exactly 2 elements",
+		"FieldLenFloat32Slice must have exactly 2 elements",
+		"FieldLenFloat64Slice must have exactly 2 elements",
+		"FieldLenBoolSlice must have exactly 2 elements",
+		"FieldLenStringMap must have exactly 2 elements",
+		"FieldLenIntMap must have exactly 2 elements",
+		"FieldLenInt8Map must have exactly 2 elements",
+		"FieldLenInt16Map must have exactly 2 elements",
+		"FieldLenInt32Map must have exactly 2 elements",
+		"FieldLenInt64Map must have exactly 2 elements",
+		"FieldLenUintMap must have exactly 2 elements",
+		"FieldLenUint8Map must have exactly 2 elements",
+		"FieldLenUint16Map must have exactly 2 elements",
+		"FieldLenUint32Map must have exactly 2 elements",
+		"FieldLenUint64Map must have exactly 2 elements",
+		"FieldLenFloat32Map must have exactly 2 elements",
+		"FieldLenFloat64Map must have exactly 2 elements",
+		"FieldLenBoolMap must have exactly 2 elements",
+	}
+
+	v.FieldLenString = "abcde"
+	v.FieldLenStringSlice = []string{"abc", "def", "ghi"}
+	v.FieldLenIntSlice = []int{65, 66, 67}
+	v.FieldLenInt8Slice = []int8{65, 66, 67}
+	v.FieldLenInt16Slice = []int16{65, 66, 67}
+	v.FieldLenInt32Slice = []int32{65, 66, 67}
+	v.FieldLenInt64Slice = []int64{65, 66, 67}
+	v.FieldLenUintSlice = []uint{65, 66, 67}
+	v.FieldLenUint8Slice = []uint8{65, 66, 67}
+	v.FieldLenUint16Slice = []uint16{65, 66, 67}
+	v.FieldLenUint32Slice = []uint32{65, 66, 67}
+	v.FieldLenUint64Slice = []uint64{65, 66, 67}
+	v.FieldLenFloat32Slice = []float32{65.65, 66.66, 67.67}
+	v.FieldLenFloat64Slice = []float64{65.65, 66.66, 67.67}
+	v.FieldLenBoolSlice = []bool{true, false, true}
+	v.FieldLenStringMap = map[string]string{"a": "1", "b": "2", "c": "3"}
+	v.FieldLenIntMap = map[int]int{1: 65, 2: 67, 3: 68}
+	v.FieldLenInt8Map = map[int8]int8{1: 65, 2: 67, 3: 68}
+	v.FieldLenInt16Map = map[int16]int16{1: 65, 2: 67, 3: 68}
+	v.FieldLenInt32Map = map[int32]int32{1: 65, 2: 67, 3: 68}
+	v.FieldLenInt64Map = map[int64]int64{1: 65, 2: 67, 3: 68}
+	v.FieldLenUintMap = map[uint]uint{1: 65, 2: 67, 3: 68}
+	v.FieldLenUint8Map = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	v.FieldLenUint16Map = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	v.FieldLenUint32Map = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	v.FieldLenUint64Map = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	v.FieldLenFloat32Map = map[float32]float32{1: 65.65, 2: 66.66, 3: 67.67}
+	v.FieldLenFloat64Map = map[float64]float64{1: 65.65, 2: 66.66, 3: 67.67}
+	v.FieldLenBoolMap = map[bool]bool{true: true}
+
+	errs = lenStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &lenStructFields{}
+	v.FieldLenString = "ab"
+	v.FieldLenStringSlice = []string{"abc", "def"}
+	v.FieldLenIntSlice = []int{65, 67}
+	v.FieldLenInt8Slice = []int8{65, 67}
+	v.FieldLenInt16Slice = []int16{65, 67}
+	v.FieldLenInt32Slice = []int32{65, 67}
+	v.FieldLenInt64Slice = []int64{65, 67}
+	v.FieldLenUintSlice = []uint{65, 67}
+	v.FieldLenUint8Slice = []uint8{65, 67}
+	v.FieldLenUint16Slice = []uint16{65, 67}
+	v.FieldLenUint32Slice = []uint32{65, 67}
+	v.FieldLenUint64Slice = []uint64{65, 67}
+	v.FieldLenFloat32Slice = []float32{65.65, 67.67}
+	v.FieldLenFloat64Slice = []float64{65.65, 67.67}
+	v.FieldLenBoolSlice = []bool{true, false}
+	v.FieldLenStringMap = map[string]string{"a": "1", "b": "2"}
+	v.FieldLenIntMap = map[int]int{1: 65, 2: 67}
+	v.FieldLenInt8Map = map[int8]int8{1: 65, 2: 67}
+	v.FieldLenInt16Map = map[int16]int16{1: 65, 2: 67}
+	v.FieldLenInt32Map = map[int32]int32{1: 65, 2: 67}
+	v.FieldLenInt64Map = map[int64]int64{1: 65, 2: 67}
+	v.FieldLenUintMap = map[uint]uint{1: 65, 2: 67}
+	v.FieldLenUint8Map = map[uint8]uint8{1: 65, 2: 67}
+	v.FieldLenUint16Map = map[uint16]uint16{1: 65, 2: 67}
+	v.FieldLenUint32Map = map[uint32]uint32{1: 65, 2: 67}
+	v.FieldLenUint64Map = map[uint64]uint64{1: 65, 2: 67}
+	v.FieldLenFloat32Map = map[float32]float32{1: 65.65, 2: 67.67}
+	v.FieldLenFloat64Map = map[float64]float64{1: 65.65, 2: 67.67}
+	v.FieldLenBoolMap = map[bool]bool{true: true, false: false}
+
+	expectedMsgErrors = nil
+	errs = lenStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("lenStructFields types tests ok")
+}
+
+type inStructFields struct {
+	FieldInString       string              `valid:"in=ab cd ef"`
+	FieldInInt          int                 `valid:"in=12 34 56"`
+	FieldInInt8         int8                `valid:"in=12 34 56"`
+	FieldInInt16        int16               `valid:"in=12 34 56"`
+	FieldInInt32        int32               `valid:"in=12 34 56"`
+	FieldInInt64        int64               `valid:"in=12 34 56"`
+	FieldInUint         uint                `valid:"in=12 34 56"`
+	FieldInUint8        uint8               `valid:"in=12 34 56"`
+	FieldInUint16       uint16              `valid:"in=12 34 56"`
+	FieldInUint32       uint32              `valid:"in=12 34 56"`
+	FieldInUint64       uint64              `valid:"in=12 34 56"`
+	FieldInFloat32      float32             `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64      float64             `valid:"in=11.11 22.22 33.33"`
+	FieldInBool         bool                `valid:"in=true"`
+	FieldInStringSlice  []string            `valid:"in=ab cd ef"`
+	FieldInIntSlice     []int               `valid:"in=12 34 56"`
+	FieldInInt8Slice    []int8              `valid:"in=12 34 56"`
+	FieldInInt16Slice   []int16             `valid:"in=12 34 56"`
+	FieldInInt32Slice   []int32             `valid:"in=12 34 56"`
+	FieldInInt64Slice   []int64             `valid:"in=12 34 56"`
+	FieldInUintSlice    []uint              `valid:"in=12 34 56"`
+	FieldInUint8Slice   []uint8             `valid:"in=12 34 56"`
+	FieldInUint16Slice  []uint16            `valid:"in=12 34 56"`
+	FieldInUint32Slice  []uint32            `valid:"in=12 34 56"`
+	FieldInUint64Slice  []uint64            `valid:"in=12 34 56"`
+	FieldInFloat32Slice []float32           `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64Slice []float64           `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolSlice    []bool              `valid:"in=true"`
+	FieldInStringArray  [3]string           `valid:"in=ab cd ef"`
+	FieldInIntArray     [3]int              `valid:"in=12 34 56"`
+	FieldInInt8Array    [3]int8             `valid:"in=12 34 56"`
+	FieldInInt16Array   [3]int16            `valid:"in=12 34 56"`
+	FieldInInt32Array   [3]int32            `valid:"in=12 34 56"`
+	FieldInInt64Array   [3]int64            `valid:"in=12 34 56"`
+	FieldInUintArray    [3]uint             `valid:"in=12 34 56"`
+	FieldInUint8Array   [3]uint8            `valid:"in=12 34 56"`
+	FieldInUint16Array  [3]uint16           `valid:"in=12 34 56"`
+	FieldInUint32Array  [3]uint32           `valid:"in=12 34 56"`
+	FieldInUint64Array  [3]uint64           `valid:"in=12 34 56"`
+	FieldInFloat32Array [3]float32          `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64Array [3]float64          `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolArray    [3]bool             `valid:"in=true"`
+	FieldInStringMap    map[string]string   `valid:"in=a b c"`
+	FieldInIntMap       map[int]int         `valid:"in=1 2 3"`
+	FieldInInt8Map      map[int8]int8       `valid:"in=1 2 3"`
+	FieldInInt16Map     map[int16]int16     `valid:"in=1 2 3"`
+	FieldInInt32Map     map[int32]int32     `valid:"in=1 2 3"`
+	FieldInInt64Map     map[int64]int64     `valid:"in=1 2 3"`
+	FieldInUintMap      map[uint]uint       `valid:"in=1 2 3"`
+	FieldInUint8Map     map[uint8]uint8     `valid:"in=1 2 3"`
+	FieldInUint16Map    map[uint16]uint16   `valid:"in=1 2 3"`
+	FieldInUint32Map    map[uint32]uint32   `valid:"in=1 2 3"`
+	FieldInUint64Map    map[uint64]uint64   `valid:"in=1 2 3"`
+	FieldInFloat32Map   map[float32]float32 `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64Map   map[float64]float64 `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolMap      map[bool]bool       `valid:"in=false"`
+}
+
+func inStructFieldsTests() {
+	log.Println("starting inStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &inStructFields{}
+	expectedMsgErrors = []string{
+		"FieldInString must be one of 'ab' 'cd' 'ef'",
+		"FieldInInt must be one of '12' '34' '56'",
+		"FieldInInt8 must be one of '12' '34' '56'",
+		"FieldInInt16 must be one of '12' '34' '56'",
+		"FieldInInt32 must be one of '12' '34' '56'",
+		"FieldInInt64 must be one of '12' '34' '56'",
+		"FieldInUint must be one of '12' '34' '56'",
+		"FieldInUint8 must be one of '12' '34' '56'",
+		"FieldInUint16 must be one of '12' '34' '56'",
+		"FieldInUint32 must be one of '12' '34' '56'",
+		"FieldInUint64 must be one of '12' '34' '56'",
+		"FieldInFloat32 must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64 must be one of '11.11' '22.22' '33.33'",
+		"FieldInBool must be one of 'true'",
+		"FieldInStringSlice elements must be one of 'ab' 'cd' 'ef'",
+		"FieldInIntSlice elements must be one of '12' '34' '56'",
+		"FieldInInt8Slice elements must be one of '12' '34' '56'",
+		"FieldInInt16Slice elements must be one of '12' '34' '56'",
+		"FieldInInt32Slice elements must be one of '12' '34' '56'",
+		"FieldInInt64Slice elements must be one of '12' '34' '56'",
+		"FieldInUintSlice elements must be one of '12' '34' '56'",
+		"FieldInUint8Slice elements must be one of '12' '34' '56'",
+		"FieldInUint16Slice elements must be one of '12' '34' '56'",
+		"FieldInUint32Slice elements must be one of '12' '34' '56'",
+		"FieldInUint64Slice elements must be one of '12' '34' '56'",
+		"FieldInFloat32Slice elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64Slice elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolSlice elements must be one of 'true'",
+		"FieldInStringArray elements must be one of 'ab' 'cd' 'ef'",
+		"FieldInIntArray elements must be one of '12' '34' '56'",
+		"FieldInInt8Array elements must be one of '12' '34' '56'",
+		"FieldInInt16Array elements must be one of '12' '34' '56'",
+		"FieldInInt32Array elements must be one of '12' '34' '56'",
+		"FieldInInt64Array elements must be one of '12' '34' '56'",
+		"FieldInUintArray elements must be one of '12' '34' '56'",
+		"FieldInUint8Array elements must be one of '12' '34' '56'",
+		"FieldInUint16Array elements must be one of '12' '34' '56'",
+		"FieldInUint32Array elements must be one of '12' '34' '56'",
+		"FieldInUint64Array elements must be one of '12' '34' '56'",
+		"FieldInFloat32Array elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64Array elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolArray elements must be one of 'true'",
+		"FieldInStringMap elements must be one of 'a' 'b' 'c'",
+		"FieldInIntMap elements must be one of '1' '2' '3'",
+		"FieldInInt8Map elements must be one of '1' '2' '3'",
+		"FieldInInt16Map elements must be one of '1' '2' '3'",
+		"FieldInInt32Map elements must be one of '1' '2' '3'",
+		"FieldInInt64Map elements must be one of '1' '2' '3'",
+		"FieldInUintMap elements must be one of '1' '2' '3'",
+		"FieldInUint8Map elements must be one of '1' '2' '3'",
+		"FieldInUint16Map elements must be one of '1' '2' '3'",
+		"FieldInUint32Map elements must be one of '1' '2' '3'",
+		"FieldInUint64Map elements must be one of '1' '2' '3'",
+		"FieldInFloat32Map elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64Map elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolMap elements must be one of 'false'",
+	}
+
+	v.FieldInString = "fg"
+	v.FieldInInt = 78
+	v.FieldInInt8 = 78
+	v.FieldInInt16 = 78
+	v.FieldInInt32 = 78
+	v.FieldInInt64 = 78
+	v.FieldInUint = 78
+	v.FieldInUint8 = 78
+	v.FieldInUint16 = 78
+	v.FieldInUint32 = 78
+	v.FieldInUint64 = 78
+	v.FieldInFloat32 = 44.44
+	v.FieldInFloat64 = 44.44
+	v.FieldInBool = false
+	v.FieldInStringSlice = []string{"ab", "gh", "ef"}
+	v.FieldInIntSlice = []int{12, 78, 56}
+	v.FieldInInt8Slice = []int8{12, 78, 56}
+	v.FieldInInt16Slice = []int16{12, 78, 56}
+	v.FieldInInt32Slice = []int32{12, 78, 56}
+	v.FieldInInt64Slice = []int64{12, 78, 56}
+	v.FieldInUintSlice = []uint{12, 78, 56}
+	v.FieldInUint8Slice = []uint8{12, 78, 56}
+	v.FieldInUint16Slice = []uint16{12, 78, 56}
+	v.FieldInUint32Slice = []uint32{12, 78, 56}
+	v.FieldInUint64Slice = []uint64{12, 78, 56}
+	v.FieldInFloat32Slice = []float32{11.11, 44.44, 33.33}
+	v.FieldInFloat64Slice = []float64{11.11, 44.44, 33.33}
+	v.FieldInBoolSlice = []bool{true, false, true}
+	v.FieldInStringArray = [3]string{"ab", "gh", "ef"}
+	v.FieldInIntArray = [3]int{12, 78, 56}
+	v.FieldInInt8Array = [3]int8{12, 78, 56}
+	v.FieldInInt16Array = [3]int16{12, 78, 56}
+	v.FieldInInt32Array = [3]int32{12, 78, 56}
+	v.FieldInInt64Array = [3]int64{12, 78, 56}
+	v.FieldInUintArray = [3]uint{12, 78, 56}
+	v.FieldInUint8Array = [3]uint8{12, 78, 56}
+	v.FieldInUint16Array = [3]uint16{12, 78, 56}
+	v.FieldInUint32Array = [3]uint32{12, 78, 56}
+	v.FieldInUint64Array = [3]uint64{12, 78, 56}
+	v.FieldInFloat32Array = [3]float32{11.11, 44.44, 33.33}
+	v.FieldInFloat64Array = [3]float64{11.11, 44.44, 33.33}
+	v.FieldInBoolArray = [3]bool{true, false, true}
+	v.FieldInStringMap = map[string]string{"a": "1", "d": "9", "c": "3"}
+	v.FieldInIntMap = map[int]int{1: 65, 4: 69, 3: 68}
+	v.FieldInInt8Map = map[int8]int8{1: 65, 4: 69, 3: 68}
+	v.FieldInInt16Map = map[int16]int16{1: 65, 4: 69, 3: 68}
+	v.FieldInInt32Map = map[int32]int32{1: 65, 4: 69, 3: 68}
+	v.FieldInInt64Map = map[int64]int64{1: 65, 4: 69, 3: 68}
+	v.FieldInUintMap = map[uint]uint{1: 65, 4: 69, 3: 68}
+	v.FieldInUint8Map = map[uint8]uint8{1: 65, 4: 69, 3: 68}
+	v.FieldInUint16Map = map[uint16]uint16{1: 65, 4: 69, 3: 68}
+	v.FieldInUint32Map = map[uint32]uint32{1: 65, 4: 69, 3: 68}
+	v.FieldInUint64Map = map[uint64]uint64{1: 65, 4: 69, 3: 68}
+	v.FieldInFloat32Map = map[float32]float32{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	v.FieldInFloat64Map = map[float64]float64{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	v.FieldInBoolMap = map[bool]bool{true: true, false: false}
+
+	errs = inStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &inStructFields{}
+	v.FieldInString = "cd"
+	v.FieldInInt = 34
+	v.FieldInInt8 = 34
+	v.FieldInInt16 = 34
+	v.FieldInInt32 = 34
+	v.FieldInInt64 = 34
+	v.FieldInUint = 34
+	v.FieldInUint8 = 34
+	v.FieldInUint16 = 34
+	v.FieldInUint32 = 34
+	v.FieldInUint64 = 34
+	v.FieldInFloat32 = 22.22
+	v.FieldInFloat64 = 22.22
+	v.FieldInBool = true
+	v.FieldInStringSlice = []string{"ab", "ef"}
+	v.FieldInIntSlice = []int{12, 56}
+	v.FieldInInt8Slice = []int8{12, 56}
+	v.FieldInInt16Slice = []int16{12, 56}
+	v.FieldInInt32Slice = []int32{12, 56}
+	v.FieldInInt64Slice = []int64{12, 56}
+	v.FieldInUintSlice = []uint{12, 56}
+	v.FieldInUint8Slice = []uint8{12, 56}
+	v.FieldInUint16Slice = []uint16{12, 56}
+	v.FieldInUint32Slice = []uint32{12, 56}
+	v.FieldInUint64Slice = []uint64{12, 56}
+	v.FieldInFloat32Slice = []float32{11.11, 22.22}
+	v.FieldInFloat64Slice = []float64{11.11, 22.22}
+	v.FieldInBoolSlice = []bool{true, true}
+	v.FieldInStringArray = [3]string{"ab", "ef", "ab"}
+	v.FieldInIntArray = [3]int{12, 56, 12}
+	v.FieldInInt8Array = [3]int8{12, 56, 12}
+	v.FieldInInt16Array = [3]int16{12, 56, 12}
+	v.FieldInInt32Array = [3]int32{12, 56, 12}
+	v.FieldInInt64Array = [3]int64{12, 56, 12}
+	v.FieldInUintArray = [3]uint{12, 56, 12}
+	v.FieldInUint8Array = [3]uint8{12, 56, 12}
+	v.FieldInUint16Array = [3]uint16{12, 56, 12}
+	v.FieldInUint32Array = [3]uint32{12, 56, 12}
+	v.FieldInUint64Array = [3]uint64{12, 56, 12}
+	v.FieldInFloat32Array = [3]float32{11.11, 22.22, 11.11}
+	v.FieldInFloat64Array = [3]float64{11.11, 22.22, 11.11}
+	v.FieldInBoolArray = [3]bool{true, true, true}
+	v.FieldInStringMap = map[string]string{"a": "1", "b": "2", "c": "3"}
+	v.FieldInIntMap = map[int]int{1: 65, 2: 67, 3: 68}
+	v.FieldInInt8Map = map[int8]int8{1: 65, 2: 67, 3: 68}
+	v.FieldInInt16Map = map[int16]int16{1: 65, 2: 67, 3: 68}
+	v.FieldInInt32Map = map[int32]int32{1: 65, 2: 67, 3: 68}
+	v.FieldInInt64Map = map[int64]int64{1: 65, 2: 67, 3: 68}
+	v.FieldInUintMap = map[uint]uint{1: 65, 2: 67, 3: 68}
+	v.FieldInUint8Map = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	v.FieldInUint16Map = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	v.FieldInUint32Map = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	v.FieldInUint64Map = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	v.FieldInFloat32Map = map[float32]float32{11.11: 11.11, 22.22: 22.22, 33.33: 33.33}
+	v.FieldInFloat64Map = map[float64]float64{11.11: 11.11, 22.22: 22.22, 33.33: 33.33}
+	v.FieldInBoolMap = map[bool]bool{false: false}
+
+	expectedMsgErrors = nil
+	errs = inStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("inStructFields types tests ok")
+}
+
+type ninStructFields struct {
+	FieldNinString       string              `valid:"nin=ab cd ef"`
+	FieldNinInt          int                 `valid:"nin=12 34 56"`
+	FieldNinInt8         int8                `valid:"nin=12 34 56"`
+	FieldNinInt16        int16               `valid:"nin=12 34 56"`
+	FieldNinInt32        int32               `valid:"nin=12 34 56"`
+	FieldNinInt64        int64               `valid:"nin=12 34 56"`
+	FieldNinUint         uint                `valid:"nin=12 34 56"`
+	FieldNinUint8        uint8               `valid:"nin=12 34 56"`
+	FieldNinUint16       uint16              `valid:"nin=12 34 56"`
+	FieldNinUint32       uint32              `valid:"nin=12 34 56"`
+	FieldNinUint64       uint64              `valid:"nin=12 34 56"`
+	FieldNinFloat32      float32             `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64      float64             `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBool         bool                `valid:"nin=true"`
+	FieldNinStringSlice  []string            `valid:"nin=ab cd ef"`
+	FieldNinIntSlice     []int               `valid:"nin=12 34 56"`
+	FieldNinInt8Slice    []int8              `valid:"nin=12 34 56"`
+	FieldNinInt16Slice   []int16             `valid:"nin=12 34 56"`
+	FieldNinInt32Slice   []int32             `valid:"nin=12 34 56"`
+	FieldNinInt64Slice   []int64             `valid:"nin=12 34 56"`
+	FieldNinUintSlice    []uint              `valid:"nin=12 34 56"`
+	FieldNinUint8Slice   []uint8             `valid:"nin=12 34 56"`
+	FieldNinUint16Slice  []uint16            `valid:"nin=12 34 56"`
+	FieldNinUint32Slice  []uint32            `valid:"nin=12 34 56"`
+	FieldNinUint64Slice  []uint64            `valid:"nin=12 34 56"`
+	FieldNinFloat32Slice []float32           `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64Slice []float64           `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolSlice    []bool              `valid:"nin=true"`
+	FieldNinStringArray  [3]string           `valid:"nin=ab cd ef"`
+	FieldNinIntArray     [3]int              `valid:"nin=12 34 56"`
+	FieldNinInt8Array    [3]int8             `valid:"nin=12 34 56"`
+	FieldNinInt16Array   [3]int16            `valid:"nin=12 34 56"`
+	FieldNinInt32Array   [3]int32            `valid:"nin=12 34 56"`
+	FieldNinInt64Array   [3]int64            `valid:"nin=12 34 56"`
+	FieldNinUintArray    [3]uint             `valid:"nin=12 34 56"`
+	FieldNinUint8Array   [3]uint8            `valid:"nin=12 34 56"`
+	FieldNinUint16Array  [3]uint16           `valid:"nin=12 34 56"`
+	FieldNinUint32Array  [3]uint32           `valid:"nin=12 34 56"`
+	FieldNinUint64Array  [3]uint64           `valid:"nin=12 34 56"`
+	FieldNinFloat32Array [3]float32          `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64Array [3]float64          `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolArray    [3]bool             `valid:"nin=true"`
+	FieldNinStringMap    map[string]string   `valid:"nin=a b c"`
+	FieldNinIntMap       map[int]int         `valid:"nin=1 2 3"`
+	FieldNinInt8Map      map[int8]int8       `valid:"nin=1 2 3"`
+	FieldNinInt16Map     map[int16]int16     `valid:"nin=1 2 3"`
+	FieldNinInt32Map     map[int32]int32     `valid:"nin=1 2 3"`
+	FieldNinInt64Map     map[int64]int64     `valid:"nin=1 2 3"`
+	FieldNinUintMap      map[uint]uint       `valid:"nin=1 2 3"`
+	FieldNinUint8Map     map[uint8]uint8     `valid:"nin=1 2 3"`
+	FieldNinUint16Map    map[uint16]uint16   `valid:"nin=1 2 3"`
+	FieldNinUint32Map    map[uint32]uint32   `valid:"nin=1 2 3"`
+	FieldNinUint64Map    map[uint64]uint64   `valid:"nin=1 2 3"`
+	FieldNinFloat32Map   map[float32]float32 `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64Map   map[float64]float64 `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolMap      map[bool]bool       `valid:"nin=false"`
+}
+
+func ninStructFieldsTests() {
+	log.Println("starting ninStructFields types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (invalid cases)
+	v := &ninStructFields{}
+	expectedMsgErrors = []string{
+		"FieldNinString must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinInt must not be one of '12' '34' '56'",
+		"FieldNinInt8 must not be one of '12' '34' '56'",
+		"FieldNinInt16 must not be one of '12' '34' '56'",
+		"FieldNinInt32 must not be one of '12' '34' '56'",
+		"FieldNinInt64 must not be one of '12' '34' '56'",
+		"FieldNinUint must not be one of '12' '34' '56'",
+		"FieldNinUint8 must not be one of '12' '34' '56'",
+		"FieldNinUint16 must not be one of '12' '34' '56'",
+		"FieldNinUint32 must not be one of '12' '34' '56'",
+		"FieldNinUint64 must not be one of '12' '34' '56'",
+		"FieldNinFloat32 must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64 must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBool must not be one of 'true'",
+		"FieldNinStringSlice elements must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinIntSlice elements must not be one of '12' '34' '56'",
+		"FieldNinInt8Slice elements must not be one of '12' '34' '56'",
+		"FieldNinInt16Slice elements must not be one of '12' '34' '56'",
+		"FieldNinInt32Slice elements must not be one of '12' '34' '56'",
+		"FieldNinInt64Slice elements must not be one of '12' '34' '56'",
+		"FieldNinUintSlice elements must not be one of '12' '34' '56'",
+		"FieldNinUint8Slice elements must not be one of '12' '34' '56'",
+		"FieldNinUint16Slice elements must not be one of '12' '34' '56'",
+		"FieldNinUint32Slice elements must not be one of '12' '34' '56'",
+		"FieldNinUint64Slice elements must not be one of '12' '34' '56'",
+		"FieldNinFloat32Slice elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64Slice elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolSlice elements must not be one of 'true'",
+		"FieldNinStringArray elements must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinIntArray elements must not be one of '12' '34' '56'",
+		"FieldNinInt8Array elements must not be one of '12' '34' '56'",
+		"FieldNinInt16Array elements must not be one of '12' '34' '56'",
+		"FieldNinInt32Array elements must not be one of '12' '34' '56'",
+		"FieldNinInt64Array elements must not be one of '12' '34' '56'",
+		"FieldNinUintArray elements must not be one of '12' '34' '56'",
+		"FieldNinUint8Array elements must not be one of '12' '34' '56'",
+		"FieldNinUint16Array elements must not be one of '12' '34' '56'",
+		"FieldNinUint32Array elements must not be one of '12' '34' '56'",
+		"FieldNinUint64Array elements must not be one of '12' '34' '56'",
+		"FieldNinFloat32Array elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64Array elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolArray elements must not be one of 'true'",
+		"FieldNinStringMap elements must not be one of 'a' 'b' 'c'",
+		"FieldNinIntMap elements must not be one of '1' '2' '3'",
+		"FieldNinInt8Map elements must not be one of '1' '2' '3'",
+		"FieldNinInt16Map elements must not be one of '1' '2' '3'",
+		"FieldNinInt32Map elements must not be one of '1' '2' '3'",
+		"FieldNinInt64Map elements must not be one of '1' '2' '3'",
+		"FieldNinUintMap elements must not be one of '1' '2' '3'",
+		"FieldNinUint8Map elements must not be one of '1' '2' '3'",
+		"FieldNinUint16Map elements must not be one of '1' '2' '3'",
+		"FieldNinUint32Map elements must not be one of '1' '2' '3'",
+		"FieldNinUint64Map elements must not be one of '1' '2' '3'",
+		"FieldNinFloat32Map elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64Map elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolMap elements must not be one of 'false'",
+	}
+
+	v.FieldNinString = "cd"
+	v.FieldNinInt = 34
+	v.FieldNinInt8 = 34
+	v.FieldNinInt16 = 34
+	v.FieldNinInt32 = 34
+	v.FieldNinInt64 = 34
+	v.FieldNinUint = 34
+	v.FieldNinUint8 = 34
+	v.FieldNinUint16 = 34
+	v.FieldNinUint32 = 34
+	v.FieldNinUint64 = 34
+	v.FieldNinFloat32 = 22.22
+	v.FieldNinFloat64 = 22.22
+	v.FieldNinBool = true
+	v.FieldNinStringSlice = []string{"ab", "ef"}
+	v.FieldNinIntSlice = []int{12, 78, 56}
+	v.FieldNinInt8Slice = []int8{12, 78, 56}
+	v.FieldNinInt16Slice = []int16{12, 78, 56}
+	v.FieldNinInt32Slice = []int32{12, 78, 56}
+	v.FieldNinInt64Slice = []int64{12, 78, 56}
+	v.FieldNinUintSlice = []uint{12, 78, 56}
+	v.FieldNinUint8Slice = []uint8{12, 78, 56}
+	v.FieldNinUint16Slice = []uint16{12, 78, 56}
+	v.FieldNinUint32Slice = []uint32{12, 78, 56}
+	v.FieldNinUint64Slice = []uint64{12, 78, 56}
+	v.FieldNinFloat32Slice = []float32{11.11, 44.44, 33.33}
+	v.FieldNinFloat64Slice = []float64{11.11, 44.44, 33.33}
+	v.FieldNinBoolSlice = []bool{true, false, true}
+	v.FieldNinStringArray = [3]string{"ab", "gh", "ef"}
+	v.FieldNinIntArray = [3]int{12, 78, 56}
+	v.FieldNinInt8Array = [3]int8{12, 78, 56}
+	v.FieldNinInt16Array = [3]int16{12, 78, 56}
+	v.FieldNinInt32Array = [3]int32{12, 78, 56}
+	v.FieldNinInt64Array = [3]int64{12, 78, 56}
+	v.FieldNinUintArray = [3]uint{12, 78, 56}
+	v.FieldNinUint8Array = [3]uint8{12, 78, 56}
+	v.FieldNinUint16Array = [3]uint16{12, 78, 56}
+	v.FieldNinUint32Array = [3]uint32{12, 78, 56}
+	v.FieldNinUint64Array = [3]uint64{12, 78, 56}
+	v.FieldNinFloat32Array = [3]float32{11.11, 44.44, 33.33}
+	v.FieldNinFloat64Array = [3]float64{11.11, 44.44, 33.33}
+	v.FieldNinBoolArray = [3]bool{true, false, true}
+	v.FieldNinStringMap = map[string]string{"a": "1", "d": "9", "c": "3"}
+	v.FieldNinIntMap = map[int]int{1: 11, 4: 44, 3: 33}
+	v.FieldNinInt8Map = map[int8]int8{1: 11, 4: 44, 3: 33}
+	v.FieldNinInt16Map = map[int16]int16{1: 11, 4: 44, 3: 33}
+	v.FieldNinInt32Map = map[int32]int32{1: 11, 4: 44, 3: 33}
+	v.FieldNinInt64Map = map[int64]int64{1: 11, 4: 44, 3: 33}
+	v.FieldNinUintMap = map[uint]uint{1: 11, 4: 44, 3: 33}
+	v.FieldNinUint8Map = map[uint8]uint8{1: 11, 4: 44, 3: 33}
+	v.FieldNinUint16Map = map[uint16]uint16{1: 11, 4: 44, 3: 33}
+	v.FieldNinUint32Map = map[uint32]uint32{1: 11, 4: 44, 3: 33}
+	v.FieldNinUint64Map = map[uint64]uint64{1: 11, 4: 44, 3: 33}
+	v.FieldNinFloat32Map = map[float32]float32{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	v.FieldNinFloat64Map = map[float64]float64{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	v.FieldNinBoolMap = map[bool]bool{true: true, false: false}
+
+	errs = ninStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All valid cases
+	v = &ninStructFields{}
+	v.FieldNinString = "fg"
+	v.FieldNinInt = 78
+	v.FieldNinInt8 = 78
+	v.FieldNinInt16 = 78
+	v.FieldNinInt32 = 78
+	v.FieldNinInt64 = 78
+	v.FieldNinUint = 78
+	v.FieldNinUint8 = 78
+	v.FieldNinUint16 = 78
+	v.FieldNinUint32 = 78
+	v.FieldNinUint64 = 78
+	v.FieldNinFloat32 = 44.44
+	v.FieldNinFloat64 = 44.44
+	v.FieldNinBool = false
+	v.FieldNinStringSlice = []string{"gh", "ij", "kl"}
+	v.FieldNinIntSlice = []int{78, 91}
+	v.FieldNinInt8Slice = []int8{78, 91}
+	v.FieldNinInt16Slice = []int16{78, 91}
+	v.FieldNinInt32Slice = []int32{78, 91}
+	v.FieldNinInt64Slice = []int64{78, 91}
+	v.FieldNinUintSlice = []uint{78, 91}
+	v.FieldNinUint8Slice = []uint8{78, 91}
+	v.FieldNinUint16Slice = []uint16{78, 91}
+	v.FieldNinUint32Slice = []uint32{78, 91}
+	v.FieldNinUint64Slice = []uint64{78, 91}
+	v.FieldNinFloat32Slice = []float32{44.44, 55.55, 66.66}
+	v.FieldNinFloat64Slice = []float64{44.44, 55.55, 66.66}
+	v.FieldNinBoolSlice = []bool{false, false, false}
+	v.FieldNinStringArray = [3]string{"gh", "ij", "kl"}
+	v.FieldNinIntArray = [3]int{78, 91, 23}
+	v.FieldNinInt8Array = [3]int8{78, 91, 23}
+	v.FieldNinInt16Array = [3]int16{78, 91, 23}
+	v.FieldNinInt32Array = [3]int32{78, 91, 23}
+	v.FieldNinInt64Array = [3]int64{78, 91, 23}
+	v.FieldNinUintArray = [3]uint{78, 91, 23}
+	v.FieldNinUint8Array = [3]uint8{78, 91, 23}
+	v.FieldNinUint16Array = [3]uint16{78, 91, 23}
+	v.FieldNinUint32Array = [3]uint32{78, 91, 23}
+	v.FieldNinUint64Array = [3]uint64{78, 91, 23}
+	v.FieldNinFloat32Array = [3]float32{44.44, 55.55, 66.66}
+	v.FieldNinFloat64Array = [3]float64{44.44, 55.55, 66.66}
+	v.FieldNinBoolArray = [3]bool{false, false, false}
+	v.FieldNinStringMap = map[string]string{"d": "1", "e": "2", "f": "3"}
+	v.FieldNinIntMap = map[int]int{5: 55, 6: 66, 7: 77}
+	v.FieldNinInt8Map = map[int8]int8{5: 55, 6: 66, 7: 77}
+	v.FieldNinInt16Map = map[int16]int16{5: 55, 6: 66, 7: 77}
+	v.FieldNinInt32Map = map[int32]int32{5: 55, 6: 66, 7: 77}
+	v.FieldNinInt64Map = map[int64]int64{5: 55, 6: 66, 7: 77}
+	v.FieldNinUintMap = map[uint]uint{5: 55, 6: 66, 7: 77}
+	v.FieldNinUint8Map = map[uint8]uint8{5: 55, 6: 66, 7: 77}
+	v.FieldNinUint16Map = map[uint16]uint16{5: 55, 6: 66, 7: 77}
+	v.FieldNinUint32Map = map[uint32]uint32{5: 55, 6: 66, 7: 77}
+	v.FieldNinUint64Map = map[uint64]uint64{5: 55, 6: 66, 7: 77}
+	v.FieldNinFloat32Map = map[float32]float32{44.44: 44.44, 55.55: 55.55, 66.66: 66.66}
+	v.FieldNinFloat64Map = map[float64]float64{44.44: 44.44, 55.55: 55.55, 66.66: 66.66}
+	v.FieldNinBoolMap = map[bool]bool{true: true}
+
+	expectedMsgErrors = nil
+	errs = ninStructFieldsValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	log.Println("ninStructFields types tests ok")
+}
diff --git a/tests/endtoend/numeric_float.go b/tests/endtoend/generated_numeric_float_tests.go
similarity index 98%
rename from tests/endtoend/numeric_float.go
rename to tests/endtoend/generated_numeric_float_tests.go
index 8c4c3c0..1d45479 100644
--- a/tests/endtoend/numeric_float.go
+++ b/tests/endtoend/generated_numeric_float_tests.go
@@ -1,4 +1,4 @@
-// Code generated by NumericTestGenerator. DO NOT EDIT.
+// Code generated by TestGenerator. DO NOT EDIT.
 
 package main
 
diff --git a/tests/endtoend/numeric_int.go b/tests/endtoend/generated_numeric_int_tests.go
similarity index 99%
rename from tests/endtoend/numeric_int.go
rename to tests/endtoend/generated_numeric_int_tests.go
index 018235f..61ecbed 100644
--- a/tests/endtoend/numeric_int.go
+++ b/tests/endtoend/generated_numeric_int_tests.go
@@ -1,4 +1,4 @@
-// Code generated by NumericTestGenerator. DO NOT EDIT.
+// Code generated by TestGenerator. DO NOT EDIT.
 
 package main
 
diff --git a/tests/endtoend/generated_pointer_tests.go b/tests/endtoend/generated_pointer_tests.go
new file mode 100644
index 0000000..778456c
--- /dev/null
+++ b/tests/endtoend/generated_pointer_tests.go
@@ -0,0 +1,2514 @@
+// Code generated by TestGenerator. DO NOT EDIT.
+
+package main
+
+import (
+	"log"
+)
+
+func pointerTests() {
+	emailStructFieldsPointerTests()
+	requiredStructFieldsPointerTests()
+	eqStructFieldsPointerTests()
+	neqStructFieldsPointerTests()
+	gtStructFieldsPointerTests()
+	gteStructFieldsPointerTests()
+	ltStructFieldsPointerTests()
+	lteStructFieldsPointerTests()
+	minStructFieldsPointerTests()
+	maxStructFieldsPointerTests()
+	eq_ignore_caseStructFieldsPointerTests()
+	neq_ignore_caseStructFieldsPointerTests()
+	lenStructFieldsPointerTests()
+	inStructFieldsPointerTests()
+	ninStructFieldsPointerTests()
+
+}
+
+type emailStructFieldsPointer struct {
+	FieldEmailStringPointer *string `valid:"email"`
+}
+
+func emailStructFieldsPointerTests() {
+	log.Println("starting emailStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &emailStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldEmailStringPointer must be a valid email",
+	}
+	errs = emailStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldEmailStringPointer string = "abcde@example"
+
+	v = &emailStructFieldsPointer{}
+	v.FieldEmailStringPointer = &InvalidFieldEmailStringPointer
+
+	errs = emailStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldEmailStringPointer string = "abcde@example.com"
+
+	v = &emailStructFieldsPointer{}
+	v.FieldEmailStringPointer = &ValidFieldEmailStringPointer
+
+	expectedMsgErrors = nil
+	errs = emailStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("emailStructFieldsPointer types tests ok")
+}
+
+type requiredStructFieldsPointer struct {
+	FieldRequiredStringPointer       *string              `valid:"required"`
+	FieldRequiredIntPointer          *int                 `valid:"required"`
+	FieldRequiredInt8Pointer         *int8                `valid:"required"`
+	FieldRequiredInt16Pointer        *int16               `valid:"required"`
+	FieldRequiredInt32Pointer        *int32               `valid:"required"`
+	FieldRequiredInt64Pointer        *int64               `valid:"required"`
+	FieldRequiredUintPointer         *uint                `valid:"required"`
+	FieldRequiredUint8Pointer        *uint8               `valid:"required"`
+	FieldRequiredUint16Pointer       *uint16              `valid:"required"`
+	FieldRequiredUint32Pointer       *uint32              `valid:"required"`
+	FieldRequiredUint64Pointer       *uint64              `valid:"required"`
+	FieldRequiredFloat32Pointer      *float32             `valid:"required"`
+	FieldRequiredFloat64Pointer      *float64             `valid:"required"`
+	FieldRequiredBoolPointer         *bool                `valid:"required"`
+	FieldRequiredStringSlicePointer  *[]string            `valid:"required"`
+	FieldRequiredIntSlicePointer     *[]int               `valid:"required"`
+	FieldRequiredInt8SlicePointer    *[]int8              `valid:"required"`
+	FieldRequiredInt16SlicePointer   *[]int16             `valid:"required"`
+	FieldRequiredInt32SlicePointer   *[]int32             `valid:"required"`
+	FieldRequiredInt64SlicePointer   *[]int64             `valid:"required"`
+	FieldRequiredUintSlicePointer    *[]uint              `valid:"required"`
+	FieldRequiredUint8SlicePointer   *[]uint8             `valid:"required"`
+	FieldRequiredUint16SlicePointer  *[]uint16            `valid:"required"`
+	FieldRequiredUint32SlicePointer  *[]uint32            `valid:"required"`
+	FieldRequiredUint64SlicePointer  *[]uint64            `valid:"required"`
+	FieldRequiredFloat32SlicePointer *[]float32           `valid:"required"`
+	FieldRequiredFloat64SlicePointer *[]float64           `valid:"required"`
+	FieldRequiredBoolSlicePointer    *[]bool              `valid:"required"`
+	FieldRequiredStringArrayPointer  *[3]string           `valid:"required"`
+	FieldRequiredIntArrayPointer     *[3]int              `valid:"required"`
+	FieldRequiredInt8ArrayPointer    *[3]int8             `valid:"required"`
+	FieldRequiredInt16ArrayPointer   *[3]int16            `valid:"required"`
+	FieldRequiredInt32ArrayPointer   *[3]int32            `valid:"required"`
+	FieldRequiredInt64ArrayPointer   *[3]int64            `valid:"required"`
+	FieldRequiredUintArrayPointer    *[3]uint             `valid:"required"`
+	FieldRequiredUint8ArrayPointer   *[3]uint8            `valid:"required"`
+	FieldRequiredUint16ArrayPointer  *[3]uint16           `valid:"required"`
+	FieldRequiredUint32ArrayPointer  *[3]uint32           `valid:"required"`
+	FieldRequiredUint64ArrayPointer  *[3]uint64           `valid:"required"`
+	FieldRequiredFloat32ArrayPointer *[3]float32          `valid:"required"`
+	FieldRequiredFloat64ArrayPointer *[3]float64          `valid:"required"`
+	FieldRequiredBoolArrayPointer    *[3]bool             `valid:"required"`
+	FieldRequiredStringMapPointer    *map[string]string   `valid:"required"`
+	FieldRequiredIntMapPointer       *map[int]int         `valid:"required"`
+	FieldRequiredInt8MapPointer      *map[int8]int8       `valid:"required"`
+	FieldRequiredInt16MapPointer     *map[int16]int16     `valid:"required"`
+	FieldRequiredInt32MapPointer     *map[int32]int32     `valid:"required"`
+	FieldRequiredInt64MapPointer     *map[int64]int64     `valid:"required"`
+	FieldRequiredUintMapPointer      *map[uint]uint       `valid:"required"`
+	FieldRequiredUint8MapPointer     *map[uint8]uint8     `valid:"required"`
+	FieldRequiredUint16MapPointer    *map[uint16]uint16   `valid:"required"`
+	FieldRequiredUint32MapPointer    *map[uint32]uint32   `valid:"required"`
+	FieldRequiredUint64MapPointer    *map[uint64]uint64   `valid:"required"`
+	FieldRequiredFloat32MapPointer   *map[float32]float32 `valid:"required"`
+	FieldRequiredFloat64MapPointer   *map[float64]float64 `valid:"required"`
+	FieldRequiredBoolMapPointer      *map[bool]bool       `valid:"required"`
+}
+
+func requiredStructFieldsPointerTests() {
+	log.Println("starting requiredStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &requiredStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldRequiredStringPointer is required",
+		"FieldRequiredIntPointer is required",
+		"FieldRequiredInt8Pointer is required",
+		"FieldRequiredInt16Pointer is required",
+		"FieldRequiredInt32Pointer is required",
+		"FieldRequiredInt64Pointer is required",
+		"FieldRequiredUintPointer is required",
+		"FieldRequiredUint8Pointer is required",
+		"FieldRequiredUint16Pointer is required",
+		"FieldRequiredUint32Pointer is required",
+		"FieldRequiredUint64Pointer is required",
+		"FieldRequiredFloat32Pointer is required",
+		"FieldRequiredFloat64Pointer is required",
+		"FieldRequiredBoolPointer is required",
+		"FieldRequiredStringSlicePointer must not be empty",
+		"FieldRequiredIntSlicePointer must not be empty",
+		"FieldRequiredInt8SlicePointer must not be empty",
+		"FieldRequiredInt16SlicePointer must not be empty",
+		"FieldRequiredInt32SlicePointer must not be empty",
+		"FieldRequiredInt64SlicePointer must not be empty",
+		"FieldRequiredUintSlicePointer must not be empty",
+		"FieldRequiredUint8SlicePointer must not be empty",
+		"FieldRequiredUint16SlicePointer must not be empty",
+		"FieldRequiredUint32SlicePointer must not be empty",
+		"FieldRequiredUint64SlicePointer must not be empty",
+		"FieldRequiredFloat32SlicePointer must not be empty",
+		"FieldRequiredFloat64SlicePointer must not be empty",
+		"FieldRequiredBoolSlicePointer must not be empty",
+		"FieldRequiredStringArrayPointer must not be empty",
+		"FieldRequiredIntArrayPointer must not be empty",
+		"FieldRequiredInt8ArrayPointer must not be empty",
+		"FieldRequiredInt16ArrayPointer must not be empty",
+		"FieldRequiredInt32ArrayPointer must not be empty",
+		"FieldRequiredInt64ArrayPointer must not be empty",
+		"FieldRequiredUintArrayPointer must not be empty",
+		"FieldRequiredUint8ArrayPointer must not be empty",
+		"FieldRequiredUint16ArrayPointer must not be empty",
+		"FieldRequiredUint32ArrayPointer must not be empty",
+		"FieldRequiredUint64ArrayPointer must not be empty",
+		"FieldRequiredFloat32ArrayPointer must not be empty",
+		"FieldRequiredFloat64ArrayPointer must not be empty",
+		"FieldRequiredBoolArrayPointer must not be empty",
+		"FieldRequiredStringMapPointer must not be empty",
+		"FieldRequiredIntMapPointer must not be empty",
+		"FieldRequiredInt8MapPointer must not be empty",
+		"FieldRequiredInt16MapPointer must not be empty",
+		"FieldRequiredInt32MapPointer must not be empty",
+		"FieldRequiredInt64MapPointer must not be empty",
+		"FieldRequiredUintMapPointer must not be empty",
+		"FieldRequiredUint8MapPointer must not be empty",
+		"FieldRequiredUint16MapPointer must not be empty",
+		"FieldRequiredUint32MapPointer must not be empty",
+		"FieldRequiredUint64MapPointer must not be empty",
+		"FieldRequiredFloat32MapPointer must not be empty",
+		"FieldRequiredFloat64MapPointer must not be empty",
+		"FieldRequiredBoolMapPointer must not be empty",
+	}
+	errs = requiredStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldRequiredStringPointer string = ""
+	var InvalidFieldRequiredIntPointer int = 0
+	var InvalidFieldRequiredInt8Pointer int8 = 0
+	var InvalidFieldRequiredInt16Pointer int16 = 0
+	var InvalidFieldRequiredInt32Pointer int32 = 0
+	var InvalidFieldRequiredInt64Pointer int64 = 0
+	var InvalidFieldRequiredUintPointer uint = 0
+	var InvalidFieldRequiredUint8Pointer uint8 = 0
+	var InvalidFieldRequiredUint16Pointer uint16 = 0
+	var InvalidFieldRequiredUint32Pointer uint32 = 0
+	var InvalidFieldRequiredUint64Pointer uint64 = 0
+	var InvalidFieldRequiredFloat32Pointer float32 = 0
+	var InvalidFieldRequiredFloat64Pointer float64 = 0
+	var InvalidFieldRequiredBoolPointer bool = false
+	var InvalidFieldRequiredStringSlicePointer []string = []string{}
+	var InvalidFieldRequiredIntSlicePointer []int = []int{}
+	var InvalidFieldRequiredInt8SlicePointer []int8 = []int8{}
+	var InvalidFieldRequiredInt16SlicePointer []int16 = []int16{}
+	var InvalidFieldRequiredInt32SlicePointer []int32 = []int32{}
+	var InvalidFieldRequiredInt64SlicePointer []int64 = []int64{}
+	var InvalidFieldRequiredUintSlicePointer []uint = []uint{}
+	var InvalidFieldRequiredUint8SlicePointer []uint8 = []uint8{}
+	var InvalidFieldRequiredUint16SlicePointer []uint16 = []uint16{}
+	var InvalidFieldRequiredUint32SlicePointer []uint32 = []uint32{}
+	var InvalidFieldRequiredUint64SlicePointer []uint64 = []uint64{}
+	var InvalidFieldRequiredFloat32SlicePointer []float32 = []float32{}
+	var InvalidFieldRequiredFloat64SlicePointer []float64 = []float64{}
+	var InvalidFieldRequiredBoolSlicePointer []bool = []bool{}
+
+	var InvalidFieldRequiredStringMapPointer map[string]string = map[string]string{}
+	var InvalidFieldRequiredIntMapPointer map[int]int = map[int]int{}
+	var InvalidFieldRequiredInt8MapPointer map[int8]int8 = map[int8]int8{}
+	var InvalidFieldRequiredInt16MapPointer map[int16]int16 = map[int16]int16{}
+	var InvalidFieldRequiredInt32MapPointer map[int32]int32 = map[int32]int32{}
+	var InvalidFieldRequiredInt64MapPointer map[int64]int64 = map[int64]int64{}
+	var InvalidFieldRequiredUintMapPointer map[uint]uint = map[uint]uint{}
+	var InvalidFieldRequiredUint8MapPointer map[uint8]uint8 = map[uint8]uint8{}
+	var InvalidFieldRequiredUint16MapPointer map[uint16]uint16 = map[uint16]uint16{}
+	var InvalidFieldRequiredUint32MapPointer map[uint32]uint32 = map[uint32]uint32{}
+	var InvalidFieldRequiredUint64MapPointer map[uint64]uint64 = map[uint64]uint64{}
+	var InvalidFieldRequiredFloat32MapPointer map[float32]float32 = map[float32]float32{}
+	var InvalidFieldRequiredFloat64MapPointer map[float64]float64 = map[float64]float64{}
+	var InvalidFieldRequiredBoolMapPointer map[bool]bool = map[bool]bool{}
+
+	v = &requiredStructFieldsPointer{}
+	v.FieldRequiredStringPointer = &InvalidFieldRequiredStringPointer
+	v.FieldRequiredIntPointer = &InvalidFieldRequiredIntPointer
+	v.FieldRequiredInt8Pointer = &InvalidFieldRequiredInt8Pointer
+	v.FieldRequiredInt16Pointer = &InvalidFieldRequiredInt16Pointer
+	v.FieldRequiredInt32Pointer = &InvalidFieldRequiredInt32Pointer
+	v.FieldRequiredInt64Pointer = &InvalidFieldRequiredInt64Pointer
+	v.FieldRequiredUintPointer = &InvalidFieldRequiredUintPointer
+	v.FieldRequiredUint8Pointer = &InvalidFieldRequiredUint8Pointer
+	v.FieldRequiredUint16Pointer = &InvalidFieldRequiredUint16Pointer
+	v.FieldRequiredUint32Pointer = &InvalidFieldRequiredUint32Pointer
+	v.FieldRequiredUint64Pointer = &InvalidFieldRequiredUint64Pointer
+	v.FieldRequiredFloat32Pointer = &InvalidFieldRequiredFloat32Pointer
+	v.FieldRequiredFloat64Pointer = &InvalidFieldRequiredFloat64Pointer
+	v.FieldRequiredBoolPointer = &InvalidFieldRequiredBoolPointer
+	v.FieldRequiredStringSlicePointer = &InvalidFieldRequiredStringSlicePointer
+	v.FieldRequiredIntSlicePointer = &InvalidFieldRequiredIntSlicePointer
+	v.FieldRequiredInt8SlicePointer = &InvalidFieldRequiredInt8SlicePointer
+	v.FieldRequiredInt16SlicePointer = &InvalidFieldRequiredInt16SlicePointer
+	v.FieldRequiredInt32SlicePointer = &InvalidFieldRequiredInt32SlicePointer
+	v.FieldRequiredInt64SlicePointer = &InvalidFieldRequiredInt64SlicePointer
+	v.FieldRequiredUintSlicePointer = &InvalidFieldRequiredUintSlicePointer
+	v.FieldRequiredUint8SlicePointer = &InvalidFieldRequiredUint8SlicePointer
+	v.FieldRequiredUint16SlicePointer = &InvalidFieldRequiredUint16SlicePointer
+	v.FieldRequiredUint32SlicePointer = &InvalidFieldRequiredUint32SlicePointer
+	v.FieldRequiredUint64SlicePointer = &InvalidFieldRequiredUint64SlicePointer
+	v.FieldRequiredFloat32SlicePointer = &InvalidFieldRequiredFloat32SlicePointer
+	v.FieldRequiredFloat64SlicePointer = &InvalidFieldRequiredFloat64SlicePointer
+	v.FieldRequiredBoolSlicePointer = &InvalidFieldRequiredBoolSlicePointer
+
+	v.FieldRequiredStringMapPointer = &InvalidFieldRequiredStringMapPointer
+	v.FieldRequiredIntMapPointer = &InvalidFieldRequiredIntMapPointer
+	v.FieldRequiredInt8MapPointer = &InvalidFieldRequiredInt8MapPointer
+	v.FieldRequiredInt16MapPointer = &InvalidFieldRequiredInt16MapPointer
+	v.FieldRequiredInt32MapPointer = &InvalidFieldRequiredInt32MapPointer
+	v.FieldRequiredInt64MapPointer = &InvalidFieldRequiredInt64MapPointer
+	v.FieldRequiredUintMapPointer = &InvalidFieldRequiredUintMapPointer
+	v.FieldRequiredUint8MapPointer = &InvalidFieldRequiredUint8MapPointer
+	v.FieldRequiredUint16MapPointer = &InvalidFieldRequiredUint16MapPointer
+	v.FieldRequiredUint32MapPointer = &InvalidFieldRequiredUint32MapPointer
+	v.FieldRequiredUint64MapPointer = &InvalidFieldRequiredUint64MapPointer
+	v.FieldRequiredFloat32MapPointer = &InvalidFieldRequiredFloat32MapPointer
+	v.FieldRequiredFloat64MapPointer = &InvalidFieldRequiredFloat64MapPointer
+	v.FieldRequiredBoolMapPointer = &InvalidFieldRequiredBoolMapPointer
+
+	errs = requiredStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldRequiredStringPointer string = "abcde"
+	var ValidFieldRequiredIntPointer int = 32
+	var ValidFieldRequiredInt8Pointer int8 = 32
+	var ValidFieldRequiredInt16Pointer int16 = 32
+	var ValidFieldRequiredInt32Pointer int32 = 32
+	var ValidFieldRequiredInt64Pointer int64 = 32
+	var ValidFieldRequiredUintPointer uint = 32
+	var ValidFieldRequiredUint8Pointer uint8 = 32
+	var ValidFieldRequiredUint16Pointer uint16 = 32
+	var ValidFieldRequiredUint32Pointer uint32 = 32
+	var ValidFieldRequiredUint64Pointer uint64 = 32
+	var ValidFieldRequiredFloat32Pointer float32 = 12.34
+	var ValidFieldRequiredFloat64Pointer float64 = 12.34
+	var ValidFieldRequiredBoolPointer bool = true
+	var ValidFieldRequiredStringSlicePointer []string = []string{"abcde"}
+	var ValidFieldRequiredIntSlicePointer []int = []int{32}
+	var ValidFieldRequiredInt8SlicePointer []int8 = []int8{32}
+	var ValidFieldRequiredInt16SlicePointer []int16 = []int16{32}
+	var ValidFieldRequiredInt32SlicePointer []int32 = []int32{32}
+	var ValidFieldRequiredInt64SlicePointer []int64 = []int64{32}
+	var ValidFieldRequiredUintSlicePointer []uint = []uint{32}
+	var ValidFieldRequiredUint8SlicePointer []uint8 = []uint8{32}
+	var ValidFieldRequiredUint16SlicePointer []uint16 = []uint16{32}
+	var ValidFieldRequiredUint32SlicePointer []uint32 = []uint32{32}
+	var ValidFieldRequiredUint64SlicePointer []uint64 = []uint64{32}
+	var ValidFieldRequiredFloat32SlicePointer []float32 = []float32{12.34}
+	var ValidFieldRequiredFloat64SlicePointer []float64 = []float64{12.34}
+	var ValidFieldRequiredBoolSlicePointer []bool = []bool{true}
+	var ValidFieldRequiredStringArrayPointer [3]string = [3]string{"abcde"}
+	var ValidFieldRequiredIntArrayPointer [3]int = [3]int{32}
+	var ValidFieldRequiredInt8ArrayPointer [3]int8 = [3]int8{32}
+	var ValidFieldRequiredInt16ArrayPointer [3]int16 = [3]int16{32}
+	var ValidFieldRequiredInt32ArrayPointer [3]int32 = [3]int32{32}
+	var ValidFieldRequiredInt64ArrayPointer [3]int64 = [3]int64{32}
+	var ValidFieldRequiredUintArrayPointer [3]uint = [3]uint{32}
+	var ValidFieldRequiredUint8ArrayPointer [3]uint8 = [3]uint8{32}
+	var ValidFieldRequiredUint16ArrayPointer [3]uint16 = [3]uint16{32}
+	var ValidFieldRequiredUint32ArrayPointer [3]uint32 = [3]uint32{32}
+	var ValidFieldRequiredUint64ArrayPointer [3]uint64 = [3]uint64{32}
+	var ValidFieldRequiredFloat32ArrayPointer [3]float32 = [3]float32{12.34}
+	var ValidFieldRequiredFloat64ArrayPointer [3]float64 = [3]float64{12.34}
+	var ValidFieldRequiredBoolArrayPointer [3]bool = [3]bool{true}
+	var ValidFieldRequiredStringMapPointer map[string]string = map[string]string{"abcde": "value"}
+	var ValidFieldRequiredIntMapPointer map[int]int = map[int]int{32: 64}
+	var ValidFieldRequiredInt8MapPointer map[int8]int8 = map[int8]int8{32: 64}
+	var ValidFieldRequiredInt16MapPointer map[int16]int16 = map[int16]int16{32: 64}
+	var ValidFieldRequiredInt32MapPointer map[int32]int32 = map[int32]int32{32: 64}
+	var ValidFieldRequiredInt64MapPointer map[int64]int64 = map[int64]int64{32: 64}
+	var ValidFieldRequiredUintMapPointer map[uint]uint = map[uint]uint{32: 64}
+	var ValidFieldRequiredUint8MapPointer map[uint8]uint8 = map[uint8]uint8{32: 64}
+	var ValidFieldRequiredUint16MapPointer map[uint16]uint16 = map[uint16]uint16{32: 64}
+	var ValidFieldRequiredUint32MapPointer map[uint32]uint32 = map[uint32]uint32{32: 64}
+	var ValidFieldRequiredUint64MapPointer map[uint64]uint64 = map[uint64]uint64{32: 64}
+	var ValidFieldRequiredFloat32MapPointer map[float32]float32 = map[float32]float32{12.34: 56.78}
+	var ValidFieldRequiredFloat64MapPointer map[float64]float64 = map[float64]float64{12.34: 56.78}
+	var ValidFieldRequiredBoolMapPointer map[bool]bool = map[bool]bool{true: true}
+
+	v = &requiredStructFieldsPointer{}
+	v.FieldRequiredStringPointer = &ValidFieldRequiredStringPointer
+	v.FieldRequiredIntPointer = &ValidFieldRequiredIntPointer
+	v.FieldRequiredInt8Pointer = &ValidFieldRequiredInt8Pointer
+	v.FieldRequiredInt16Pointer = &ValidFieldRequiredInt16Pointer
+	v.FieldRequiredInt32Pointer = &ValidFieldRequiredInt32Pointer
+	v.FieldRequiredInt64Pointer = &ValidFieldRequiredInt64Pointer
+	v.FieldRequiredUintPointer = &ValidFieldRequiredUintPointer
+	v.FieldRequiredUint8Pointer = &ValidFieldRequiredUint8Pointer
+	v.FieldRequiredUint16Pointer = &ValidFieldRequiredUint16Pointer
+	v.FieldRequiredUint32Pointer = &ValidFieldRequiredUint32Pointer
+	v.FieldRequiredUint64Pointer = &ValidFieldRequiredUint64Pointer
+	v.FieldRequiredFloat32Pointer = &ValidFieldRequiredFloat32Pointer
+	v.FieldRequiredFloat64Pointer = &ValidFieldRequiredFloat64Pointer
+	v.FieldRequiredBoolPointer = &ValidFieldRequiredBoolPointer
+	v.FieldRequiredStringSlicePointer = &ValidFieldRequiredStringSlicePointer
+	v.FieldRequiredIntSlicePointer = &ValidFieldRequiredIntSlicePointer
+	v.FieldRequiredInt8SlicePointer = &ValidFieldRequiredInt8SlicePointer
+	v.FieldRequiredInt16SlicePointer = &ValidFieldRequiredInt16SlicePointer
+	v.FieldRequiredInt32SlicePointer = &ValidFieldRequiredInt32SlicePointer
+	v.FieldRequiredInt64SlicePointer = &ValidFieldRequiredInt64SlicePointer
+	v.FieldRequiredUintSlicePointer = &ValidFieldRequiredUintSlicePointer
+	v.FieldRequiredUint8SlicePointer = &ValidFieldRequiredUint8SlicePointer
+	v.FieldRequiredUint16SlicePointer = &ValidFieldRequiredUint16SlicePointer
+	v.FieldRequiredUint32SlicePointer = &ValidFieldRequiredUint32SlicePointer
+	v.FieldRequiredUint64SlicePointer = &ValidFieldRequiredUint64SlicePointer
+	v.FieldRequiredFloat32SlicePointer = &ValidFieldRequiredFloat32SlicePointer
+	v.FieldRequiredFloat64SlicePointer = &ValidFieldRequiredFloat64SlicePointer
+	v.FieldRequiredBoolSlicePointer = &ValidFieldRequiredBoolSlicePointer
+	v.FieldRequiredStringArrayPointer = &ValidFieldRequiredStringArrayPointer
+	v.FieldRequiredIntArrayPointer = &ValidFieldRequiredIntArrayPointer
+	v.FieldRequiredInt8ArrayPointer = &ValidFieldRequiredInt8ArrayPointer
+	v.FieldRequiredInt16ArrayPointer = &ValidFieldRequiredInt16ArrayPointer
+	v.FieldRequiredInt32ArrayPointer = &ValidFieldRequiredInt32ArrayPointer
+	v.FieldRequiredInt64ArrayPointer = &ValidFieldRequiredInt64ArrayPointer
+	v.FieldRequiredUintArrayPointer = &ValidFieldRequiredUintArrayPointer
+	v.FieldRequiredUint8ArrayPointer = &ValidFieldRequiredUint8ArrayPointer
+	v.FieldRequiredUint16ArrayPointer = &ValidFieldRequiredUint16ArrayPointer
+	v.FieldRequiredUint32ArrayPointer = &ValidFieldRequiredUint32ArrayPointer
+	v.FieldRequiredUint64ArrayPointer = &ValidFieldRequiredUint64ArrayPointer
+	v.FieldRequiredFloat32ArrayPointer = &ValidFieldRequiredFloat32ArrayPointer
+	v.FieldRequiredFloat64ArrayPointer = &ValidFieldRequiredFloat64ArrayPointer
+	v.FieldRequiredBoolArrayPointer = &ValidFieldRequiredBoolArrayPointer
+	v.FieldRequiredStringMapPointer = &ValidFieldRequiredStringMapPointer
+	v.FieldRequiredIntMapPointer = &ValidFieldRequiredIntMapPointer
+	v.FieldRequiredInt8MapPointer = &ValidFieldRequiredInt8MapPointer
+	v.FieldRequiredInt16MapPointer = &ValidFieldRequiredInt16MapPointer
+	v.FieldRequiredInt32MapPointer = &ValidFieldRequiredInt32MapPointer
+	v.FieldRequiredInt64MapPointer = &ValidFieldRequiredInt64MapPointer
+	v.FieldRequiredUintMapPointer = &ValidFieldRequiredUintMapPointer
+	v.FieldRequiredUint8MapPointer = &ValidFieldRequiredUint8MapPointer
+	v.FieldRequiredUint16MapPointer = &ValidFieldRequiredUint16MapPointer
+	v.FieldRequiredUint32MapPointer = &ValidFieldRequiredUint32MapPointer
+	v.FieldRequiredUint64MapPointer = &ValidFieldRequiredUint64MapPointer
+	v.FieldRequiredFloat32MapPointer = &ValidFieldRequiredFloat32MapPointer
+	v.FieldRequiredFloat64MapPointer = &ValidFieldRequiredFloat64MapPointer
+	v.FieldRequiredBoolMapPointer = &ValidFieldRequiredBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = requiredStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("requiredStructFieldsPointer types tests ok")
+}
+
+type eqStructFieldsPointer struct {
+	FieldEqStringPointer  *string  `valid:"eq=abcde"`
+	FieldEqIntPointer     *int     `valid:"eq=32"`
+	FieldEqInt8Pointer    *int8    `valid:"eq=32"`
+	FieldEqInt16Pointer   *int16   `valid:"eq=32"`
+	FieldEqInt32Pointer   *int32   `valid:"eq=32"`
+	FieldEqInt64Pointer   *int64   `valid:"eq=32"`
+	FieldEqUintPointer    *uint    `valid:"eq=32"`
+	FieldEqUint8Pointer   *uint8   `valid:"eq=32"`
+	FieldEqUint16Pointer  *uint16  `valid:"eq=32"`
+	FieldEqUint32Pointer  *uint32  `valid:"eq=32"`
+	FieldEqUint64Pointer  *uint64  `valid:"eq=32"`
+	FieldEqFloat32Pointer *float32 `valid:"eq=12.34"`
+	FieldEqFloat64Pointer *float64 `valid:"eq=12.34"`
+	FieldEqBoolPointer    *bool    `valid:"eq=true"`
+}
+
+func eqStructFieldsPointerTests() {
+	log.Println("starting eqStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &eqStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldEqStringPointer must be equal to 'abcde'",
+		"FieldEqIntPointer must be equal to 32",
+		"FieldEqInt8Pointer must be equal to 32",
+		"FieldEqInt16Pointer must be equal to 32",
+		"FieldEqInt32Pointer must be equal to 32",
+		"FieldEqInt64Pointer must be equal to 32",
+		"FieldEqUintPointer must be equal to 32",
+		"FieldEqUint8Pointer must be equal to 32",
+		"FieldEqUint16Pointer must be equal to 32",
+		"FieldEqUint32Pointer must be equal to 32",
+		"FieldEqUint64Pointer must be equal to 32",
+		"FieldEqFloat32Pointer must be equal to 12.34",
+		"FieldEqFloat64Pointer must be equal to 12.34",
+		"FieldEqBoolPointer must be equal to true",
+	}
+	errs = eqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldEqStringPointer string = "fghij"
+	var InvalidFieldEqIntPointer int = 64
+	var InvalidFieldEqInt8Pointer int8 = 64
+	var InvalidFieldEqInt16Pointer int16 = 64
+	var InvalidFieldEqInt32Pointer int32 = 64
+	var InvalidFieldEqInt64Pointer int64 = 64
+	var InvalidFieldEqUintPointer uint = 64
+	var InvalidFieldEqUint8Pointer uint8 = 64
+	var InvalidFieldEqUint16Pointer uint16 = 64
+	var InvalidFieldEqUint32Pointer uint32 = 64
+	var InvalidFieldEqUint64Pointer uint64 = 64
+	var InvalidFieldEqFloat32Pointer float32 = 34.56
+	var InvalidFieldEqFloat64Pointer float64 = 34.56
+	var InvalidFieldEqBoolPointer bool = false
+
+	v = &eqStructFieldsPointer{}
+	v.FieldEqStringPointer = &InvalidFieldEqStringPointer
+	v.FieldEqIntPointer = &InvalidFieldEqIntPointer
+	v.FieldEqInt8Pointer = &InvalidFieldEqInt8Pointer
+	v.FieldEqInt16Pointer = &InvalidFieldEqInt16Pointer
+	v.FieldEqInt32Pointer = &InvalidFieldEqInt32Pointer
+	v.FieldEqInt64Pointer = &InvalidFieldEqInt64Pointer
+	v.FieldEqUintPointer = &InvalidFieldEqUintPointer
+	v.FieldEqUint8Pointer = &InvalidFieldEqUint8Pointer
+	v.FieldEqUint16Pointer = &InvalidFieldEqUint16Pointer
+	v.FieldEqUint32Pointer = &InvalidFieldEqUint32Pointer
+	v.FieldEqUint64Pointer = &InvalidFieldEqUint64Pointer
+	v.FieldEqFloat32Pointer = &InvalidFieldEqFloat32Pointer
+	v.FieldEqFloat64Pointer = &InvalidFieldEqFloat64Pointer
+	v.FieldEqBoolPointer = &InvalidFieldEqBoolPointer
+
+	errs = eqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldEqStringPointer string = "abcde"
+	var ValidFieldEqIntPointer int = 32
+	var ValidFieldEqInt8Pointer int8 = 32
+	var ValidFieldEqInt16Pointer int16 = 32
+	var ValidFieldEqInt32Pointer int32 = 32
+	var ValidFieldEqInt64Pointer int64 = 32
+	var ValidFieldEqUintPointer uint = 32
+	var ValidFieldEqUint8Pointer uint8 = 32
+	var ValidFieldEqUint16Pointer uint16 = 32
+	var ValidFieldEqUint32Pointer uint32 = 32
+	var ValidFieldEqUint64Pointer uint64 = 32
+	var ValidFieldEqFloat32Pointer float32 = 12.34
+	var ValidFieldEqFloat64Pointer float64 = 12.34
+	var ValidFieldEqBoolPointer bool = true
+
+	v = &eqStructFieldsPointer{}
+	v.FieldEqStringPointer = &ValidFieldEqStringPointer
+	v.FieldEqIntPointer = &ValidFieldEqIntPointer
+	v.FieldEqInt8Pointer = &ValidFieldEqInt8Pointer
+	v.FieldEqInt16Pointer = &ValidFieldEqInt16Pointer
+	v.FieldEqInt32Pointer = &ValidFieldEqInt32Pointer
+	v.FieldEqInt64Pointer = &ValidFieldEqInt64Pointer
+	v.FieldEqUintPointer = &ValidFieldEqUintPointer
+	v.FieldEqUint8Pointer = &ValidFieldEqUint8Pointer
+	v.FieldEqUint16Pointer = &ValidFieldEqUint16Pointer
+	v.FieldEqUint32Pointer = &ValidFieldEqUint32Pointer
+	v.FieldEqUint64Pointer = &ValidFieldEqUint64Pointer
+	v.FieldEqFloat32Pointer = &ValidFieldEqFloat32Pointer
+	v.FieldEqFloat64Pointer = &ValidFieldEqFloat64Pointer
+	v.FieldEqBoolPointer = &ValidFieldEqBoolPointer
+
+	expectedMsgErrors = nil
+	errs = eqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("eqStructFieldsPointer types tests ok")
+}
+
+type neqStructFieldsPointer struct {
+	FieldNeqStringPointer  *string  `valid:"neq=abcde"`
+	FieldNeqIntPointer     *int     `valid:"neq=32"`
+	FieldNeqInt8Pointer    *int8    `valid:"neq=32"`
+	FieldNeqInt16Pointer   *int16   `valid:"neq=32"`
+	FieldNeqInt32Pointer   *int32   `valid:"neq=32"`
+	FieldNeqInt64Pointer   *int64   `valid:"neq=32"`
+	FieldNeqUintPointer    *uint    `valid:"neq=32"`
+	FieldNeqUint8Pointer   *uint8   `valid:"neq=32"`
+	FieldNeqUint16Pointer  *uint16  `valid:"neq=32"`
+	FieldNeqUint32Pointer  *uint32  `valid:"neq=32"`
+	FieldNeqUint64Pointer  *uint64  `valid:"neq=32"`
+	FieldNeqFloat32Pointer *float32 `valid:"neq=12.34"`
+	FieldNeqFloat64Pointer *float64 `valid:"neq=12.34"`
+	FieldNeqBoolPointer    *bool    `valid:"neq=true"`
+}
+
+func neqStructFieldsPointerTests() {
+	log.Println("starting neqStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &neqStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldNeqStringPointer must not be equal to 'abcde'",
+		"FieldNeqIntPointer must not be equal to 32",
+		"FieldNeqInt8Pointer must not be equal to 32",
+		"FieldNeqInt16Pointer must not be equal to 32",
+		"FieldNeqInt32Pointer must not be equal to 32",
+		"FieldNeqInt64Pointer must not be equal to 32",
+		"FieldNeqUintPointer must not be equal to 32",
+		"FieldNeqUint8Pointer must not be equal to 32",
+		"FieldNeqUint16Pointer must not be equal to 32",
+		"FieldNeqUint32Pointer must not be equal to 32",
+		"FieldNeqUint64Pointer must not be equal to 32",
+		"FieldNeqFloat32Pointer must not be equal to 12.34",
+		"FieldNeqFloat64Pointer must not be equal to 12.34",
+		"FieldNeqBoolPointer must not be equal to true",
+	}
+	errs = neqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldNeqStringPointer string = "abcde"
+	var InvalidFieldNeqIntPointer int = 32
+	var InvalidFieldNeqInt8Pointer int8 = 32
+	var InvalidFieldNeqInt16Pointer int16 = 32
+	var InvalidFieldNeqInt32Pointer int32 = 32
+	var InvalidFieldNeqInt64Pointer int64 = 32
+	var InvalidFieldNeqUintPointer uint = 32
+	var InvalidFieldNeqUint8Pointer uint8 = 32
+	var InvalidFieldNeqUint16Pointer uint16 = 32
+	var InvalidFieldNeqUint32Pointer uint32 = 32
+	var InvalidFieldNeqUint64Pointer uint64 = 32
+	var InvalidFieldNeqFloat32Pointer float32 = 12.34
+	var InvalidFieldNeqFloat64Pointer float64 = 12.34
+	var InvalidFieldNeqBoolPointer bool = true
+
+	v = &neqStructFieldsPointer{}
+	v.FieldNeqStringPointer = &InvalidFieldNeqStringPointer
+	v.FieldNeqIntPointer = &InvalidFieldNeqIntPointer
+	v.FieldNeqInt8Pointer = &InvalidFieldNeqInt8Pointer
+	v.FieldNeqInt16Pointer = &InvalidFieldNeqInt16Pointer
+	v.FieldNeqInt32Pointer = &InvalidFieldNeqInt32Pointer
+	v.FieldNeqInt64Pointer = &InvalidFieldNeqInt64Pointer
+	v.FieldNeqUintPointer = &InvalidFieldNeqUintPointer
+	v.FieldNeqUint8Pointer = &InvalidFieldNeqUint8Pointer
+	v.FieldNeqUint16Pointer = &InvalidFieldNeqUint16Pointer
+	v.FieldNeqUint32Pointer = &InvalidFieldNeqUint32Pointer
+	v.FieldNeqUint64Pointer = &InvalidFieldNeqUint64Pointer
+	v.FieldNeqFloat32Pointer = &InvalidFieldNeqFloat32Pointer
+	v.FieldNeqFloat64Pointer = &InvalidFieldNeqFloat64Pointer
+	v.FieldNeqBoolPointer = &InvalidFieldNeqBoolPointer
+
+	errs = neqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldNeqStringPointer string = "fghij"
+	var ValidFieldNeqIntPointer int = 64
+	var ValidFieldNeqInt8Pointer int8 = 64
+	var ValidFieldNeqInt16Pointer int16 = 64
+	var ValidFieldNeqInt32Pointer int32 = 64
+	var ValidFieldNeqInt64Pointer int64 = 64
+	var ValidFieldNeqUintPointer uint = 64
+	var ValidFieldNeqUint8Pointer uint8 = 64
+	var ValidFieldNeqUint16Pointer uint16 = 64
+	var ValidFieldNeqUint32Pointer uint32 = 64
+	var ValidFieldNeqUint64Pointer uint64 = 64
+	var ValidFieldNeqFloat32Pointer float32 = 34.56
+	var ValidFieldNeqFloat64Pointer float64 = 34.56
+	var ValidFieldNeqBoolPointer bool = false
+
+	v = &neqStructFieldsPointer{}
+	v.FieldNeqStringPointer = &ValidFieldNeqStringPointer
+	v.FieldNeqIntPointer = &ValidFieldNeqIntPointer
+	v.FieldNeqInt8Pointer = &ValidFieldNeqInt8Pointer
+	v.FieldNeqInt16Pointer = &ValidFieldNeqInt16Pointer
+	v.FieldNeqInt32Pointer = &ValidFieldNeqInt32Pointer
+	v.FieldNeqInt64Pointer = &ValidFieldNeqInt64Pointer
+	v.FieldNeqUintPointer = &ValidFieldNeqUintPointer
+	v.FieldNeqUint8Pointer = &ValidFieldNeqUint8Pointer
+	v.FieldNeqUint16Pointer = &ValidFieldNeqUint16Pointer
+	v.FieldNeqUint32Pointer = &ValidFieldNeqUint32Pointer
+	v.FieldNeqUint64Pointer = &ValidFieldNeqUint64Pointer
+	v.FieldNeqFloat32Pointer = &ValidFieldNeqFloat32Pointer
+	v.FieldNeqFloat64Pointer = &ValidFieldNeqFloat64Pointer
+	v.FieldNeqBoolPointer = &ValidFieldNeqBoolPointer
+
+	expectedMsgErrors = nil
+	errs = neqStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("neqStructFieldsPointer types tests ok")
+}
+
+type gtStructFieldsPointer struct {
+	FieldGtIntPointer     *int     `valid:"gt=32"`
+	FieldGtInt8Pointer    *int8    `valid:"gt=32"`
+	FieldGtInt16Pointer   *int16   `valid:"gt=32"`
+	FieldGtInt32Pointer   *int32   `valid:"gt=32"`
+	FieldGtInt64Pointer   *int64   `valid:"gt=32"`
+	FieldGtUintPointer    *uint    `valid:"gt=32"`
+	FieldGtUint8Pointer   *uint8   `valid:"gt=32"`
+	FieldGtUint16Pointer  *uint16  `valid:"gt=32"`
+	FieldGtUint32Pointer  *uint32  `valid:"gt=32"`
+	FieldGtUint64Pointer  *uint64  `valid:"gt=32"`
+	FieldGtFloat32Pointer *float32 `valid:"gt=12.34"`
+	FieldGtFloat64Pointer *float64 `valid:"gt=12.34"`
+}
+
+func gtStructFieldsPointerTests() {
+	log.Println("starting gtStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &gtStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldGtIntPointer must be > 32",
+		"FieldGtInt8Pointer must be > 32",
+		"FieldGtInt16Pointer must be > 32",
+		"FieldGtInt32Pointer must be > 32",
+		"FieldGtInt64Pointer must be > 32",
+		"FieldGtUintPointer must be > 32",
+		"FieldGtUint8Pointer must be > 32",
+		"FieldGtUint16Pointer must be > 32",
+		"FieldGtUint32Pointer must be > 32",
+		"FieldGtUint64Pointer must be > 32",
+		"FieldGtFloat32Pointer must be > 12.34",
+		"FieldGtFloat64Pointer must be > 12.34",
+	}
+	errs = gtStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldGtIntPointer int = 31
+	var InvalidFieldGtInt8Pointer int8 = 31
+	var InvalidFieldGtInt16Pointer int16 = 31
+	var InvalidFieldGtInt32Pointer int32 = 31
+	var InvalidFieldGtInt64Pointer int64 = 31
+	var InvalidFieldGtUintPointer uint = 31
+	var InvalidFieldGtUint8Pointer uint8 = 31
+	var InvalidFieldGtUint16Pointer uint16 = 31
+	var InvalidFieldGtUint32Pointer uint32 = 31
+	var InvalidFieldGtUint64Pointer uint64 = 31
+	var InvalidFieldGtFloat32Pointer float32 = 12.34
+	var InvalidFieldGtFloat64Pointer float64 = 12.34
+
+	v = &gtStructFieldsPointer{}
+	v.FieldGtIntPointer = &InvalidFieldGtIntPointer
+	v.FieldGtInt8Pointer = &InvalidFieldGtInt8Pointer
+	v.FieldGtInt16Pointer = &InvalidFieldGtInt16Pointer
+	v.FieldGtInt32Pointer = &InvalidFieldGtInt32Pointer
+	v.FieldGtInt64Pointer = &InvalidFieldGtInt64Pointer
+	v.FieldGtUintPointer = &InvalidFieldGtUintPointer
+	v.FieldGtUint8Pointer = &InvalidFieldGtUint8Pointer
+	v.FieldGtUint16Pointer = &InvalidFieldGtUint16Pointer
+	v.FieldGtUint32Pointer = &InvalidFieldGtUint32Pointer
+	v.FieldGtUint64Pointer = &InvalidFieldGtUint64Pointer
+	v.FieldGtFloat32Pointer = &InvalidFieldGtFloat32Pointer
+	v.FieldGtFloat64Pointer = &InvalidFieldGtFloat64Pointer
+
+	errs = gtStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldGtIntPointer int = 33
+	var ValidFieldGtInt8Pointer int8 = 33
+	var ValidFieldGtInt16Pointer int16 = 33
+	var ValidFieldGtInt32Pointer int32 = 33
+	var ValidFieldGtInt64Pointer int64 = 33
+	var ValidFieldGtUintPointer uint = 33
+	var ValidFieldGtUint8Pointer uint8 = 33
+	var ValidFieldGtUint16Pointer uint16 = 33
+	var ValidFieldGtUint32Pointer uint32 = 33
+	var ValidFieldGtUint64Pointer uint64 = 33
+	var ValidFieldGtFloat32Pointer float32 = 12.35
+	var ValidFieldGtFloat64Pointer float64 = 12.35
+
+	v = &gtStructFieldsPointer{}
+	v.FieldGtIntPointer = &ValidFieldGtIntPointer
+	v.FieldGtInt8Pointer = &ValidFieldGtInt8Pointer
+	v.FieldGtInt16Pointer = &ValidFieldGtInt16Pointer
+	v.FieldGtInt32Pointer = &ValidFieldGtInt32Pointer
+	v.FieldGtInt64Pointer = &ValidFieldGtInt64Pointer
+	v.FieldGtUintPointer = &ValidFieldGtUintPointer
+	v.FieldGtUint8Pointer = &ValidFieldGtUint8Pointer
+	v.FieldGtUint16Pointer = &ValidFieldGtUint16Pointer
+	v.FieldGtUint32Pointer = &ValidFieldGtUint32Pointer
+	v.FieldGtUint64Pointer = &ValidFieldGtUint64Pointer
+	v.FieldGtFloat32Pointer = &ValidFieldGtFloat32Pointer
+	v.FieldGtFloat64Pointer = &ValidFieldGtFloat64Pointer
+
+	expectedMsgErrors = nil
+	errs = gtStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("gtStructFieldsPointer types tests ok")
+}
+
+type gteStructFieldsPointer struct {
+	FieldGteIntPointer     *int     `valid:"gte=32"`
+	FieldGteInt8Pointer    *int8    `valid:"gte=32"`
+	FieldGteInt16Pointer   *int16   `valid:"gte=32"`
+	FieldGteInt32Pointer   *int32   `valid:"gte=32"`
+	FieldGteInt64Pointer   *int64   `valid:"gte=32"`
+	FieldGteUintPointer    *uint    `valid:"gte=32"`
+	FieldGteUint8Pointer   *uint8   `valid:"gte=32"`
+	FieldGteUint16Pointer  *uint16  `valid:"gte=32"`
+	FieldGteUint32Pointer  *uint32  `valid:"gte=32"`
+	FieldGteUint64Pointer  *uint64  `valid:"gte=32"`
+	FieldGteFloat32Pointer *float32 `valid:"gte=12.34"`
+	FieldGteFloat64Pointer *float64 `valid:"gte=12.34"`
+}
+
+func gteStructFieldsPointerTests() {
+	log.Println("starting gteStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &gteStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldGteIntPointer must be >= 32",
+		"FieldGteInt8Pointer must be >= 32",
+		"FieldGteInt16Pointer must be >= 32",
+		"FieldGteInt32Pointer must be >= 32",
+		"FieldGteInt64Pointer must be >= 32",
+		"FieldGteUintPointer must be >= 32",
+		"FieldGteUint8Pointer must be >= 32",
+		"FieldGteUint16Pointer must be >= 32",
+		"FieldGteUint32Pointer must be >= 32",
+		"FieldGteUint64Pointer must be >= 32",
+		"FieldGteFloat32Pointer must be >= 12.34",
+		"FieldGteFloat64Pointer must be >= 12.34",
+	}
+	errs = gteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldGteIntPointer int = 31
+	var InvalidFieldGteInt8Pointer int8 = 31
+	var InvalidFieldGteInt16Pointer int16 = 31
+	var InvalidFieldGteInt32Pointer int32 = 31
+	var InvalidFieldGteInt64Pointer int64 = 31
+	var InvalidFieldGteUintPointer uint = 31
+	var InvalidFieldGteUint8Pointer uint8 = 31
+	var InvalidFieldGteUint16Pointer uint16 = 31
+	var InvalidFieldGteUint32Pointer uint32 = 31
+	var InvalidFieldGteUint64Pointer uint64 = 31
+	var InvalidFieldGteFloat32Pointer float32 = 12.33
+	var InvalidFieldGteFloat64Pointer float64 = 12.33
+
+	v = &gteStructFieldsPointer{}
+	v.FieldGteIntPointer = &InvalidFieldGteIntPointer
+	v.FieldGteInt8Pointer = &InvalidFieldGteInt8Pointer
+	v.FieldGteInt16Pointer = &InvalidFieldGteInt16Pointer
+	v.FieldGteInt32Pointer = &InvalidFieldGteInt32Pointer
+	v.FieldGteInt64Pointer = &InvalidFieldGteInt64Pointer
+	v.FieldGteUintPointer = &InvalidFieldGteUintPointer
+	v.FieldGteUint8Pointer = &InvalidFieldGteUint8Pointer
+	v.FieldGteUint16Pointer = &InvalidFieldGteUint16Pointer
+	v.FieldGteUint32Pointer = &InvalidFieldGteUint32Pointer
+	v.FieldGteUint64Pointer = &InvalidFieldGteUint64Pointer
+	v.FieldGteFloat32Pointer = &InvalidFieldGteFloat32Pointer
+	v.FieldGteFloat64Pointer = &InvalidFieldGteFloat64Pointer
+
+	errs = gteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldGteIntPointer int = 32
+	var ValidFieldGteInt8Pointer int8 = 32
+	var ValidFieldGteInt16Pointer int16 = 32
+	var ValidFieldGteInt32Pointer int32 = 32
+	var ValidFieldGteInt64Pointer int64 = 32
+	var ValidFieldGteUintPointer uint = 32
+	var ValidFieldGteUint8Pointer uint8 = 32
+	var ValidFieldGteUint16Pointer uint16 = 32
+	var ValidFieldGteUint32Pointer uint32 = 32
+	var ValidFieldGteUint64Pointer uint64 = 32
+	var ValidFieldGteFloat32Pointer float32 = 12.34
+	var ValidFieldGteFloat64Pointer float64 = 12.34
+
+	v = &gteStructFieldsPointer{}
+	v.FieldGteIntPointer = &ValidFieldGteIntPointer
+	v.FieldGteInt8Pointer = &ValidFieldGteInt8Pointer
+	v.FieldGteInt16Pointer = &ValidFieldGteInt16Pointer
+	v.FieldGteInt32Pointer = &ValidFieldGteInt32Pointer
+	v.FieldGteInt64Pointer = &ValidFieldGteInt64Pointer
+	v.FieldGteUintPointer = &ValidFieldGteUintPointer
+	v.FieldGteUint8Pointer = &ValidFieldGteUint8Pointer
+	v.FieldGteUint16Pointer = &ValidFieldGteUint16Pointer
+	v.FieldGteUint32Pointer = &ValidFieldGteUint32Pointer
+	v.FieldGteUint64Pointer = &ValidFieldGteUint64Pointer
+	v.FieldGteFloat32Pointer = &ValidFieldGteFloat32Pointer
+	v.FieldGteFloat64Pointer = &ValidFieldGteFloat64Pointer
+
+	expectedMsgErrors = nil
+	errs = gteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("gteStructFieldsPointer types tests ok")
+}
+
+type ltStructFieldsPointer struct {
+	FieldLtIntPointer     *int     `valid:"lt=32"`
+	FieldLtInt8Pointer    *int8    `valid:"lt=32"`
+	FieldLtInt16Pointer   *int16   `valid:"lt=32"`
+	FieldLtInt32Pointer   *int32   `valid:"lt=32"`
+	FieldLtInt64Pointer   *int64   `valid:"lt=32"`
+	FieldLtUintPointer    *uint    `valid:"lt=32"`
+	FieldLtUint8Pointer   *uint8   `valid:"lt=32"`
+	FieldLtUint16Pointer  *uint16  `valid:"lt=32"`
+	FieldLtUint32Pointer  *uint32  `valid:"lt=32"`
+	FieldLtUint64Pointer  *uint64  `valid:"lt=32"`
+	FieldLtFloat32Pointer *float32 `valid:"lt=12.34"`
+	FieldLtFloat64Pointer *float64 `valid:"lt=12.34"`
+}
+
+func ltStructFieldsPointerTests() {
+	log.Println("starting ltStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &ltStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldLtIntPointer must be < 32",
+		"FieldLtInt8Pointer must be < 32",
+		"FieldLtInt16Pointer must be < 32",
+		"FieldLtInt32Pointer must be < 32",
+		"FieldLtInt64Pointer must be < 32",
+		"FieldLtUintPointer must be < 32",
+		"FieldLtUint8Pointer must be < 32",
+		"FieldLtUint16Pointer must be < 32",
+		"FieldLtUint32Pointer must be < 32",
+		"FieldLtUint64Pointer must be < 32",
+		"FieldLtFloat32Pointer must be < 12.34",
+		"FieldLtFloat64Pointer must be < 12.34",
+	}
+	errs = ltStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldLtIntPointer int = 33
+	var InvalidFieldLtInt8Pointer int8 = 33
+	var InvalidFieldLtInt16Pointer int16 = 33
+	var InvalidFieldLtInt32Pointer int32 = 33
+	var InvalidFieldLtInt64Pointer int64 = 33
+	var InvalidFieldLtUintPointer uint = 33
+	var InvalidFieldLtUint8Pointer uint8 = 33
+	var InvalidFieldLtUint16Pointer uint16 = 33
+	var InvalidFieldLtUint32Pointer uint32 = 33
+	var InvalidFieldLtUint64Pointer uint64 = 33
+	var InvalidFieldLtFloat32Pointer float32 = 12.35
+	var InvalidFieldLtFloat64Pointer float64 = 12.35
+
+	v = &ltStructFieldsPointer{}
+	v.FieldLtIntPointer = &InvalidFieldLtIntPointer
+	v.FieldLtInt8Pointer = &InvalidFieldLtInt8Pointer
+	v.FieldLtInt16Pointer = &InvalidFieldLtInt16Pointer
+	v.FieldLtInt32Pointer = &InvalidFieldLtInt32Pointer
+	v.FieldLtInt64Pointer = &InvalidFieldLtInt64Pointer
+	v.FieldLtUintPointer = &InvalidFieldLtUintPointer
+	v.FieldLtUint8Pointer = &InvalidFieldLtUint8Pointer
+	v.FieldLtUint16Pointer = &InvalidFieldLtUint16Pointer
+	v.FieldLtUint32Pointer = &InvalidFieldLtUint32Pointer
+	v.FieldLtUint64Pointer = &InvalidFieldLtUint64Pointer
+	v.FieldLtFloat32Pointer = &InvalidFieldLtFloat32Pointer
+	v.FieldLtFloat64Pointer = &InvalidFieldLtFloat64Pointer
+
+	errs = ltStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldLtIntPointer int = 31
+	var ValidFieldLtInt8Pointer int8 = 31
+	var ValidFieldLtInt16Pointer int16 = 31
+	var ValidFieldLtInt32Pointer int32 = 31
+	var ValidFieldLtInt64Pointer int64 = 31
+	var ValidFieldLtUintPointer uint = 31
+	var ValidFieldLtUint8Pointer uint8 = 31
+	var ValidFieldLtUint16Pointer uint16 = 31
+	var ValidFieldLtUint32Pointer uint32 = 31
+	var ValidFieldLtUint64Pointer uint64 = 31
+	var ValidFieldLtFloat32Pointer float32 = 12.33
+	var ValidFieldLtFloat64Pointer float64 = 12.33
+
+	v = &ltStructFieldsPointer{}
+	v.FieldLtIntPointer = &ValidFieldLtIntPointer
+	v.FieldLtInt8Pointer = &ValidFieldLtInt8Pointer
+	v.FieldLtInt16Pointer = &ValidFieldLtInt16Pointer
+	v.FieldLtInt32Pointer = &ValidFieldLtInt32Pointer
+	v.FieldLtInt64Pointer = &ValidFieldLtInt64Pointer
+	v.FieldLtUintPointer = &ValidFieldLtUintPointer
+	v.FieldLtUint8Pointer = &ValidFieldLtUint8Pointer
+	v.FieldLtUint16Pointer = &ValidFieldLtUint16Pointer
+	v.FieldLtUint32Pointer = &ValidFieldLtUint32Pointer
+	v.FieldLtUint64Pointer = &ValidFieldLtUint64Pointer
+	v.FieldLtFloat32Pointer = &ValidFieldLtFloat32Pointer
+	v.FieldLtFloat64Pointer = &ValidFieldLtFloat64Pointer
+
+	expectedMsgErrors = nil
+	errs = ltStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("ltStructFieldsPointer types tests ok")
+}
+
+type lteStructFieldsPointer struct {
+	FieldLteIntPointer     *int     `valid:"lte=32"`
+	FieldLteInt8Pointer    *int8    `valid:"lte=32"`
+	FieldLteInt16Pointer   *int16   `valid:"lte=32"`
+	FieldLteInt32Pointer   *int32   `valid:"lte=32"`
+	FieldLteInt64Pointer   *int64   `valid:"lte=32"`
+	FieldLteUintPointer    *uint    `valid:"lte=32"`
+	FieldLteUint8Pointer   *uint8   `valid:"lte=32"`
+	FieldLteUint16Pointer  *uint16  `valid:"lte=32"`
+	FieldLteUint32Pointer  *uint32  `valid:"lte=32"`
+	FieldLteUint64Pointer  *uint64  `valid:"lte=32"`
+	FieldLteFloat32Pointer *float32 `valid:"lte=12.34"`
+	FieldLteFloat64Pointer *float64 `valid:"lte=12.34"`
+}
+
+func lteStructFieldsPointerTests() {
+	log.Println("starting lteStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &lteStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldLteIntPointer must be <= 32",
+		"FieldLteInt8Pointer must be <= 32",
+		"FieldLteInt16Pointer must be <= 32",
+		"FieldLteInt32Pointer must be <= 32",
+		"FieldLteInt64Pointer must be <= 32",
+		"FieldLteUintPointer must be <= 32",
+		"FieldLteUint8Pointer must be <= 32",
+		"FieldLteUint16Pointer must be <= 32",
+		"FieldLteUint32Pointer must be <= 32",
+		"FieldLteUint64Pointer must be <= 32",
+		"FieldLteFloat32Pointer must be <= 12.34",
+		"FieldLteFloat64Pointer must be <= 12.34",
+	}
+	errs = lteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldLteIntPointer int = 33
+	var InvalidFieldLteInt8Pointer int8 = 33
+	var InvalidFieldLteInt16Pointer int16 = 33
+	var InvalidFieldLteInt32Pointer int32 = 33
+	var InvalidFieldLteInt64Pointer int64 = 33
+	var InvalidFieldLteUintPointer uint = 33
+	var InvalidFieldLteUint8Pointer uint8 = 33
+	var InvalidFieldLteUint16Pointer uint16 = 33
+	var InvalidFieldLteUint32Pointer uint32 = 33
+	var InvalidFieldLteUint64Pointer uint64 = 33
+	var InvalidFieldLteFloat32Pointer float32 = 12.35
+	var InvalidFieldLteFloat64Pointer float64 = 12.35
+
+	v = &lteStructFieldsPointer{}
+	v.FieldLteIntPointer = &InvalidFieldLteIntPointer
+	v.FieldLteInt8Pointer = &InvalidFieldLteInt8Pointer
+	v.FieldLteInt16Pointer = &InvalidFieldLteInt16Pointer
+	v.FieldLteInt32Pointer = &InvalidFieldLteInt32Pointer
+	v.FieldLteInt64Pointer = &InvalidFieldLteInt64Pointer
+	v.FieldLteUintPointer = &InvalidFieldLteUintPointer
+	v.FieldLteUint8Pointer = &InvalidFieldLteUint8Pointer
+	v.FieldLteUint16Pointer = &InvalidFieldLteUint16Pointer
+	v.FieldLteUint32Pointer = &InvalidFieldLteUint32Pointer
+	v.FieldLteUint64Pointer = &InvalidFieldLteUint64Pointer
+	v.FieldLteFloat32Pointer = &InvalidFieldLteFloat32Pointer
+	v.FieldLteFloat64Pointer = &InvalidFieldLteFloat64Pointer
+
+	errs = lteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldLteIntPointer int = 32
+	var ValidFieldLteInt8Pointer int8 = 32
+	var ValidFieldLteInt16Pointer int16 = 32
+	var ValidFieldLteInt32Pointer int32 = 32
+	var ValidFieldLteInt64Pointer int64 = 32
+	var ValidFieldLteUintPointer uint = 32
+	var ValidFieldLteUint8Pointer uint8 = 32
+	var ValidFieldLteUint16Pointer uint16 = 32
+	var ValidFieldLteUint32Pointer uint32 = 32
+	var ValidFieldLteUint64Pointer uint64 = 32
+	var ValidFieldLteFloat32Pointer float32 = 12.34
+	var ValidFieldLteFloat64Pointer float64 = 12.34
+
+	v = &lteStructFieldsPointer{}
+	v.FieldLteIntPointer = &ValidFieldLteIntPointer
+	v.FieldLteInt8Pointer = &ValidFieldLteInt8Pointer
+	v.FieldLteInt16Pointer = &ValidFieldLteInt16Pointer
+	v.FieldLteInt32Pointer = &ValidFieldLteInt32Pointer
+	v.FieldLteInt64Pointer = &ValidFieldLteInt64Pointer
+	v.FieldLteUintPointer = &ValidFieldLteUintPointer
+	v.FieldLteUint8Pointer = &ValidFieldLteUint8Pointer
+	v.FieldLteUint16Pointer = &ValidFieldLteUint16Pointer
+	v.FieldLteUint32Pointer = &ValidFieldLteUint32Pointer
+	v.FieldLteUint64Pointer = &ValidFieldLteUint64Pointer
+	v.FieldLteFloat32Pointer = &ValidFieldLteFloat32Pointer
+	v.FieldLteFloat64Pointer = &ValidFieldLteFloat64Pointer
+
+	expectedMsgErrors = nil
+	errs = lteStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("lteStructFieldsPointer types tests ok")
+}
+
+type minStructFieldsPointer struct {
+	FieldMinStringPointer       *string              `valid:"min=5"`
+	FieldMinStringSlicePointer  *[]string            `valid:"min=2"`
+	FieldMinIntSlicePointer     *[]int               `valid:"min=2"`
+	FieldMinInt8SlicePointer    *[]int8              `valid:"min=2"`
+	FieldMinInt16SlicePointer   *[]int16             `valid:"min=2"`
+	FieldMinInt32SlicePointer   *[]int32             `valid:"min=2"`
+	FieldMinInt64SlicePointer   *[]int64             `valid:"min=2"`
+	FieldMinUintSlicePointer    *[]uint              `valid:"min=2"`
+	FieldMinUint8SlicePointer   *[]uint8             `valid:"min=2"`
+	FieldMinUint16SlicePointer  *[]uint16            `valid:"min=2"`
+	FieldMinUint32SlicePointer  *[]uint32            `valid:"min=2"`
+	FieldMinUint64SlicePointer  *[]uint64            `valid:"min=2"`
+	FieldMinFloat32SlicePointer *[]float32           `valid:"min=2"`
+	FieldMinFloat64SlicePointer *[]float64           `valid:"min=2"`
+	FieldMinBoolSlicePointer    *[]bool              `valid:"min=2"`
+	FieldMinStringMapPointer    *map[string]string   `valid:"min=2"`
+	FieldMinIntMapPointer       *map[int]int         `valid:"min=2"`
+	FieldMinInt8MapPointer      *map[int8]int8       `valid:"min=2"`
+	FieldMinInt16MapPointer     *map[int16]int16     `valid:"min=2"`
+	FieldMinInt32MapPointer     *map[int32]int32     `valid:"min=2"`
+	FieldMinInt64MapPointer     *map[int64]int64     `valid:"min=2"`
+	FieldMinUintMapPointer      *map[uint]uint       `valid:"min=2"`
+	FieldMinUint8MapPointer     *map[uint8]uint8     `valid:"min=2"`
+	FieldMinUint16MapPointer    *map[uint16]uint16   `valid:"min=2"`
+	FieldMinUint32MapPointer    *map[uint32]uint32   `valid:"min=2"`
+	FieldMinUint64MapPointer    *map[uint64]uint64   `valid:"min=2"`
+	FieldMinFloat32MapPointer   *map[float32]float32 `valid:"min=2"`
+	FieldMinFloat64MapPointer   *map[float64]float64 `valid:"min=2"`
+	FieldMinBoolMapPointer      *map[bool]bool       `valid:"min=2"`
+}
+
+func minStructFieldsPointerTests() {
+	log.Println("starting minStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &minStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldMinStringPointer length must be >= 5",
+		"FieldMinStringSlicePointer must have at least 2 elements",
+		"FieldMinIntSlicePointer must have at least 2 elements",
+		"FieldMinInt8SlicePointer must have at least 2 elements",
+		"FieldMinInt16SlicePointer must have at least 2 elements",
+		"FieldMinInt32SlicePointer must have at least 2 elements",
+		"FieldMinInt64SlicePointer must have at least 2 elements",
+		"FieldMinUintSlicePointer must have at least 2 elements",
+		"FieldMinUint8SlicePointer must have at least 2 elements",
+		"FieldMinUint16SlicePointer must have at least 2 elements",
+		"FieldMinUint32SlicePointer must have at least 2 elements",
+		"FieldMinUint64SlicePointer must have at least 2 elements",
+		"FieldMinFloat32SlicePointer must have at least 2 elements",
+		"FieldMinFloat64SlicePointer must have at least 2 elements",
+		"FieldMinBoolSlicePointer must have at least 2 elements",
+		"FieldMinStringMapPointer must have at least 2 elements",
+		"FieldMinIntMapPointer must have at least 2 elements",
+		"FieldMinInt8MapPointer must have at least 2 elements",
+		"FieldMinInt16MapPointer must have at least 2 elements",
+		"FieldMinInt32MapPointer must have at least 2 elements",
+		"FieldMinInt64MapPointer must have at least 2 elements",
+		"FieldMinUintMapPointer must have at least 2 elements",
+		"FieldMinUint8MapPointer must have at least 2 elements",
+		"FieldMinUint16MapPointer must have at least 2 elements",
+		"FieldMinUint32MapPointer must have at least 2 elements",
+		"FieldMinUint64MapPointer must have at least 2 elements",
+		"FieldMinFloat32MapPointer must have at least 2 elements",
+		"FieldMinFloat64MapPointer must have at least 2 elements",
+		"FieldMinBoolMapPointer must have at least 2 elements",
+	}
+	errs = minStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldMinStringPointer string = "abc"
+	var InvalidFieldMinStringSlicePointer []string = []string{"abc"}
+	var InvalidFieldMinIntSlicePointer []int = []int{65}
+	var InvalidFieldMinInt8SlicePointer []int8 = []int8{65}
+	var InvalidFieldMinInt16SlicePointer []int16 = []int16{65}
+	var InvalidFieldMinInt32SlicePointer []int32 = []int32{65}
+	var InvalidFieldMinInt64SlicePointer []int64 = []int64{65}
+	var InvalidFieldMinUintSlicePointer []uint = []uint{65}
+	var InvalidFieldMinUint8SlicePointer []uint8 = []uint8{65}
+	var InvalidFieldMinUint16SlicePointer []uint16 = []uint16{65}
+	var InvalidFieldMinUint32SlicePointer []uint32 = []uint32{65}
+	var InvalidFieldMinUint64SlicePointer []uint64 = []uint64{65}
+	var InvalidFieldMinFloat32SlicePointer []float32 = []float32{65.65}
+	var InvalidFieldMinFloat64SlicePointer []float64 = []float64{65.65}
+	var InvalidFieldMinBoolSlicePointer []bool = []bool{true}
+	var InvalidFieldMinStringMapPointer map[string]string = map[string]string{"a": "1"}
+	var InvalidFieldMinIntMapPointer map[int]int = map[int]int{1: 65}
+	var InvalidFieldMinInt8MapPointer map[int8]int8 = map[int8]int8{1: 65}
+	var InvalidFieldMinInt16MapPointer map[int16]int16 = map[int16]int16{1: 65}
+	var InvalidFieldMinInt32MapPointer map[int32]int32 = map[int32]int32{1: 65}
+	var InvalidFieldMinInt64MapPointer map[int64]int64 = map[int64]int64{1: 65}
+	var InvalidFieldMinUintMapPointer map[uint]uint = map[uint]uint{1: 65}
+	var InvalidFieldMinUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65}
+	var InvalidFieldMinUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65}
+	var InvalidFieldMinUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65}
+	var InvalidFieldMinUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65}
+	var InvalidFieldMinFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65}
+	var InvalidFieldMinFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65}
+	var InvalidFieldMinBoolMapPointer map[bool]bool = map[bool]bool{true: true}
+
+	v = &minStructFieldsPointer{}
+	v.FieldMinStringPointer = &InvalidFieldMinStringPointer
+	v.FieldMinStringSlicePointer = &InvalidFieldMinStringSlicePointer
+	v.FieldMinIntSlicePointer = &InvalidFieldMinIntSlicePointer
+	v.FieldMinInt8SlicePointer = &InvalidFieldMinInt8SlicePointer
+	v.FieldMinInt16SlicePointer = &InvalidFieldMinInt16SlicePointer
+	v.FieldMinInt32SlicePointer = &InvalidFieldMinInt32SlicePointer
+	v.FieldMinInt64SlicePointer = &InvalidFieldMinInt64SlicePointer
+	v.FieldMinUintSlicePointer = &InvalidFieldMinUintSlicePointer
+	v.FieldMinUint8SlicePointer = &InvalidFieldMinUint8SlicePointer
+	v.FieldMinUint16SlicePointer = &InvalidFieldMinUint16SlicePointer
+	v.FieldMinUint32SlicePointer = &InvalidFieldMinUint32SlicePointer
+	v.FieldMinUint64SlicePointer = &InvalidFieldMinUint64SlicePointer
+	v.FieldMinFloat32SlicePointer = &InvalidFieldMinFloat32SlicePointer
+	v.FieldMinFloat64SlicePointer = &InvalidFieldMinFloat64SlicePointer
+	v.FieldMinBoolSlicePointer = &InvalidFieldMinBoolSlicePointer
+	v.FieldMinStringMapPointer = &InvalidFieldMinStringMapPointer
+	v.FieldMinIntMapPointer = &InvalidFieldMinIntMapPointer
+	v.FieldMinInt8MapPointer = &InvalidFieldMinInt8MapPointer
+	v.FieldMinInt16MapPointer = &InvalidFieldMinInt16MapPointer
+	v.FieldMinInt32MapPointer = &InvalidFieldMinInt32MapPointer
+	v.FieldMinInt64MapPointer = &InvalidFieldMinInt64MapPointer
+	v.FieldMinUintMapPointer = &InvalidFieldMinUintMapPointer
+	v.FieldMinUint8MapPointer = &InvalidFieldMinUint8MapPointer
+	v.FieldMinUint16MapPointer = &InvalidFieldMinUint16MapPointer
+	v.FieldMinUint32MapPointer = &InvalidFieldMinUint32MapPointer
+	v.FieldMinUint64MapPointer = &InvalidFieldMinUint64MapPointer
+	v.FieldMinFloat32MapPointer = &InvalidFieldMinFloat32MapPointer
+	v.FieldMinFloat64MapPointer = &InvalidFieldMinFloat64MapPointer
+	v.FieldMinBoolMapPointer = &InvalidFieldMinBoolMapPointer
+
+	errs = minStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldMinStringPointer string = "abcde"
+	var ValidFieldMinStringSlicePointer []string = []string{"abc", "def"}
+	var ValidFieldMinIntSlicePointer []int = []int{65, 67}
+	var ValidFieldMinInt8SlicePointer []int8 = []int8{65, 67}
+	var ValidFieldMinInt16SlicePointer []int16 = []int16{65, 67}
+	var ValidFieldMinInt32SlicePointer []int32 = []int32{65, 67}
+	var ValidFieldMinInt64SlicePointer []int64 = []int64{65, 67}
+	var ValidFieldMinUintSlicePointer []uint = []uint{65, 67}
+	var ValidFieldMinUint8SlicePointer []uint8 = []uint8{65, 67}
+	var ValidFieldMinUint16SlicePointer []uint16 = []uint16{65, 67}
+	var ValidFieldMinUint32SlicePointer []uint32 = []uint32{65, 67}
+	var ValidFieldMinUint64SlicePointer []uint64 = []uint64{65, 67}
+	var ValidFieldMinFloat32SlicePointer []float32 = []float32{65.65, 67.67}
+	var ValidFieldMinFloat64SlicePointer []float64 = []float64{65.65, 67.67}
+	var ValidFieldMinBoolSlicePointer []bool = []bool{true, false}
+	var ValidFieldMinStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2"}
+	var ValidFieldMinIntMapPointer map[int]int = map[int]int{1: 65, 2: 67}
+	var ValidFieldMinInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67}
+	var ValidFieldMinInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67}
+	var ValidFieldMinInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67}
+	var ValidFieldMinInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67}
+	var ValidFieldMinUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67}
+	var ValidFieldMinUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67}
+	var ValidFieldMinUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67}
+	var ValidFieldMinUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67}
+	var ValidFieldMinUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67}
+	var ValidFieldMinFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65, 2: 67.67}
+	var ValidFieldMinFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65, 2: 67.67}
+	var ValidFieldMinBoolMapPointer map[bool]bool = map[bool]bool{true: true, false: false}
+
+	v = &minStructFieldsPointer{}
+	v.FieldMinStringPointer = &ValidFieldMinStringPointer
+	v.FieldMinStringSlicePointer = &ValidFieldMinStringSlicePointer
+	v.FieldMinIntSlicePointer = &ValidFieldMinIntSlicePointer
+	v.FieldMinInt8SlicePointer = &ValidFieldMinInt8SlicePointer
+	v.FieldMinInt16SlicePointer = &ValidFieldMinInt16SlicePointer
+	v.FieldMinInt32SlicePointer = &ValidFieldMinInt32SlicePointer
+	v.FieldMinInt64SlicePointer = &ValidFieldMinInt64SlicePointer
+	v.FieldMinUintSlicePointer = &ValidFieldMinUintSlicePointer
+	v.FieldMinUint8SlicePointer = &ValidFieldMinUint8SlicePointer
+	v.FieldMinUint16SlicePointer = &ValidFieldMinUint16SlicePointer
+	v.FieldMinUint32SlicePointer = &ValidFieldMinUint32SlicePointer
+	v.FieldMinUint64SlicePointer = &ValidFieldMinUint64SlicePointer
+	v.FieldMinFloat32SlicePointer = &ValidFieldMinFloat32SlicePointer
+	v.FieldMinFloat64SlicePointer = &ValidFieldMinFloat64SlicePointer
+	v.FieldMinBoolSlicePointer = &ValidFieldMinBoolSlicePointer
+	v.FieldMinStringMapPointer = &ValidFieldMinStringMapPointer
+	v.FieldMinIntMapPointer = &ValidFieldMinIntMapPointer
+	v.FieldMinInt8MapPointer = &ValidFieldMinInt8MapPointer
+	v.FieldMinInt16MapPointer = &ValidFieldMinInt16MapPointer
+	v.FieldMinInt32MapPointer = &ValidFieldMinInt32MapPointer
+	v.FieldMinInt64MapPointer = &ValidFieldMinInt64MapPointer
+	v.FieldMinUintMapPointer = &ValidFieldMinUintMapPointer
+	v.FieldMinUint8MapPointer = &ValidFieldMinUint8MapPointer
+	v.FieldMinUint16MapPointer = &ValidFieldMinUint16MapPointer
+	v.FieldMinUint32MapPointer = &ValidFieldMinUint32MapPointer
+	v.FieldMinUint64MapPointer = &ValidFieldMinUint64MapPointer
+	v.FieldMinFloat32MapPointer = &ValidFieldMinFloat32MapPointer
+	v.FieldMinFloat64MapPointer = &ValidFieldMinFloat64MapPointer
+	v.FieldMinBoolMapPointer = &ValidFieldMinBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = minStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("minStructFieldsPointer types tests ok")
+}
+
+type maxStructFieldsPointer struct {
+	FieldMaxStringPointer       *string              `valid:"max=3"`
+	FieldMaxStringSlicePointer  *[]string            `valid:"max=2"`
+	FieldMaxIntSlicePointer     *[]int               `valid:"max=2"`
+	FieldMaxInt8SlicePointer    *[]int8              `valid:"max=2"`
+	FieldMaxInt16SlicePointer   *[]int16             `valid:"max=2"`
+	FieldMaxInt32SlicePointer   *[]int32             `valid:"max=2"`
+	FieldMaxInt64SlicePointer   *[]int64             `valid:"max=2"`
+	FieldMaxUintSlicePointer    *[]uint              `valid:"max=2"`
+	FieldMaxUint8SlicePointer   *[]uint8             `valid:"max=2"`
+	FieldMaxUint16SlicePointer  *[]uint16            `valid:"max=2"`
+	FieldMaxUint32SlicePointer  *[]uint32            `valid:"max=2"`
+	FieldMaxUint64SlicePointer  *[]uint64            `valid:"max=2"`
+	FieldMaxFloat32SlicePointer *[]float32           `valid:"max=2"`
+	FieldMaxFloat64SlicePointer *[]float64           `valid:"max=2"`
+	FieldMaxBoolSlicePointer    *[]bool              `valid:"max=2"`
+	FieldMaxStringMapPointer    *map[string]string   `valid:"max=2"`
+	FieldMaxIntMapPointer       *map[int]int         `valid:"max=2"`
+	FieldMaxInt8MapPointer      *map[int8]int8       `valid:"max=2"`
+	FieldMaxInt16MapPointer     *map[int16]int16     `valid:"max=2"`
+	FieldMaxInt32MapPointer     *map[int32]int32     `valid:"max=2"`
+	FieldMaxInt64MapPointer     *map[int64]int64     `valid:"max=2"`
+	FieldMaxUintMapPointer      *map[uint]uint       `valid:"max=2"`
+	FieldMaxUint8MapPointer     *map[uint8]uint8     `valid:"max=2"`
+	FieldMaxUint16MapPointer    *map[uint16]uint16   `valid:"max=2"`
+	FieldMaxUint32MapPointer    *map[uint32]uint32   `valid:"max=2"`
+	FieldMaxUint64MapPointer    *map[uint64]uint64   `valid:"max=2"`
+	FieldMaxFloat32MapPointer   *map[float32]float32 `valid:"max=2"`
+	FieldMaxFloat64MapPointer   *map[float64]float64 `valid:"max=2"`
+	FieldMaxBoolMapPointer      *map[bool]bool       `valid:"max=1"`
+}
+
+func maxStructFieldsPointerTests() {
+	log.Println("starting maxStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &maxStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldMaxStringPointer length must be <= 3",
+		"FieldMaxStringSlicePointer must have at most 2 elements",
+		"FieldMaxIntSlicePointer must have at most 2 elements",
+		"FieldMaxInt8SlicePointer must have at most 2 elements",
+		"FieldMaxInt16SlicePointer must have at most 2 elements",
+		"FieldMaxInt32SlicePointer must have at most 2 elements",
+		"FieldMaxInt64SlicePointer must have at most 2 elements",
+		"FieldMaxUintSlicePointer must have at most 2 elements",
+		"FieldMaxUint8SlicePointer must have at most 2 elements",
+		"FieldMaxUint16SlicePointer must have at most 2 elements",
+		"FieldMaxUint32SlicePointer must have at most 2 elements",
+		"FieldMaxUint64SlicePointer must have at most 2 elements",
+		"FieldMaxFloat32SlicePointer must have at most 2 elements",
+		"FieldMaxFloat64SlicePointer must have at most 2 elements",
+		"FieldMaxBoolSlicePointer must have at most 2 elements",
+		"FieldMaxStringMapPointer must have at most 2 elements",
+		"FieldMaxIntMapPointer must have at most 2 elements",
+		"FieldMaxInt8MapPointer must have at most 2 elements",
+		"FieldMaxInt16MapPointer must have at most 2 elements",
+		"FieldMaxInt32MapPointer must have at most 2 elements",
+		"FieldMaxInt64MapPointer must have at most 2 elements",
+		"FieldMaxUintMapPointer must have at most 2 elements",
+		"FieldMaxUint8MapPointer must have at most 2 elements",
+		"FieldMaxUint16MapPointer must have at most 2 elements",
+		"FieldMaxUint32MapPointer must have at most 2 elements",
+		"FieldMaxUint64MapPointer must have at most 2 elements",
+		"FieldMaxFloat32MapPointer must have at most 2 elements",
+		"FieldMaxFloat64MapPointer must have at most 2 elements",
+		"FieldMaxBoolMapPointer must have at most 1 elements",
+	}
+	errs = maxStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldMaxStringPointer string = "abcde"
+	var InvalidFieldMaxStringSlicePointer []string = []string{"abc", "def", "ghi"}
+	var InvalidFieldMaxIntSlicePointer []int = []int{65, 66, 67}
+	var InvalidFieldMaxInt8SlicePointer []int8 = []int8{65, 66, 67}
+	var InvalidFieldMaxInt16SlicePointer []int16 = []int16{65, 66, 67}
+	var InvalidFieldMaxInt32SlicePointer []int32 = []int32{65, 66, 67}
+	var InvalidFieldMaxInt64SlicePointer []int64 = []int64{65, 66, 67}
+	var InvalidFieldMaxUintSlicePointer []uint = []uint{65, 66, 67}
+	var InvalidFieldMaxUint8SlicePointer []uint8 = []uint8{65, 66, 67}
+	var InvalidFieldMaxUint16SlicePointer []uint16 = []uint16{65, 66, 67}
+	var InvalidFieldMaxUint32SlicePointer []uint32 = []uint32{65, 66, 67}
+	var InvalidFieldMaxUint64SlicePointer []uint64 = []uint64{65, 66, 67}
+	var InvalidFieldMaxFloat32SlicePointer []float32 = []float32{65.65, 66.66, 67.67}
+	var InvalidFieldMaxFloat64SlicePointer []float64 = []float64{65.65, 66.66, 67.67}
+	var InvalidFieldMaxBoolSlicePointer []bool = []bool{true, false, true}
+	var InvalidFieldMaxStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2", "c": "3"}
+	var InvalidFieldMaxIntMapPointer map[int]int = map[int]int{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	var InvalidFieldMaxFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65, 2: 66.66, 3: 67.67}
+	var InvalidFieldMaxFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65, 2: 66.66, 3: 67.67}
+	var InvalidFieldMaxBoolMapPointer map[bool]bool = map[bool]bool{true: true, false: false}
+
+	v = &maxStructFieldsPointer{}
+	v.FieldMaxStringPointer = &InvalidFieldMaxStringPointer
+	v.FieldMaxStringSlicePointer = &InvalidFieldMaxStringSlicePointer
+	v.FieldMaxIntSlicePointer = &InvalidFieldMaxIntSlicePointer
+	v.FieldMaxInt8SlicePointer = &InvalidFieldMaxInt8SlicePointer
+	v.FieldMaxInt16SlicePointer = &InvalidFieldMaxInt16SlicePointer
+	v.FieldMaxInt32SlicePointer = &InvalidFieldMaxInt32SlicePointer
+	v.FieldMaxInt64SlicePointer = &InvalidFieldMaxInt64SlicePointer
+	v.FieldMaxUintSlicePointer = &InvalidFieldMaxUintSlicePointer
+	v.FieldMaxUint8SlicePointer = &InvalidFieldMaxUint8SlicePointer
+	v.FieldMaxUint16SlicePointer = &InvalidFieldMaxUint16SlicePointer
+	v.FieldMaxUint32SlicePointer = &InvalidFieldMaxUint32SlicePointer
+	v.FieldMaxUint64SlicePointer = &InvalidFieldMaxUint64SlicePointer
+	v.FieldMaxFloat32SlicePointer = &InvalidFieldMaxFloat32SlicePointer
+	v.FieldMaxFloat64SlicePointer = &InvalidFieldMaxFloat64SlicePointer
+	v.FieldMaxBoolSlicePointer = &InvalidFieldMaxBoolSlicePointer
+	v.FieldMaxStringMapPointer = &InvalidFieldMaxStringMapPointer
+	v.FieldMaxIntMapPointer = &InvalidFieldMaxIntMapPointer
+	v.FieldMaxInt8MapPointer = &InvalidFieldMaxInt8MapPointer
+	v.FieldMaxInt16MapPointer = &InvalidFieldMaxInt16MapPointer
+	v.FieldMaxInt32MapPointer = &InvalidFieldMaxInt32MapPointer
+	v.FieldMaxInt64MapPointer = &InvalidFieldMaxInt64MapPointer
+	v.FieldMaxUintMapPointer = &InvalidFieldMaxUintMapPointer
+	v.FieldMaxUint8MapPointer = &InvalidFieldMaxUint8MapPointer
+	v.FieldMaxUint16MapPointer = &InvalidFieldMaxUint16MapPointer
+	v.FieldMaxUint32MapPointer = &InvalidFieldMaxUint32MapPointer
+	v.FieldMaxUint64MapPointer = &InvalidFieldMaxUint64MapPointer
+	v.FieldMaxFloat32MapPointer = &InvalidFieldMaxFloat32MapPointer
+	v.FieldMaxFloat64MapPointer = &InvalidFieldMaxFloat64MapPointer
+	v.FieldMaxBoolMapPointer = &InvalidFieldMaxBoolMapPointer
+
+	errs = maxStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldMaxStringPointer string = "abc"
+	var ValidFieldMaxStringSlicePointer []string = []string{"abc", "def"}
+	var ValidFieldMaxIntSlicePointer []int = []int{65, 67}
+	var ValidFieldMaxInt8SlicePointer []int8 = []int8{65, 67}
+	var ValidFieldMaxInt16SlicePointer []int16 = []int16{65, 67}
+	var ValidFieldMaxInt32SlicePointer []int32 = []int32{65, 67}
+	var ValidFieldMaxInt64SlicePointer []int64 = []int64{65, 67}
+	var ValidFieldMaxUintSlicePointer []uint = []uint{65, 67}
+	var ValidFieldMaxUint8SlicePointer []uint8 = []uint8{65, 67}
+	var ValidFieldMaxUint16SlicePointer []uint16 = []uint16{65, 67}
+	var ValidFieldMaxUint32SlicePointer []uint32 = []uint32{65, 67}
+	var ValidFieldMaxUint64SlicePointer []uint64 = []uint64{65, 67}
+	var ValidFieldMaxFloat32SlicePointer []float32 = []float32{65.65, 67.67}
+	var ValidFieldMaxFloat64SlicePointer []float64 = []float64{65.65, 67.67}
+	var ValidFieldMaxBoolSlicePointer []bool = []bool{true, false}
+	var ValidFieldMaxStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2"}
+	var ValidFieldMaxIntMapPointer map[int]int = map[int]int{1: 65, 2: 67}
+	var ValidFieldMaxInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67}
+	var ValidFieldMaxInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67}
+	var ValidFieldMaxInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67}
+	var ValidFieldMaxInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67}
+	var ValidFieldMaxUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67}
+	var ValidFieldMaxUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67}
+	var ValidFieldMaxUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67}
+	var ValidFieldMaxUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67}
+	var ValidFieldMaxUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67}
+	var ValidFieldMaxFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65, 2: 67.67}
+	var ValidFieldMaxFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65, 2: 67.67}
+	var ValidFieldMaxBoolMapPointer map[bool]bool = map[bool]bool{true: true}
+
+	v = &maxStructFieldsPointer{}
+	v.FieldMaxStringPointer = &ValidFieldMaxStringPointer
+	v.FieldMaxStringSlicePointer = &ValidFieldMaxStringSlicePointer
+	v.FieldMaxIntSlicePointer = &ValidFieldMaxIntSlicePointer
+	v.FieldMaxInt8SlicePointer = &ValidFieldMaxInt8SlicePointer
+	v.FieldMaxInt16SlicePointer = &ValidFieldMaxInt16SlicePointer
+	v.FieldMaxInt32SlicePointer = &ValidFieldMaxInt32SlicePointer
+	v.FieldMaxInt64SlicePointer = &ValidFieldMaxInt64SlicePointer
+	v.FieldMaxUintSlicePointer = &ValidFieldMaxUintSlicePointer
+	v.FieldMaxUint8SlicePointer = &ValidFieldMaxUint8SlicePointer
+	v.FieldMaxUint16SlicePointer = &ValidFieldMaxUint16SlicePointer
+	v.FieldMaxUint32SlicePointer = &ValidFieldMaxUint32SlicePointer
+	v.FieldMaxUint64SlicePointer = &ValidFieldMaxUint64SlicePointer
+	v.FieldMaxFloat32SlicePointer = &ValidFieldMaxFloat32SlicePointer
+	v.FieldMaxFloat64SlicePointer = &ValidFieldMaxFloat64SlicePointer
+	v.FieldMaxBoolSlicePointer = &ValidFieldMaxBoolSlicePointer
+	v.FieldMaxStringMapPointer = &ValidFieldMaxStringMapPointer
+	v.FieldMaxIntMapPointer = &ValidFieldMaxIntMapPointer
+	v.FieldMaxInt8MapPointer = &ValidFieldMaxInt8MapPointer
+	v.FieldMaxInt16MapPointer = &ValidFieldMaxInt16MapPointer
+	v.FieldMaxInt32MapPointer = &ValidFieldMaxInt32MapPointer
+	v.FieldMaxInt64MapPointer = &ValidFieldMaxInt64MapPointer
+	v.FieldMaxUintMapPointer = &ValidFieldMaxUintMapPointer
+	v.FieldMaxUint8MapPointer = &ValidFieldMaxUint8MapPointer
+	v.FieldMaxUint16MapPointer = &ValidFieldMaxUint16MapPointer
+	v.FieldMaxUint32MapPointer = &ValidFieldMaxUint32MapPointer
+	v.FieldMaxUint64MapPointer = &ValidFieldMaxUint64MapPointer
+	v.FieldMaxFloat32MapPointer = &ValidFieldMaxFloat32MapPointer
+	v.FieldMaxFloat64MapPointer = &ValidFieldMaxFloat64MapPointer
+	v.FieldMaxBoolMapPointer = &ValidFieldMaxBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = maxStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("maxStructFieldsPointer types tests ok")
+}
+
+type eq_ignore_caseStructFieldsPointer struct {
+	FieldEq_ignore_caseStringPointer *string `valid:"eq_ignore_case=abcde"`
+}
+
+func eq_ignore_caseStructFieldsPointerTests() {
+	log.Println("starting eq_ignore_caseStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &eq_ignore_caseStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldEq_ignore_caseStringPointer must be equal to 'abcde'",
+	}
+	errs = eq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldEq_ignore_caseStringPointer string = "a1b2c3"
+
+	v = &eq_ignore_caseStructFieldsPointer{}
+	v.FieldEq_ignore_caseStringPointer = &InvalidFieldEq_ignore_caseStringPointer
+
+	errs = eq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldEq_ignore_caseStringPointer string = "AbCdE"
+
+	v = &eq_ignore_caseStructFieldsPointer{}
+	v.FieldEq_ignore_caseStringPointer = &ValidFieldEq_ignore_caseStringPointer
+
+	expectedMsgErrors = nil
+	errs = eq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("eq_ignore_caseStructFieldsPointer types tests ok")
+}
+
+type neq_ignore_caseStructFieldsPointer struct {
+	FieldNeq_ignore_caseStringPointer *string `valid:"neq_ignore_case=abcde"`
+}
+
+func neq_ignore_caseStructFieldsPointerTests() {
+	log.Println("starting neq_ignore_caseStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &neq_ignore_caseStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldNeq_ignore_caseStringPointer must not be equal to 'abcde'",
+	}
+	errs = neq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldNeq_ignore_caseStringPointer string = "AbCdE"
+
+	v = &neq_ignore_caseStructFieldsPointer{}
+	v.FieldNeq_ignore_caseStringPointer = &InvalidFieldNeq_ignore_caseStringPointer
+
+	errs = neq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldNeq_ignore_caseStringPointer string = "a1b2c3"
+
+	v = &neq_ignore_caseStructFieldsPointer{}
+	v.FieldNeq_ignore_caseStringPointer = &ValidFieldNeq_ignore_caseStringPointer
+
+	expectedMsgErrors = nil
+	errs = neq_ignore_caseStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("neq_ignore_caseStructFieldsPointer types tests ok")
+}
+
+type lenStructFieldsPointer struct {
+	FieldLenStringPointer       *string              `valid:"len=2"`
+	FieldLenStringSlicePointer  *[]string            `valid:"len=2"`
+	FieldLenIntSlicePointer     *[]int               `valid:"len=2"`
+	FieldLenInt8SlicePointer    *[]int8              `valid:"len=2"`
+	FieldLenInt16SlicePointer   *[]int16             `valid:"len=2"`
+	FieldLenInt32SlicePointer   *[]int32             `valid:"len=2"`
+	FieldLenInt64SlicePointer   *[]int64             `valid:"len=2"`
+	FieldLenUintSlicePointer    *[]uint              `valid:"len=2"`
+	FieldLenUint8SlicePointer   *[]uint8             `valid:"len=2"`
+	FieldLenUint16SlicePointer  *[]uint16            `valid:"len=2"`
+	FieldLenUint32SlicePointer  *[]uint32            `valid:"len=2"`
+	FieldLenUint64SlicePointer  *[]uint64            `valid:"len=2"`
+	FieldLenFloat32SlicePointer *[]float32           `valid:"len=2"`
+	FieldLenFloat64SlicePointer *[]float64           `valid:"len=2"`
+	FieldLenBoolSlicePointer    *[]bool              `valid:"len=2"`
+	FieldLenStringMapPointer    *map[string]string   `valid:"len=2"`
+	FieldLenIntMapPointer       *map[int]int         `valid:"len=2"`
+	FieldLenInt8MapPointer      *map[int8]int8       `valid:"len=2"`
+	FieldLenInt16MapPointer     *map[int16]int16     `valid:"len=2"`
+	FieldLenInt32MapPointer     *map[int32]int32     `valid:"len=2"`
+	FieldLenInt64MapPointer     *map[int64]int64     `valid:"len=2"`
+	FieldLenUintMapPointer      *map[uint]uint       `valid:"len=2"`
+	FieldLenUint8MapPointer     *map[uint8]uint8     `valid:"len=2"`
+	FieldLenUint16MapPointer    *map[uint16]uint16   `valid:"len=2"`
+	FieldLenUint32MapPointer    *map[uint32]uint32   `valid:"len=2"`
+	FieldLenUint64MapPointer    *map[uint64]uint64   `valid:"len=2"`
+	FieldLenFloat32MapPointer   *map[float32]float32 `valid:"len=2"`
+	FieldLenFloat64MapPointer   *map[float64]float64 `valid:"len=2"`
+	FieldLenBoolMapPointer      *map[bool]bool       `valid:"len=2"`
+}
+
+func lenStructFieldsPointerTests() {
+	log.Println("starting lenStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &lenStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldLenStringPointer length must be 2",
+		"FieldLenStringSlicePointer must have exactly 2 elements",
+		"FieldLenIntSlicePointer must have exactly 2 elements",
+		"FieldLenInt8SlicePointer must have exactly 2 elements",
+		"FieldLenInt16SlicePointer must have exactly 2 elements",
+		"FieldLenInt32SlicePointer must have exactly 2 elements",
+		"FieldLenInt64SlicePointer must have exactly 2 elements",
+		"FieldLenUintSlicePointer must have exactly 2 elements",
+		"FieldLenUint8SlicePointer must have exactly 2 elements",
+		"FieldLenUint16SlicePointer must have exactly 2 elements",
+		"FieldLenUint32SlicePointer must have exactly 2 elements",
+		"FieldLenUint64SlicePointer must have exactly 2 elements",
+		"FieldLenFloat32SlicePointer must have exactly 2 elements",
+		"FieldLenFloat64SlicePointer must have exactly 2 elements",
+		"FieldLenBoolSlicePointer must have exactly 2 elements",
+		"FieldLenStringMapPointer must have exactly 2 elements",
+		"FieldLenIntMapPointer must have exactly 2 elements",
+		"FieldLenInt8MapPointer must have exactly 2 elements",
+		"FieldLenInt16MapPointer must have exactly 2 elements",
+		"FieldLenInt32MapPointer must have exactly 2 elements",
+		"FieldLenInt64MapPointer must have exactly 2 elements",
+		"FieldLenUintMapPointer must have exactly 2 elements",
+		"FieldLenUint8MapPointer must have exactly 2 elements",
+		"FieldLenUint16MapPointer must have exactly 2 elements",
+		"FieldLenUint32MapPointer must have exactly 2 elements",
+		"FieldLenUint64MapPointer must have exactly 2 elements",
+		"FieldLenFloat32MapPointer must have exactly 2 elements",
+		"FieldLenFloat64MapPointer must have exactly 2 elements",
+		"FieldLenBoolMapPointer must have exactly 2 elements",
+	}
+	errs = lenStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldLenStringPointer string = "abcde"
+	var InvalidFieldLenStringSlicePointer []string = []string{"abc", "def", "ghi"}
+	var InvalidFieldLenIntSlicePointer []int = []int{65, 66, 67}
+	var InvalidFieldLenInt8SlicePointer []int8 = []int8{65, 66, 67}
+	var InvalidFieldLenInt16SlicePointer []int16 = []int16{65, 66, 67}
+	var InvalidFieldLenInt32SlicePointer []int32 = []int32{65, 66, 67}
+	var InvalidFieldLenInt64SlicePointer []int64 = []int64{65, 66, 67}
+	var InvalidFieldLenUintSlicePointer []uint = []uint{65, 66, 67}
+	var InvalidFieldLenUint8SlicePointer []uint8 = []uint8{65, 66, 67}
+	var InvalidFieldLenUint16SlicePointer []uint16 = []uint16{65, 66, 67}
+	var InvalidFieldLenUint32SlicePointer []uint32 = []uint32{65, 66, 67}
+	var InvalidFieldLenUint64SlicePointer []uint64 = []uint64{65, 66, 67}
+	var InvalidFieldLenFloat32SlicePointer []float32 = []float32{65.65, 66.66, 67.67}
+	var InvalidFieldLenFloat64SlicePointer []float64 = []float64{65.65, 66.66, 67.67}
+	var InvalidFieldLenBoolSlicePointer []bool = []bool{true, false, true}
+	var InvalidFieldLenStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2", "c": "3"}
+	var InvalidFieldLenIntMapPointer map[int]int = map[int]int{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	var InvalidFieldLenFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65, 2: 66.66, 3: 67.67}
+	var InvalidFieldLenFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65, 2: 66.66, 3: 67.67}
+	var InvalidFieldLenBoolMapPointer map[bool]bool = map[bool]bool{true: true}
+
+	v = &lenStructFieldsPointer{}
+	v.FieldLenStringPointer = &InvalidFieldLenStringPointer
+	v.FieldLenStringSlicePointer = &InvalidFieldLenStringSlicePointer
+	v.FieldLenIntSlicePointer = &InvalidFieldLenIntSlicePointer
+	v.FieldLenInt8SlicePointer = &InvalidFieldLenInt8SlicePointer
+	v.FieldLenInt16SlicePointer = &InvalidFieldLenInt16SlicePointer
+	v.FieldLenInt32SlicePointer = &InvalidFieldLenInt32SlicePointer
+	v.FieldLenInt64SlicePointer = &InvalidFieldLenInt64SlicePointer
+	v.FieldLenUintSlicePointer = &InvalidFieldLenUintSlicePointer
+	v.FieldLenUint8SlicePointer = &InvalidFieldLenUint8SlicePointer
+	v.FieldLenUint16SlicePointer = &InvalidFieldLenUint16SlicePointer
+	v.FieldLenUint32SlicePointer = &InvalidFieldLenUint32SlicePointer
+	v.FieldLenUint64SlicePointer = &InvalidFieldLenUint64SlicePointer
+	v.FieldLenFloat32SlicePointer = &InvalidFieldLenFloat32SlicePointer
+	v.FieldLenFloat64SlicePointer = &InvalidFieldLenFloat64SlicePointer
+	v.FieldLenBoolSlicePointer = &InvalidFieldLenBoolSlicePointer
+	v.FieldLenStringMapPointer = &InvalidFieldLenStringMapPointer
+	v.FieldLenIntMapPointer = &InvalidFieldLenIntMapPointer
+	v.FieldLenInt8MapPointer = &InvalidFieldLenInt8MapPointer
+	v.FieldLenInt16MapPointer = &InvalidFieldLenInt16MapPointer
+	v.FieldLenInt32MapPointer = &InvalidFieldLenInt32MapPointer
+	v.FieldLenInt64MapPointer = &InvalidFieldLenInt64MapPointer
+	v.FieldLenUintMapPointer = &InvalidFieldLenUintMapPointer
+	v.FieldLenUint8MapPointer = &InvalidFieldLenUint8MapPointer
+	v.FieldLenUint16MapPointer = &InvalidFieldLenUint16MapPointer
+	v.FieldLenUint32MapPointer = &InvalidFieldLenUint32MapPointer
+	v.FieldLenUint64MapPointer = &InvalidFieldLenUint64MapPointer
+	v.FieldLenFloat32MapPointer = &InvalidFieldLenFloat32MapPointer
+	v.FieldLenFloat64MapPointer = &InvalidFieldLenFloat64MapPointer
+	v.FieldLenBoolMapPointer = &InvalidFieldLenBoolMapPointer
+
+	errs = lenStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldLenStringPointer string = "ab"
+	var ValidFieldLenStringSlicePointer []string = []string{"abc", "def"}
+	var ValidFieldLenIntSlicePointer []int = []int{65, 67}
+	var ValidFieldLenInt8SlicePointer []int8 = []int8{65, 67}
+	var ValidFieldLenInt16SlicePointer []int16 = []int16{65, 67}
+	var ValidFieldLenInt32SlicePointer []int32 = []int32{65, 67}
+	var ValidFieldLenInt64SlicePointer []int64 = []int64{65, 67}
+	var ValidFieldLenUintSlicePointer []uint = []uint{65, 67}
+	var ValidFieldLenUint8SlicePointer []uint8 = []uint8{65, 67}
+	var ValidFieldLenUint16SlicePointer []uint16 = []uint16{65, 67}
+	var ValidFieldLenUint32SlicePointer []uint32 = []uint32{65, 67}
+	var ValidFieldLenUint64SlicePointer []uint64 = []uint64{65, 67}
+	var ValidFieldLenFloat32SlicePointer []float32 = []float32{65.65, 67.67}
+	var ValidFieldLenFloat64SlicePointer []float64 = []float64{65.65, 67.67}
+	var ValidFieldLenBoolSlicePointer []bool = []bool{true, false}
+	var ValidFieldLenStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2"}
+	var ValidFieldLenIntMapPointer map[int]int = map[int]int{1: 65, 2: 67}
+	var ValidFieldLenInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67}
+	var ValidFieldLenInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67}
+	var ValidFieldLenInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67}
+	var ValidFieldLenInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67}
+	var ValidFieldLenUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67}
+	var ValidFieldLenUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67}
+	var ValidFieldLenUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67}
+	var ValidFieldLenUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67}
+	var ValidFieldLenUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67}
+	var ValidFieldLenFloat32MapPointer map[float32]float32 = map[float32]float32{1: 65.65, 2: 67.67}
+	var ValidFieldLenFloat64MapPointer map[float64]float64 = map[float64]float64{1: 65.65, 2: 67.67}
+	var ValidFieldLenBoolMapPointer map[bool]bool = map[bool]bool{true: true, false: false}
+
+	v = &lenStructFieldsPointer{}
+	v.FieldLenStringPointer = &ValidFieldLenStringPointer
+	v.FieldLenStringSlicePointer = &ValidFieldLenStringSlicePointer
+	v.FieldLenIntSlicePointer = &ValidFieldLenIntSlicePointer
+	v.FieldLenInt8SlicePointer = &ValidFieldLenInt8SlicePointer
+	v.FieldLenInt16SlicePointer = &ValidFieldLenInt16SlicePointer
+	v.FieldLenInt32SlicePointer = &ValidFieldLenInt32SlicePointer
+	v.FieldLenInt64SlicePointer = &ValidFieldLenInt64SlicePointer
+	v.FieldLenUintSlicePointer = &ValidFieldLenUintSlicePointer
+	v.FieldLenUint8SlicePointer = &ValidFieldLenUint8SlicePointer
+	v.FieldLenUint16SlicePointer = &ValidFieldLenUint16SlicePointer
+	v.FieldLenUint32SlicePointer = &ValidFieldLenUint32SlicePointer
+	v.FieldLenUint64SlicePointer = &ValidFieldLenUint64SlicePointer
+	v.FieldLenFloat32SlicePointer = &ValidFieldLenFloat32SlicePointer
+	v.FieldLenFloat64SlicePointer = &ValidFieldLenFloat64SlicePointer
+	v.FieldLenBoolSlicePointer = &ValidFieldLenBoolSlicePointer
+	v.FieldLenStringMapPointer = &ValidFieldLenStringMapPointer
+	v.FieldLenIntMapPointer = &ValidFieldLenIntMapPointer
+	v.FieldLenInt8MapPointer = &ValidFieldLenInt8MapPointer
+	v.FieldLenInt16MapPointer = &ValidFieldLenInt16MapPointer
+	v.FieldLenInt32MapPointer = &ValidFieldLenInt32MapPointer
+	v.FieldLenInt64MapPointer = &ValidFieldLenInt64MapPointer
+	v.FieldLenUintMapPointer = &ValidFieldLenUintMapPointer
+	v.FieldLenUint8MapPointer = &ValidFieldLenUint8MapPointer
+	v.FieldLenUint16MapPointer = &ValidFieldLenUint16MapPointer
+	v.FieldLenUint32MapPointer = &ValidFieldLenUint32MapPointer
+	v.FieldLenUint64MapPointer = &ValidFieldLenUint64MapPointer
+	v.FieldLenFloat32MapPointer = &ValidFieldLenFloat32MapPointer
+	v.FieldLenFloat64MapPointer = &ValidFieldLenFloat64MapPointer
+	v.FieldLenBoolMapPointer = &ValidFieldLenBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = lenStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("lenStructFieldsPointer types tests ok")
+}
+
+type inStructFieldsPointer struct {
+	FieldInStringPointer       *string              `valid:"in=ab cd ef"`
+	FieldInIntPointer          *int                 `valid:"in=12 34 56"`
+	FieldInInt8Pointer         *int8                `valid:"in=12 34 56"`
+	FieldInInt16Pointer        *int16               `valid:"in=12 34 56"`
+	FieldInInt32Pointer        *int32               `valid:"in=12 34 56"`
+	FieldInInt64Pointer        *int64               `valid:"in=12 34 56"`
+	FieldInUintPointer         *uint                `valid:"in=12 34 56"`
+	FieldInUint8Pointer        *uint8               `valid:"in=12 34 56"`
+	FieldInUint16Pointer       *uint16              `valid:"in=12 34 56"`
+	FieldInUint32Pointer       *uint32              `valid:"in=12 34 56"`
+	FieldInUint64Pointer       *uint64              `valid:"in=12 34 56"`
+	FieldInFloat32Pointer      *float32             `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64Pointer      *float64             `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolPointer         *bool                `valid:"in=true"`
+	FieldInStringSlicePointer  *[]string            `valid:"in=ab cd ef"`
+	FieldInIntSlicePointer     *[]int               `valid:"in=12 34 56"`
+	FieldInInt8SlicePointer    *[]int8              `valid:"in=12 34 56"`
+	FieldInInt16SlicePointer   *[]int16             `valid:"in=12 34 56"`
+	FieldInInt32SlicePointer   *[]int32             `valid:"in=12 34 56"`
+	FieldInInt64SlicePointer   *[]int64             `valid:"in=12 34 56"`
+	FieldInUintSlicePointer    *[]uint              `valid:"in=12 34 56"`
+	FieldInUint8SlicePointer   *[]uint8             `valid:"in=12 34 56"`
+	FieldInUint16SlicePointer  *[]uint16            `valid:"in=12 34 56"`
+	FieldInUint32SlicePointer  *[]uint32            `valid:"in=12 34 56"`
+	FieldInUint64SlicePointer  *[]uint64            `valid:"in=12 34 56"`
+	FieldInFloat32SlicePointer *[]float32           `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64SlicePointer *[]float64           `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolSlicePointer    *[]bool              `valid:"in=true"`
+	FieldInStringArrayPointer  *[3]string           `valid:"in=ab cd ef"`
+	FieldInIntArrayPointer     *[3]int              `valid:"in=12 34 56"`
+	FieldInInt8ArrayPointer    *[3]int8             `valid:"in=12 34 56"`
+	FieldInInt16ArrayPointer   *[3]int16            `valid:"in=12 34 56"`
+	FieldInInt32ArrayPointer   *[3]int32            `valid:"in=12 34 56"`
+	FieldInInt64ArrayPointer   *[3]int64            `valid:"in=12 34 56"`
+	FieldInUintArrayPointer    *[3]uint             `valid:"in=12 34 56"`
+	FieldInUint8ArrayPointer   *[3]uint8            `valid:"in=12 34 56"`
+	FieldInUint16ArrayPointer  *[3]uint16           `valid:"in=12 34 56"`
+	FieldInUint32ArrayPointer  *[3]uint32           `valid:"in=12 34 56"`
+	FieldInUint64ArrayPointer  *[3]uint64           `valid:"in=12 34 56"`
+	FieldInFloat32ArrayPointer *[3]float32          `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64ArrayPointer *[3]float64          `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolArrayPointer    *[3]bool             `valid:"in=true"`
+	FieldInStringMapPointer    *map[string]string   `valid:"in=a b c"`
+	FieldInIntMapPointer       *map[int]int         `valid:"in=1 2 3"`
+	FieldInInt8MapPointer      *map[int8]int8       `valid:"in=1 2 3"`
+	FieldInInt16MapPointer     *map[int16]int16     `valid:"in=1 2 3"`
+	FieldInInt32MapPointer     *map[int32]int32     `valid:"in=1 2 3"`
+	FieldInInt64MapPointer     *map[int64]int64     `valid:"in=1 2 3"`
+	FieldInUintMapPointer      *map[uint]uint       `valid:"in=1 2 3"`
+	FieldInUint8MapPointer     *map[uint8]uint8     `valid:"in=1 2 3"`
+	FieldInUint16MapPointer    *map[uint16]uint16   `valid:"in=1 2 3"`
+	FieldInUint32MapPointer    *map[uint32]uint32   `valid:"in=1 2 3"`
+	FieldInUint64MapPointer    *map[uint64]uint64   `valid:"in=1 2 3"`
+	FieldInFloat32MapPointer   *map[float32]float32 `valid:"in=11.11 22.22 33.33"`
+	FieldInFloat64MapPointer   *map[float64]float64 `valid:"in=11.11 22.22 33.33"`
+	FieldInBoolMapPointer      *map[bool]bool       `valid:"in=false"`
+}
+
+func inStructFieldsPointerTests() {
+	log.Println("starting inStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &inStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldInStringPointer must be one of 'ab' 'cd' 'ef'",
+		"FieldInIntPointer must be one of '12' '34' '56'",
+		"FieldInInt8Pointer must be one of '12' '34' '56'",
+		"FieldInInt16Pointer must be one of '12' '34' '56'",
+		"FieldInInt32Pointer must be one of '12' '34' '56'",
+		"FieldInInt64Pointer must be one of '12' '34' '56'",
+		"FieldInUintPointer must be one of '12' '34' '56'",
+		"FieldInUint8Pointer must be one of '12' '34' '56'",
+		"FieldInUint16Pointer must be one of '12' '34' '56'",
+		"FieldInUint32Pointer must be one of '12' '34' '56'",
+		"FieldInUint64Pointer must be one of '12' '34' '56'",
+		"FieldInFloat32Pointer must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64Pointer must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolPointer must be one of 'true'",
+		"FieldInStringSlicePointer elements must be one of 'ab' 'cd' 'ef'",
+		"FieldInIntSlicePointer elements must be one of '12' '34' '56'",
+		"FieldInInt8SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInInt16SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInInt32SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInInt64SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInUintSlicePointer elements must be one of '12' '34' '56'",
+		"FieldInUint8SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInUint16SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInUint32SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInUint64SlicePointer elements must be one of '12' '34' '56'",
+		"FieldInFloat32SlicePointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64SlicePointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolSlicePointer elements must be one of 'true'",
+		"FieldInStringArrayPointer elements must be one of 'ab' 'cd' 'ef'",
+		"FieldInIntArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInInt8ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInInt16ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInInt32ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInInt64ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInUintArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInUint8ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInUint16ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInUint32ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInUint64ArrayPointer elements must be one of '12' '34' '56'",
+		"FieldInFloat32ArrayPointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64ArrayPointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolArrayPointer elements must be one of 'true'",
+		"FieldInStringMapPointer elements must be one of 'a' 'b' 'c'",
+		"FieldInIntMapPointer elements must be one of '1' '2' '3'",
+		"FieldInInt8MapPointer elements must be one of '1' '2' '3'",
+		"FieldInInt16MapPointer elements must be one of '1' '2' '3'",
+		"FieldInInt32MapPointer elements must be one of '1' '2' '3'",
+		"FieldInInt64MapPointer elements must be one of '1' '2' '3'",
+		"FieldInUintMapPointer elements must be one of '1' '2' '3'",
+		"FieldInUint8MapPointer elements must be one of '1' '2' '3'",
+		"FieldInUint16MapPointer elements must be one of '1' '2' '3'",
+		"FieldInUint32MapPointer elements must be one of '1' '2' '3'",
+		"FieldInUint64MapPointer elements must be one of '1' '2' '3'",
+		"FieldInFloat32MapPointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInFloat64MapPointer elements must be one of '11.11' '22.22' '33.33'",
+		"FieldInBoolMapPointer elements must be one of 'false'",
+	}
+	errs = inStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldInStringPointer string = "fg"
+	var InvalidFieldInIntPointer int = 78
+	var InvalidFieldInInt8Pointer int8 = 78
+	var InvalidFieldInInt16Pointer int16 = 78
+	var InvalidFieldInInt32Pointer int32 = 78
+	var InvalidFieldInInt64Pointer int64 = 78
+	var InvalidFieldInUintPointer uint = 78
+	var InvalidFieldInUint8Pointer uint8 = 78
+	var InvalidFieldInUint16Pointer uint16 = 78
+	var InvalidFieldInUint32Pointer uint32 = 78
+	var InvalidFieldInUint64Pointer uint64 = 78
+	var InvalidFieldInFloat32Pointer float32 = 44.44
+	var InvalidFieldInFloat64Pointer float64 = 44.44
+	var InvalidFieldInBoolPointer bool = false
+	var InvalidFieldInStringSlicePointer []string = []string{"ab", "gh", "ef"}
+	var InvalidFieldInIntSlicePointer []int = []int{12, 78, 56}
+	var InvalidFieldInInt8SlicePointer []int8 = []int8{12, 78, 56}
+	var InvalidFieldInInt16SlicePointer []int16 = []int16{12, 78, 56}
+	var InvalidFieldInInt32SlicePointer []int32 = []int32{12, 78, 56}
+	var InvalidFieldInInt64SlicePointer []int64 = []int64{12, 78, 56}
+	var InvalidFieldInUintSlicePointer []uint = []uint{12, 78, 56}
+	var InvalidFieldInUint8SlicePointer []uint8 = []uint8{12, 78, 56}
+	var InvalidFieldInUint16SlicePointer []uint16 = []uint16{12, 78, 56}
+	var InvalidFieldInUint32SlicePointer []uint32 = []uint32{12, 78, 56}
+	var InvalidFieldInUint64SlicePointer []uint64 = []uint64{12, 78, 56}
+	var InvalidFieldInFloat32SlicePointer []float32 = []float32{11.11, 44.44, 33.33}
+	var InvalidFieldInFloat64SlicePointer []float64 = []float64{11.11, 44.44, 33.33}
+	var InvalidFieldInBoolSlicePointer []bool = []bool{true, false, true}
+	var InvalidFieldInStringArrayPointer [3]string = [3]string{"ab", "gh", "ef"}
+	var InvalidFieldInIntArrayPointer [3]int = [3]int{12, 78, 56}
+	var InvalidFieldInInt8ArrayPointer [3]int8 = [3]int8{12, 78, 56}
+	var InvalidFieldInInt16ArrayPointer [3]int16 = [3]int16{12, 78, 56}
+	var InvalidFieldInInt32ArrayPointer [3]int32 = [3]int32{12, 78, 56}
+	var InvalidFieldInInt64ArrayPointer [3]int64 = [3]int64{12, 78, 56}
+	var InvalidFieldInUintArrayPointer [3]uint = [3]uint{12, 78, 56}
+	var InvalidFieldInUint8ArrayPointer [3]uint8 = [3]uint8{12, 78, 56}
+	var InvalidFieldInUint16ArrayPointer [3]uint16 = [3]uint16{12, 78, 56}
+	var InvalidFieldInUint32ArrayPointer [3]uint32 = [3]uint32{12, 78, 56}
+	var InvalidFieldInUint64ArrayPointer [3]uint64 = [3]uint64{12, 78, 56}
+	var InvalidFieldInFloat32ArrayPointer [3]float32 = [3]float32{11.11, 44.44, 33.33}
+	var InvalidFieldInFloat64ArrayPointer [3]float64 = [3]float64{11.11, 44.44, 33.33}
+	var InvalidFieldInBoolArrayPointer [3]bool = [3]bool{true, false, true}
+	var InvalidFieldInStringMapPointer map[string]string = map[string]string{"a": "1", "d": "9", "c": "3"}
+	var InvalidFieldInIntMapPointer map[int]int = map[int]int{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInUintMapPointer map[uint]uint = map[uint]uint{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 4: 69, 3: 68}
+	var InvalidFieldInFloat32MapPointer map[float32]float32 = map[float32]float32{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	var InvalidFieldInFloat64MapPointer map[float64]float64 = map[float64]float64{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	var InvalidFieldInBoolMapPointer map[bool]bool = map[bool]bool{true: true, false: false}
+
+	v = &inStructFieldsPointer{}
+	v.FieldInStringPointer = &InvalidFieldInStringPointer
+	v.FieldInIntPointer = &InvalidFieldInIntPointer
+	v.FieldInInt8Pointer = &InvalidFieldInInt8Pointer
+	v.FieldInInt16Pointer = &InvalidFieldInInt16Pointer
+	v.FieldInInt32Pointer = &InvalidFieldInInt32Pointer
+	v.FieldInInt64Pointer = &InvalidFieldInInt64Pointer
+	v.FieldInUintPointer = &InvalidFieldInUintPointer
+	v.FieldInUint8Pointer = &InvalidFieldInUint8Pointer
+	v.FieldInUint16Pointer = &InvalidFieldInUint16Pointer
+	v.FieldInUint32Pointer = &InvalidFieldInUint32Pointer
+	v.FieldInUint64Pointer = &InvalidFieldInUint64Pointer
+	v.FieldInFloat32Pointer = &InvalidFieldInFloat32Pointer
+	v.FieldInFloat64Pointer = &InvalidFieldInFloat64Pointer
+	v.FieldInBoolPointer = &InvalidFieldInBoolPointer
+	v.FieldInStringSlicePointer = &InvalidFieldInStringSlicePointer
+	v.FieldInIntSlicePointer = &InvalidFieldInIntSlicePointer
+	v.FieldInInt8SlicePointer = &InvalidFieldInInt8SlicePointer
+	v.FieldInInt16SlicePointer = &InvalidFieldInInt16SlicePointer
+	v.FieldInInt32SlicePointer = &InvalidFieldInInt32SlicePointer
+	v.FieldInInt64SlicePointer = &InvalidFieldInInt64SlicePointer
+	v.FieldInUintSlicePointer = &InvalidFieldInUintSlicePointer
+	v.FieldInUint8SlicePointer = &InvalidFieldInUint8SlicePointer
+	v.FieldInUint16SlicePointer = &InvalidFieldInUint16SlicePointer
+	v.FieldInUint32SlicePointer = &InvalidFieldInUint32SlicePointer
+	v.FieldInUint64SlicePointer = &InvalidFieldInUint64SlicePointer
+	v.FieldInFloat32SlicePointer = &InvalidFieldInFloat32SlicePointer
+	v.FieldInFloat64SlicePointer = &InvalidFieldInFloat64SlicePointer
+	v.FieldInBoolSlicePointer = &InvalidFieldInBoolSlicePointer
+	v.FieldInStringArrayPointer = &InvalidFieldInStringArrayPointer
+	v.FieldInIntArrayPointer = &InvalidFieldInIntArrayPointer
+	v.FieldInInt8ArrayPointer = &InvalidFieldInInt8ArrayPointer
+	v.FieldInInt16ArrayPointer = &InvalidFieldInInt16ArrayPointer
+	v.FieldInInt32ArrayPointer = &InvalidFieldInInt32ArrayPointer
+	v.FieldInInt64ArrayPointer = &InvalidFieldInInt64ArrayPointer
+	v.FieldInUintArrayPointer = &InvalidFieldInUintArrayPointer
+	v.FieldInUint8ArrayPointer = &InvalidFieldInUint8ArrayPointer
+	v.FieldInUint16ArrayPointer = &InvalidFieldInUint16ArrayPointer
+	v.FieldInUint32ArrayPointer = &InvalidFieldInUint32ArrayPointer
+	v.FieldInUint64ArrayPointer = &InvalidFieldInUint64ArrayPointer
+	v.FieldInFloat32ArrayPointer = &InvalidFieldInFloat32ArrayPointer
+	v.FieldInFloat64ArrayPointer = &InvalidFieldInFloat64ArrayPointer
+	v.FieldInBoolArrayPointer = &InvalidFieldInBoolArrayPointer
+	v.FieldInStringMapPointer = &InvalidFieldInStringMapPointer
+	v.FieldInIntMapPointer = &InvalidFieldInIntMapPointer
+	v.FieldInInt8MapPointer = &InvalidFieldInInt8MapPointer
+	v.FieldInInt16MapPointer = &InvalidFieldInInt16MapPointer
+	v.FieldInInt32MapPointer = &InvalidFieldInInt32MapPointer
+	v.FieldInInt64MapPointer = &InvalidFieldInInt64MapPointer
+	v.FieldInUintMapPointer = &InvalidFieldInUintMapPointer
+	v.FieldInUint8MapPointer = &InvalidFieldInUint8MapPointer
+	v.FieldInUint16MapPointer = &InvalidFieldInUint16MapPointer
+	v.FieldInUint32MapPointer = &InvalidFieldInUint32MapPointer
+	v.FieldInUint64MapPointer = &InvalidFieldInUint64MapPointer
+	v.FieldInFloat32MapPointer = &InvalidFieldInFloat32MapPointer
+	v.FieldInFloat64MapPointer = &InvalidFieldInFloat64MapPointer
+	v.FieldInBoolMapPointer = &InvalidFieldInBoolMapPointer
+
+	errs = inStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldInStringPointer string = "cd"
+	var ValidFieldInIntPointer int = 34
+	var ValidFieldInInt8Pointer int8 = 34
+	var ValidFieldInInt16Pointer int16 = 34
+	var ValidFieldInInt32Pointer int32 = 34
+	var ValidFieldInInt64Pointer int64 = 34
+	var ValidFieldInUintPointer uint = 34
+	var ValidFieldInUint8Pointer uint8 = 34
+	var ValidFieldInUint16Pointer uint16 = 34
+	var ValidFieldInUint32Pointer uint32 = 34
+	var ValidFieldInUint64Pointer uint64 = 34
+	var ValidFieldInFloat32Pointer float32 = 22.22
+	var ValidFieldInFloat64Pointer float64 = 22.22
+	var ValidFieldInBoolPointer bool = true
+	var ValidFieldInStringSlicePointer []string = []string{"ab", "ef"}
+	var ValidFieldInIntSlicePointer []int = []int{12, 56}
+	var ValidFieldInInt8SlicePointer []int8 = []int8{12, 56}
+	var ValidFieldInInt16SlicePointer []int16 = []int16{12, 56}
+	var ValidFieldInInt32SlicePointer []int32 = []int32{12, 56}
+	var ValidFieldInInt64SlicePointer []int64 = []int64{12, 56}
+	var ValidFieldInUintSlicePointer []uint = []uint{12, 56}
+	var ValidFieldInUint8SlicePointer []uint8 = []uint8{12, 56}
+	var ValidFieldInUint16SlicePointer []uint16 = []uint16{12, 56}
+	var ValidFieldInUint32SlicePointer []uint32 = []uint32{12, 56}
+	var ValidFieldInUint64SlicePointer []uint64 = []uint64{12, 56}
+	var ValidFieldInFloat32SlicePointer []float32 = []float32{11.11, 22.22}
+	var ValidFieldInFloat64SlicePointer []float64 = []float64{11.11, 22.22}
+	var ValidFieldInBoolSlicePointer []bool = []bool{true, true}
+	var ValidFieldInStringArrayPointer [3]string = [3]string{"ab", "ef", "ab"}
+	var ValidFieldInIntArrayPointer [3]int = [3]int{12, 56, 12}
+	var ValidFieldInInt8ArrayPointer [3]int8 = [3]int8{12, 56, 12}
+	var ValidFieldInInt16ArrayPointer [3]int16 = [3]int16{12, 56, 12}
+	var ValidFieldInInt32ArrayPointer [3]int32 = [3]int32{12, 56, 12}
+	var ValidFieldInInt64ArrayPointer [3]int64 = [3]int64{12, 56, 12}
+	var ValidFieldInUintArrayPointer [3]uint = [3]uint{12, 56, 12}
+	var ValidFieldInUint8ArrayPointer [3]uint8 = [3]uint8{12, 56, 12}
+	var ValidFieldInUint16ArrayPointer [3]uint16 = [3]uint16{12, 56, 12}
+	var ValidFieldInUint32ArrayPointer [3]uint32 = [3]uint32{12, 56, 12}
+	var ValidFieldInUint64ArrayPointer [3]uint64 = [3]uint64{12, 56, 12}
+	var ValidFieldInFloat32ArrayPointer [3]float32 = [3]float32{11.11, 22.22, 11.11}
+	var ValidFieldInFloat64ArrayPointer [3]float64 = [3]float64{11.11, 22.22, 11.11}
+	var ValidFieldInBoolArrayPointer [3]bool = [3]bool{true, true, true}
+	var ValidFieldInStringMapPointer map[string]string = map[string]string{"a": "1", "b": "2", "c": "3"}
+	var ValidFieldInIntMapPointer map[int]int = map[int]int{1: 65, 2: 67, 3: 68}
+	var ValidFieldInInt8MapPointer map[int8]int8 = map[int8]int8{1: 65, 2: 67, 3: 68}
+	var ValidFieldInInt16MapPointer map[int16]int16 = map[int16]int16{1: 65, 2: 67, 3: 68}
+	var ValidFieldInInt32MapPointer map[int32]int32 = map[int32]int32{1: 65, 2: 67, 3: 68}
+	var ValidFieldInInt64MapPointer map[int64]int64 = map[int64]int64{1: 65, 2: 67, 3: 68}
+	var ValidFieldInUintMapPointer map[uint]uint = map[uint]uint{1: 65, 2: 67, 3: 68}
+	var ValidFieldInUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 65, 2: 67, 3: 68}
+	var ValidFieldInUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 65, 2: 67, 3: 68}
+	var ValidFieldInUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 65, 2: 67, 3: 68}
+	var ValidFieldInUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 65, 2: 67, 3: 68}
+	var ValidFieldInFloat32MapPointer map[float32]float32 = map[float32]float32{11.11: 11.11, 22.22: 22.22, 33.33: 33.33}
+	var ValidFieldInFloat64MapPointer map[float64]float64 = map[float64]float64{11.11: 11.11, 22.22: 22.22, 33.33: 33.33}
+	var ValidFieldInBoolMapPointer map[bool]bool = map[bool]bool{false: false}
+
+	v = &inStructFieldsPointer{}
+	v.FieldInStringPointer = &ValidFieldInStringPointer
+	v.FieldInIntPointer = &ValidFieldInIntPointer
+	v.FieldInInt8Pointer = &ValidFieldInInt8Pointer
+	v.FieldInInt16Pointer = &ValidFieldInInt16Pointer
+	v.FieldInInt32Pointer = &ValidFieldInInt32Pointer
+	v.FieldInInt64Pointer = &ValidFieldInInt64Pointer
+	v.FieldInUintPointer = &ValidFieldInUintPointer
+	v.FieldInUint8Pointer = &ValidFieldInUint8Pointer
+	v.FieldInUint16Pointer = &ValidFieldInUint16Pointer
+	v.FieldInUint32Pointer = &ValidFieldInUint32Pointer
+	v.FieldInUint64Pointer = &ValidFieldInUint64Pointer
+	v.FieldInFloat32Pointer = &ValidFieldInFloat32Pointer
+	v.FieldInFloat64Pointer = &ValidFieldInFloat64Pointer
+	v.FieldInBoolPointer = &ValidFieldInBoolPointer
+	v.FieldInStringSlicePointer = &ValidFieldInStringSlicePointer
+	v.FieldInIntSlicePointer = &ValidFieldInIntSlicePointer
+	v.FieldInInt8SlicePointer = &ValidFieldInInt8SlicePointer
+	v.FieldInInt16SlicePointer = &ValidFieldInInt16SlicePointer
+	v.FieldInInt32SlicePointer = &ValidFieldInInt32SlicePointer
+	v.FieldInInt64SlicePointer = &ValidFieldInInt64SlicePointer
+	v.FieldInUintSlicePointer = &ValidFieldInUintSlicePointer
+	v.FieldInUint8SlicePointer = &ValidFieldInUint8SlicePointer
+	v.FieldInUint16SlicePointer = &ValidFieldInUint16SlicePointer
+	v.FieldInUint32SlicePointer = &ValidFieldInUint32SlicePointer
+	v.FieldInUint64SlicePointer = &ValidFieldInUint64SlicePointer
+	v.FieldInFloat32SlicePointer = &ValidFieldInFloat32SlicePointer
+	v.FieldInFloat64SlicePointer = &ValidFieldInFloat64SlicePointer
+	v.FieldInBoolSlicePointer = &ValidFieldInBoolSlicePointer
+	v.FieldInStringArrayPointer = &ValidFieldInStringArrayPointer
+	v.FieldInIntArrayPointer = &ValidFieldInIntArrayPointer
+	v.FieldInInt8ArrayPointer = &ValidFieldInInt8ArrayPointer
+	v.FieldInInt16ArrayPointer = &ValidFieldInInt16ArrayPointer
+	v.FieldInInt32ArrayPointer = &ValidFieldInInt32ArrayPointer
+	v.FieldInInt64ArrayPointer = &ValidFieldInInt64ArrayPointer
+	v.FieldInUintArrayPointer = &ValidFieldInUintArrayPointer
+	v.FieldInUint8ArrayPointer = &ValidFieldInUint8ArrayPointer
+	v.FieldInUint16ArrayPointer = &ValidFieldInUint16ArrayPointer
+	v.FieldInUint32ArrayPointer = &ValidFieldInUint32ArrayPointer
+	v.FieldInUint64ArrayPointer = &ValidFieldInUint64ArrayPointer
+	v.FieldInFloat32ArrayPointer = &ValidFieldInFloat32ArrayPointer
+	v.FieldInFloat64ArrayPointer = &ValidFieldInFloat64ArrayPointer
+	v.FieldInBoolArrayPointer = &ValidFieldInBoolArrayPointer
+	v.FieldInStringMapPointer = &ValidFieldInStringMapPointer
+	v.FieldInIntMapPointer = &ValidFieldInIntMapPointer
+	v.FieldInInt8MapPointer = &ValidFieldInInt8MapPointer
+	v.FieldInInt16MapPointer = &ValidFieldInInt16MapPointer
+	v.FieldInInt32MapPointer = &ValidFieldInInt32MapPointer
+	v.FieldInInt64MapPointer = &ValidFieldInInt64MapPointer
+	v.FieldInUintMapPointer = &ValidFieldInUintMapPointer
+	v.FieldInUint8MapPointer = &ValidFieldInUint8MapPointer
+	v.FieldInUint16MapPointer = &ValidFieldInUint16MapPointer
+	v.FieldInUint32MapPointer = &ValidFieldInUint32MapPointer
+	v.FieldInUint64MapPointer = &ValidFieldInUint64MapPointer
+	v.FieldInFloat32MapPointer = &ValidFieldInFloat32MapPointer
+	v.FieldInFloat64MapPointer = &ValidFieldInFloat64MapPointer
+	v.FieldInBoolMapPointer = &ValidFieldInBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = inStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("inStructFieldsPointer types tests ok")
+}
+
+type ninStructFieldsPointer struct {
+	FieldNinStringPointer       *string              `valid:"nin=ab cd ef"`
+	FieldNinIntPointer          *int                 `valid:"nin=12 34 56"`
+	FieldNinInt8Pointer         *int8                `valid:"nin=12 34 56"`
+	FieldNinInt16Pointer        *int16               `valid:"nin=12 34 56"`
+	FieldNinInt32Pointer        *int32               `valid:"nin=12 34 56"`
+	FieldNinInt64Pointer        *int64               `valid:"nin=12 34 56"`
+	FieldNinUintPointer         *uint                `valid:"nin=12 34 56"`
+	FieldNinUint8Pointer        *uint8               `valid:"nin=12 34 56"`
+	FieldNinUint16Pointer       *uint16              `valid:"nin=12 34 56"`
+	FieldNinUint32Pointer       *uint32              `valid:"nin=12 34 56"`
+	FieldNinUint64Pointer       *uint64              `valid:"nin=12 34 56"`
+	FieldNinFloat32Pointer      *float32             `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64Pointer      *float64             `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolPointer         *bool                `valid:"nin=true"`
+	FieldNinStringSlicePointer  *[]string            `valid:"nin=ab cd ef"`
+	FieldNinIntSlicePointer     *[]int               `valid:"nin=12 34 56"`
+	FieldNinInt8SlicePointer    *[]int8              `valid:"nin=12 34 56"`
+	FieldNinInt16SlicePointer   *[]int16             `valid:"nin=12 34 56"`
+	FieldNinInt32SlicePointer   *[]int32             `valid:"nin=12 34 56"`
+	FieldNinInt64SlicePointer   *[]int64             `valid:"nin=12 34 56"`
+	FieldNinUintSlicePointer    *[]uint              `valid:"nin=12 34 56"`
+	FieldNinUint8SlicePointer   *[]uint8             `valid:"nin=12 34 56"`
+	FieldNinUint16SlicePointer  *[]uint16            `valid:"nin=12 34 56"`
+	FieldNinUint32SlicePointer  *[]uint32            `valid:"nin=12 34 56"`
+	FieldNinUint64SlicePointer  *[]uint64            `valid:"nin=12 34 56"`
+	FieldNinFloat32SlicePointer *[]float32           `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64SlicePointer *[]float64           `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolSlicePointer    *[]bool              `valid:"nin=true"`
+	FieldNinStringArrayPointer  *[3]string           `valid:"nin=ab cd ef"`
+	FieldNinIntArrayPointer     *[3]int              `valid:"nin=12 34 56"`
+	FieldNinInt8ArrayPointer    *[3]int8             `valid:"nin=12 34 56"`
+	FieldNinInt16ArrayPointer   *[3]int16            `valid:"nin=12 34 56"`
+	FieldNinInt32ArrayPointer   *[3]int32            `valid:"nin=12 34 56"`
+	FieldNinInt64ArrayPointer   *[3]int64            `valid:"nin=12 34 56"`
+	FieldNinUintArrayPointer    *[3]uint             `valid:"nin=12 34 56"`
+	FieldNinUint8ArrayPointer   *[3]uint8            `valid:"nin=12 34 56"`
+	FieldNinUint16ArrayPointer  *[3]uint16           `valid:"nin=12 34 56"`
+	FieldNinUint32ArrayPointer  *[3]uint32           `valid:"nin=12 34 56"`
+	FieldNinUint64ArrayPointer  *[3]uint64           `valid:"nin=12 34 56"`
+	FieldNinFloat32ArrayPointer *[3]float32          `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64ArrayPointer *[3]float64          `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolArrayPointer    *[3]bool             `valid:"nin=true"`
+	FieldNinStringMapPointer    *map[string]string   `valid:"nin=a b c"`
+	FieldNinIntMapPointer       *map[int]int         `valid:"nin=1 2 3"`
+	FieldNinInt8MapPointer      *map[int8]int8       `valid:"nin=1 2 3"`
+	FieldNinInt16MapPointer     *map[int16]int16     `valid:"nin=1 2 3"`
+	FieldNinInt32MapPointer     *map[int32]int32     `valid:"nin=1 2 3"`
+	FieldNinInt64MapPointer     *map[int64]int64     `valid:"nin=1 2 3"`
+	FieldNinUintMapPointer      *map[uint]uint       `valid:"nin=1 2 3"`
+	FieldNinUint8MapPointer     *map[uint8]uint8     `valid:"nin=1 2 3"`
+	FieldNinUint16MapPointer    *map[uint16]uint16   `valid:"nin=1 2 3"`
+	FieldNinUint32MapPointer    *map[uint32]uint32   `valid:"nin=1 2 3"`
+	FieldNinUint64MapPointer    *map[uint64]uint64   `valid:"nin=1 2 3"`
+	FieldNinFloat32MapPointer   *map[float32]float32 `valid:"nin=11.11 22.22 33.33"`
+	FieldNinFloat64MapPointer   *map[float64]float64 `valid:"nin=11.11 22.22 33.33"`
+	FieldNinBoolMapPointer      *map[bool]bool       `valid:"nin=false"`
+}
+
+func ninStructFieldsPointerTests() {
+	log.Println("starting ninStructFieldsPointer types tests")
+
+	var expectedMsgErrors []string
+	var errs []error
+
+	// Test case 1: All failure scenarios (nil values)
+	v := &ninStructFieldsPointer{}
+	expectedMsgErrors = []string{
+		"FieldNinStringPointer must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinIntPointer must not be one of '12' '34' '56'",
+		"FieldNinInt8Pointer must not be one of '12' '34' '56'",
+		"FieldNinInt16Pointer must not be one of '12' '34' '56'",
+		"FieldNinInt32Pointer must not be one of '12' '34' '56'",
+		"FieldNinInt64Pointer must not be one of '12' '34' '56'",
+		"FieldNinUintPointer must not be one of '12' '34' '56'",
+		"FieldNinUint8Pointer must not be one of '12' '34' '56'",
+		"FieldNinUint16Pointer must not be one of '12' '34' '56'",
+		"FieldNinUint32Pointer must not be one of '12' '34' '56'",
+		"FieldNinUint64Pointer must not be one of '12' '34' '56'",
+		"FieldNinFloat32Pointer must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64Pointer must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolPointer must not be one of 'true'",
+		"FieldNinStringSlicePointer elements must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinIntSlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt8SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt16SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt32SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt64SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinUintSlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint8SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint16SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint32SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint64SlicePointer elements must not be one of '12' '34' '56'",
+		"FieldNinFloat32SlicePointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64SlicePointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolSlicePointer elements must not be one of 'true'",
+		"FieldNinStringArrayPointer elements must not be one of 'ab' 'cd' 'ef'",
+		"FieldNinIntArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt8ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt16ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt32ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinInt64ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinUintArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint8ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint16ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint32ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinUint64ArrayPointer elements must not be one of '12' '34' '56'",
+		"FieldNinFloat32ArrayPointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64ArrayPointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolArrayPointer elements must not be one of 'true'",
+		"FieldNinStringMapPointer elements must not be one of 'a' 'b' 'c'",
+		"FieldNinIntMapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinInt8MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinInt16MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinInt32MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinInt64MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinUintMapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinUint8MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinUint16MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinUint32MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinUint64MapPointer elements must not be one of '1' '2' '3'",
+		"FieldNinFloat32MapPointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinFloat64MapPointer elements must not be one of '11.11' '22.22' '33.33'",
+		"FieldNinBoolMapPointer elements must not be one of 'false'",
+	}
+	errs = ninStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 1", errs, expectedMsgErrors)
+
+	// Test case 2: All failure scenarios (invalid cases)
+	var InvalidFieldNinStringPointer string = "cd"
+	var InvalidFieldNinIntPointer int = 34
+	var InvalidFieldNinInt8Pointer int8 = 34
+	var InvalidFieldNinInt16Pointer int16 = 34
+	var InvalidFieldNinInt32Pointer int32 = 34
+	var InvalidFieldNinInt64Pointer int64 = 34
+	var InvalidFieldNinUintPointer uint = 34
+	var InvalidFieldNinUint8Pointer uint8 = 34
+	var InvalidFieldNinUint16Pointer uint16 = 34
+	var InvalidFieldNinUint32Pointer uint32 = 34
+	var InvalidFieldNinUint64Pointer uint64 = 34
+	var InvalidFieldNinFloat32Pointer float32 = 22.22
+	var InvalidFieldNinFloat64Pointer float64 = 22.22
+	var InvalidFieldNinBoolPointer bool = true
+	var InvalidFieldNinStringSlicePointer []string = []string{"ab", "ef"}
+	var InvalidFieldNinIntSlicePointer []int = []int{12, 78, 56}
+	var InvalidFieldNinInt8SlicePointer []int8 = []int8{12, 78, 56}
+	var InvalidFieldNinInt16SlicePointer []int16 = []int16{12, 78, 56}
+	var InvalidFieldNinInt32SlicePointer []int32 = []int32{12, 78, 56}
+	var InvalidFieldNinInt64SlicePointer []int64 = []int64{12, 78, 56}
+	var InvalidFieldNinUintSlicePointer []uint = []uint{12, 78, 56}
+	var InvalidFieldNinUint8SlicePointer []uint8 = []uint8{12, 78, 56}
+	var InvalidFieldNinUint16SlicePointer []uint16 = []uint16{12, 78, 56}
+	var InvalidFieldNinUint32SlicePointer []uint32 = []uint32{12, 78, 56}
+	var InvalidFieldNinUint64SlicePointer []uint64 = []uint64{12, 78, 56}
+	var InvalidFieldNinFloat32SlicePointer []float32 = []float32{11.11, 44.44, 33.33}
+	var InvalidFieldNinFloat64SlicePointer []float64 = []float64{11.11, 44.44, 33.33}
+	var InvalidFieldNinBoolSlicePointer []bool = []bool{true, false, true}
+	var InvalidFieldNinStringArrayPointer [3]string = [3]string{"ab", "gh", "ef"}
+	var InvalidFieldNinIntArrayPointer [3]int = [3]int{12, 78, 56}
+	var InvalidFieldNinInt8ArrayPointer [3]int8 = [3]int8{12, 78, 56}
+	var InvalidFieldNinInt16ArrayPointer [3]int16 = [3]int16{12, 78, 56}
+	var InvalidFieldNinInt32ArrayPointer [3]int32 = [3]int32{12, 78, 56}
+	var InvalidFieldNinInt64ArrayPointer [3]int64 = [3]int64{12, 78, 56}
+	var InvalidFieldNinUintArrayPointer [3]uint = [3]uint{12, 78, 56}
+	var InvalidFieldNinUint8ArrayPointer [3]uint8 = [3]uint8{12, 78, 56}
+	var InvalidFieldNinUint16ArrayPointer [3]uint16 = [3]uint16{12, 78, 56}
+	var InvalidFieldNinUint32ArrayPointer [3]uint32 = [3]uint32{12, 78, 56}
+	var InvalidFieldNinUint64ArrayPointer [3]uint64 = [3]uint64{12, 78, 56}
+	var InvalidFieldNinFloat32ArrayPointer [3]float32 = [3]float32{11.11, 44.44, 33.33}
+	var InvalidFieldNinFloat64ArrayPointer [3]float64 = [3]float64{11.11, 44.44, 33.33}
+	var InvalidFieldNinBoolArrayPointer [3]bool = [3]bool{true, false, true}
+	var InvalidFieldNinStringMapPointer map[string]string = map[string]string{"a": "1", "d": "9", "c": "3"}
+	var InvalidFieldNinIntMapPointer map[int]int = map[int]int{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinInt8MapPointer map[int8]int8 = map[int8]int8{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinInt16MapPointer map[int16]int16 = map[int16]int16{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinInt32MapPointer map[int32]int32 = map[int32]int32{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinInt64MapPointer map[int64]int64 = map[int64]int64{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinUintMapPointer map[uint]uint = map[uint]uint{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinUint8MapPointer map[uint8]uint8 = map[uint8]uint8{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinUint16MapPointer map[uint16]uint16 = map[uint16]uint16{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinUint32MapPointer map[uint32]uint32 = map[uint32]uint32{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinUint64MapPointer map[uint64]uint64 = map[uint64]uint64{1: 11, 4: 44, 3: 33}
+	var InvalidFieldNinFloat32MapPointer map[float32]float32 = map[float32]float32{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	var InvalidFieldNinFloat64MapPointer map[float64]float64 = map[float64]float64{11.11: 11.11, 44.44: 44.44, 33.33: 33.33}
+	var InvalidFieldNinBoolMapPointer map[bool]bool = map[bool]bool{true: true, false: false}
+
+	v = &ninStructFieldsPointer{}
+	v.FieldNinStringPointer = &InvalidFieldNinStringPointer
+	v.FieldNinIntPointer = &InvalidFieldNinIntPointer
+	v.FieldNinInt8Pointer = &InvalidFieldNinInt8Pointer
+	v.FieldNinInt16Pointer = &InvalidFieldNinInt16Pointer
+	v.FieldNinInt32Pointer = &InvalidFieldNinInt32Pointer
+	v.FieldNinInt64Pointer = &InvalidFieldNinInt64Pointer
+	v.FieldNinUintPointer = &InvalidFieldNinUintPointer
+	v.FieldNinUint8Pointer = &InvalidFieldNinUint8Pointer
+	v.FieldNinUint16Pointer = &InvalidFieldNinUint16Pointer
+	v.FieldNinUint32Pointer = &InvalidFieldNinUint32Pointer
+	v.FieldNinUint64Pointer = &InvalidFieldNinUint64Pointer
+	v.FieldNinFloat32Pointer = &InvalidFieldNinFloat32Pointer
+	v.FieldNinFloat64Pointer = &InvalidFieldNinFloat64Pointer
+	v.FieldNinBoolPointer = &InvalidFieldNinBoolPointer
+	v.FieldNinStringSlicePointer = &InvalidFieldNinStringSlicePointer
+	v.FieldNinIntSlicePointer = &InvalidFieldNinIntSlicePointer
+	v.FieldNinInt8SlicePointer = &InvalidFieldNinInt8SlicePointer
+	v.FieldNinInt16SlicePointer = &InvalidFieldNinInt16SlicePointer
+	v.FieldNinInt32SlicePointer = &InvalidFieldNinInt32SlicePointer
+	v.FieldNinInt64SlicePointer = &InvalidFieldNinInt64SlicePointer
+	v.FieldNinUintSlicePointer = &InvalidFieldNinUintSlicePointer
+	v.FieldNinUint8SlicePointer = &InvalidFieldNinUint8SlicePointer
+	v.FieldNinUint16SlicePointer = &InvalidFieldNinUint16SlicePointer
+	v.FieldNinUint32SlicePointer = &InvalidFieldNinUint32SlicePointer
+	v.FieldNinUint64SlicePointer = &InvalidFieldNinUint64SlicePointer
+	v.FieldNinFloat32SlicePointer = &InvalidFieldNinFloat32SlicePointer
+	v.FieldNinFloat64SlicePointer = &InvalidFieldNinFloat64SlicePointer
+	v.FieldNinBoolSlicePointer = &InvalidFieldNinBoolSlicePointer
+	v.FieldNinStringArrayPointer = &InvalidFieldNinStringArrayPointer
+	v.FieldNinIntArrayPointer = &InvalidFieldNinIntArrayPointer
+	v.FieldNinInt8ArrayPointer = &InvalidFieldNinInt8ArrayPointer
+	v.FieldNinInt16ArrayPointer = &InvalidFieldNinInt16ArrayPointer
+	v.FieldNinInt32ArrayPointer = &InvalidFieldNinInt32ArrayPointer
+	v.FieldNinInt64ArrayPointer = &InvalidFieldNinInt64ArrayPointer
+	v.FieldNinUintArrayPointer = &InvalidFieldNinUintArrayPointer
+	v.FieldNinUint8ArrayPointer = &InvalidFieldNinUint8ArrayPointer
+	v.FieldNinUint16ArrayPointer = &InvalidFieldNinUint16ArrayPointer
+	v.FieldNinUint32ArrayPointer = &InvalidFieldNinUint32ArrayPointer
+	v.FieldNinUint64ArrayPointer = &InvalidFieldNinUint64ArrayPointer
+	v.FieldNinFloat32ArrayPointer = &InvalidFieldNinFloat32ArrayPointer
+	v.FieldNinFloat64ArrayPointer = &InvalidFieldNinFloat64ArrayPointer
+	v.FieldNinBoolArrayPointer = &InvalidFieldNinBoolArrayPointer
+	v.FieldNinStringMapPointer = &InvalidFieldNinStringMapPointer
+	v.FieldNinIntMapPointer = &InvalidFieldNinIntMapPointer
+	v.FieldNinInt8MapPointer = &InvalidFieldNinInt8MapPointer
+	v.FieldNinInt16MapPointer = &InvalidFieldNinInt16MapPointer
+	v.FieldNinInt32MapPointer = &InvalidFieldNinInt32MapPointer
+	v.FieldNinInt64MapPointer = &InvalidFieldNinInt64MapPointer
+	v.FieldNinUintMapPointer = &InvalidFieldNinUintMapPointer
+	v.FieldNinUint8MapPointer = &InvalidFieldNinUint8MapPointer
+	v.FieldNinUint16MapPointer = &InvalidFieldNinUint16MapPointer
+	v.FieldNinUint32MapPointer = &InvalidFieldNinUint32MapPointer
+	v.FieldNinUint64MapPointer = &InvalidFieldNinUint64MapPointer
+	v.FieldNinFloat32MapPointer = &InvalidFieldNinFloat32MapPointer
+	v.FieldNinFloat64MapPointer = &InvalidFieldNinFloat64MapPointer
+	v.FieldNinBoolMapPointer = &InvalidFieldNinBoolMapPointer
+
+	errs = ninStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 2", errs, expectedMsgErrors)
+
+	// Test case 3: All valid cases
+	var ValidFieldNinStringPointer string = "fg"
+	var ValidFieldNinIntPointer int = 78
+	var ValidFieldNinInt8Pointer int8 = 78
+	var ValidFieldNinInt16Pointer int16 = 78
+	var ValidFieldNinInt32Pointer int32 = 78
+	var ValidFieldNinInt64Pointer int64 = 78
+	var ValidFieldNinUintPointer uint = 78
+	var ValidFieldNinUint8Pointer uint8 = 78
+	var ValidFieldNinUint16Pointer uint16 = 78
+	var ValidFieldNinUint32Pointer uint32 = 78
+	var ValidFieldNinUint64Pointer uint64 = 78
+	var ValidFieldNinFloat32Pointer float32 = 44.44
+	var ValidFieldNinFloat64Pointer float64 = 44.44
+	var ValidFieldNinBoolPointer bool = false
+	var ValidFieldNinStringSlicePointer []string = []string{"gh", "ij", "kl"}
+	var ValidFieldNinIntSlicePointer []int = []int{78, 91}
+	var ValidFieldNinInt8SlicePointer []int8 = []int8{78, 91}
+	var ValidFieldNinInt16SlicePointer []int16 = []int16{78, 91}
+	var ValidFieldNinInt32SlicePointer []int32 = []int32{78, 91}
+	var ValidFieldNinInt64SlicePointer []int64 = []int64{78, 91}
+	var ValidFieldNinUintSlicePointer []uint = []uint{78, 91}
+	var ValidFieldNinUint8SlicePointer []uint8 = []uint8{78, 91}
+	var ValidFieldNinUint16SlicePointer []uint16 = []uint16{78, 91}
+	var ValidFieldNinUint32SlicePointer []uint32 = []uint32{78, 91}
+	var ValidFieldNinUint64SlicePointer []uint64 = []uint64{78, 91}
+	var ValidFieldNinFloat32SlicePointer []float32 = []float32{44.44, 55.55, 66.66}
+	var ValidFieldNinFloat64SlicePointer []float64 = []float64{44.44, 55.55, 66.66}
+	var ValidFieldNinBoolSlicePointer []bool = []bool{false, false, false}
+	var ValidFieldNinStringArrayPointer [3]string = [3]string{"gh", "ij", "kl"}
+	var ValidFieldNinIntArrayPointer [3]int = [3]int{78, 91, 23}
+	var ValidFieldNinInt8ArrayPointer [3]int8 = [3]int8{78, 91, 23}
+	var ValidFieldNinInt16ArrayPointer [3]int16 = [3]int16{78, 91, 23}
+	var ValidFieldNinInt32ArrayPointer [3]int32 = [3]int32{78, 91, 23}
+	var ValidFieldNinInt64ArrayPointer [3]int64 = [3]int64{78, 91, 23}
+	var ValidFieldNinUintArrayPointer [3]uint = [3]uint{78, 91, 23}
+	var ValidFieldNinUint8ArrayPointer [3]uint8 = [3]uint8{78, 91, 23}
+	var ValidFieldNinUint16ArrayPointer [3]uint16 = [3]uint16{78, 91, 23}
+	var ValidFieldNinUint32ArrayPointer [3]uint32 = [3]uint32{78, 91, 23}
+	var ValidFieldNinUint64ArrayPointer [3]uint64 = [3]uint64{78, 91, 23}
+	var ValidFieldNinFloat32ArrayPointer [3]float32 = [3]float32{44.44, 55.55, 66.66}
+	var ValidFieldNinFloat64ArrayPointer [3]float64 = [3]float64{44.44, 55.55, 66.66}
+	var ValidFieldNinBoolArrayPointer [3]bool = [3]bool{false, false, false}
+	var ValidFieldNinStringMapPointer map[string]string = map[string]string{"d": "1", "e": "2", "f": "3"}
+	var ValidFieldNinIntMapPointer map[int]int = map[int]int{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinInt8MapPointer map[int8]int8 = map[int8]int8{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinInt16MapPointer map[int16]int16 = map[int16]int16{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinInt32MapPointer map[int32]int32 = map[int32]int32{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinInt64MapPointer map[int64]int64 = map[int64]int64{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinUintMapPointer map[uint]uint = map[uint]uint{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinUint8MapPointer map[uint8]uint8 = map[uint8]uint8{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinUint16MapPointer map[uint16]uint16 = map[uint16]uint16{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinUint32MapPointer map[uint32]uint32 = map[uint32]uint32{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinUint64MapPointer map[uint64]uint64 = map[uint64]uint64{5: 55, 6: 66, 7: 77}
+	var ValidFieldNinFloat32MapPointer map[float32]float32 = map[float32]float32{44.44: 44.44, 55.55: 55.55, 66.66: 66.66}
+	var ValidFieldNinFloat64MapPointer map[float64]float64 = map[float64]float64{44.44: 44.44, 55.55: 55.55, 66.66: 66.66}
+	var ValidFieldNinBoolMapPointer map[bool]bool = map[bool]bool{true: true}
+
+	v = &ninStructFieldsPointer{}
+	v.FieldNinStringPointer = &ValidFieldNinStringPointer
+	v.FieldNinIntPointer = &ValidFieldNinIntPointer
+	v.FieldNinInt8Pointer = &ValidFieldNinInt8Pointer
+	v.FieldNinInt16Pointer = &ValidFieldNinInt16Pointer
+	v.FieldNinInt32Pointer = &ValidFieldNinInt32Pointer
+	v.FieldNinInt64Pointer = &ValidFieldNinInt64Pointer
+	v.FieldNinUintPointer = &ValidFieldNinUintPointer
+	v.FieldNinUint8Pointer = &ValidFieldNinUint8Pointer
+	v.FieldNinUint16Pointer = &ValidFieldNinUint16Pointer
+	v.FieldNinUint32Pointer = &ValidFieldNinUint32Pointer
+	v.FieldNinUint64Pointer = &ValidFieldNinUint64Pointer
+	v.FieldNinFloat32Pointer = &ValidFieldNinFloat32Pointer
+	v.FieldNinFloat64Pointer = &ValidFieldNinFloat64Pointer
+	v.FieldNinBoolPointer = &ValidFieldNinBoolPointer
+	v.FieldNinStringSlicePointer = &ValidFieldNinStringSlicePointer
+	v.FieldNinIntSlicePointer = &ValidFieldNinIntSlicePointer
+	v.FieldNinInt8SlicePointer = &ValidFieldNinInt8SlicePointer
+	v.FieldNinInt16SlicePointer = &ValidFieldNinInt16SlicePointer
+	v.FieldNinInt32SlicePointer = &ValidFieldNinInt32SlicePointer
+	v.FieldNinInt64SlicePointer = &ValidFieldNinInt64SlicePointer
+	v.FieldNinUintSlicePointer = &ValidFieldNinUintSlicePointer
+	v.FieldNinUint8SlicePointer = &ValidFieldNinUint8SlicePointer
+	v.FieldNinUint16SlicePointer = &ValidFieldNinUint16SlicePointer
+	v.FieldNinUint32SlicePointer = &ValidFieldNinUint32SlicePointer
+	v.FieldNinUint64SlicePointer = &ValidFieldNinUint64SlicePointer
+	v.FieldNinFloat32SlicePointer = &ValidFieldNinFloat32SlicePointer
+	v.FieldNinFloat64SlicePointer = &ValidFieldNinFloat64SlicePointer
+	v.FieldNinBoolSlicePointer = &ValidFieldNinBoolSlicePointer
+	v.FieldNinStringArrayPointer = &ValidFieldNinStringArrayPointer
+	v.FieldNinIntArrayPointer = &ValidFieldNinIntArrayPointer
+	v.FieldNinInt8ArrayPointer = &ValidFieldNinInt8ArrayPointer
+	v.FieldNinInt16ArrayPointer = &ValidFieldNinInt16ArrayPointer
+	v.FieldNinInt32ArrayPointer = &ValidFieldNinInt32ArrayPointer
+	v.FieldNinInt64ArrayPointer = &ValidFieldNinInt64ArrayPointer
+	v.FieldNinUintArrayPointer = &ValidFieldNinUintArrayPointer
+	v.FieldNinUint8ArrayPointer = &ValidFieldNinUint8ArrayPointer
+	v.FieldNinUint16ArrayPointer = &ValidFieldNinUint16ArrayPointer
+	v.FieldNinUint32ArrayPointer = &ValidFieldNinUint32ArrayPointer
+	v.FieldNinUint64ArrayPointer = &ValidFieldNinUint64ArrayPointer
+	v.FieldNinFloat32ArrayPointer = &ValidFieldNinFloat32ArrayPointer
+	v.FieldNinFloat64ArrayPointer = &ValidFieldNinFloat64ArrayPointer
+	v.FieldNinBoolArrayPointer = &ValidFieldNinBoolArrayPointer
+	v.FieldNinStringMapPointer = &ValidFieldNinStringMapPointer
+	v.FieldNinIntMapPointer = &ValidFieldNinIntMapPointer
+	v.FieldNinInt8MapPointer = &ValidFieldNinInt8MapPointer
+	v.FieldNinInt16MapPointer = &ValidFieldNinInt16MapPointer
+	v.FieldNinInt32MapPointer = &ValidFieldNinInt32MapPointer
+	v.FieldNinInt64MapPointer = &ValidFieldNinInt64MapPointer
+	v.FieldNinUintMapPointer = &ValidFieldNinUintMapPointer
+	v.FieldNinUint8MapPointer = &ValidFieldNinUint8MapPointer
+	v.FieldNinUint16MapPointer = &ValidFieldNinUint16MapPointer
+	v.FieldNinUint32MapPointer = &ValidFieldNinUint32MapPointer
+	v.FieldNinUint64MapPointer = &ValidFieldNinUint64MapPointer
+	v.FieldNinFloat32MapPointer = &ValidFieldNinFloat32MapPointer
+	v.FieldNinFloat64MapPointer = &ValidFieldNinFloat64MapPointer
+	v.FieldNinBoolMapPointer = &ValidFieldNinBoolMapPointer
+
+	expectedMsgErrors = nil
+	errs = ninStructFieldsPointerValidate(v)
+	assertExpectedErrorMsgs("testcase 3", errs, expectedMsgErrors)
+
+	log.Println("ninStructFieldsPointer types tests ok")
+}
diff --git a/tests/endtoend/main.go b/tests/endtoend/main.go
index 072724b..8982f92 100644
--- a/tests/endtoend/main.go
+++ b/tests/endtoend/main.go
@@ -4,9 +4,11 @@ import (
 	"errors"
 	"log"
 	"slices"
+	"strings"
 
 	"github.com/opencodeco/validgen/tests/endtoend/structsinpkg"
 	"github.com/opencodeco/validgen/types"
+	"github.com/sergi/go-diff/diffmatchpatch"
 )
 
 type AllTypes1 struct {
@@ -46,6 +48,8 @@ func main() {
 	mapUint8Tests()
 	numericIntTypeTests()
 	numericFloatTypeTests()
+	pointerTests()
+	noPointerTests()
 
 	log.Println("finishing tests")
 }
@@ -168,3 +172,33 @@ func expectedMsgErrorsOk(errs []error, expectedMsgErrors []string) bool {
 		return false
 	})
 }
+
+func assertExpectedErrorMsgs(testName string, errs []error, expectedMsgErrors []string) {
+	ok := slices.EqualFunc(errs, expectedMsgErrors, func(e1 error, e2msg string) bool {
+		var valErr types.ValidationError
+		if errors.As(e1, &valErr) {
+			return valErr.Msg == e2msg
+		}
+
+		return false
+	})
+
+	if ok {
+		return
+	}
+
+	dmp := diffmatchpatch.New()
+	want := strings.Join(expectedMsgErrors, "\n")
+	got := ""
+	for _, err := range errs {
+		got += err.Error() + "\n"
+	}
+
+	diffs := dmp.DiffMain(want, got, false)
+	if len(diffs) == 0 {
+		return
+	}
+
+	diff := dmp.DiffPrettyText(diffs)
+	log.Fatalf("%s error\nerror = %v\nwantErr = %v\n%s() diff = \n%v", testName, errs, expectedMsgErrors, testName, diff)
+}
diff --git a/tests/endtoend/string.go b/tests/endtoend/string.go
index f16e5ad..e6c2167 100644
--- a/tests/endtoend/string.go
+++ b/tests/endtoend/string.go
@@ -13,7 +13,6 @@ type StringType struct {
 	FieldIn     string `valid:"in=ab bc cd"`
 	FieldNotIn  string `valid:"nin=xx yy zz"`
 	EmailReq    string `valid:"required,email"`
-	EmailOpt    string `valid:"email"`
 }
 
 func stringTests() {
@@ -33,7 +32,6 @@ func stringTests() {
 		FieldIn:     "abc",
 		FieldNotIn:  "zz",
 		EmailReq:    "invalid.email.format", // Invalid required email
-		EmailOpt:    "invalid",              // Invalid optional email
 	}
 	expectedMsgErrors = []string{
 		"FieldReq is required",
@@ -46,7 +44,6 @@ func stringTests() {
 		"FieldIn must be one of 'ab' 'bc' 'cd'",
 		"FieldNotIn must not be one of 'xx' 'yy' 'zz'",
 		"EmailReq must be a valid email",
-		"EmailOpt must be a valid email",
 	}
 	errs = StringTypeValidate(v)
 	if !expectedMsgErrorsOk(errs, expectedMsgErrors) {
@@ -65,7 +62,6 @@ func stringTests() {
 		FieldIn:     "bc",
 		FieldNotIn:  "xy",
 		EmailReq:    "user@example.com", // Valid required email
-		EmailOpt:    "",                 // Empty optional email (valid)
 	}
 	expectedMsgErrors = nil
 	errs = StringTypeValidate(v)
diff --git a/tests/endtoend/validator__.go b/tests/endtoend/validator__.go
index 6acb189..89a7bbb 100755
--- a/tests/endtoend/validator__.go
+++ b/tests/endtoend/validator__.go
@@ -650,9 +650,6 @@ func StringTypeValidate(obj *StringType) []error {
 	if !(types.IsValidEmail(obj.EmailReq)) {
 		errs = append(errs, types.NewValidationError("EmailReq must be a valid email"))
 	}
-	if !(types.IsValidEmail(obj.EmailOpt)) {
-		errs = append(errs, types.NewValidationError("EmailOpt must be a valid email"))
-	}
 	return errs
 }
 func UserValidate(obj *User) []error {
@@ -683,3 +680,2085 @@ func UserWithStructInPkgValidate(obj *UserWithStructInPkg) []error {
 	errs = append(errs, structsinpkg.AddressValidate(&obj.Address)...)
 	return errs
 }
+func emailStructFieldsValidate(obj *emailStructFields) []error {
+	var errs []error
+	if !(types.IsValidEmail(obj.FieldEmailString)) {
+		errs = append(errs, types.NewValidationError("FieldEmailString must be a valid email"))
+	}
+	return errs
+}
+func emailStructFieldsPointerValidate(obj *emailStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldEmailStringPointer != nil && types.IsValidEmail(*obj.FieldEmailStringPointer)) {
+		errs = append(errs, types.NewValidationError("FieldEmailStringPointer must be a valid email"))
+	}
+	return errs
+}
+func eqStructFieldsValidate(obj *eqStructFields) []error {
+	var errs []error
+	if !(obj.FieldEqString == "abcde") {
+		errs = append(errs, types.NewValidationError("FieldEqString must be equal to 'abcde'"))
+	}
+	if !(obj.FieldEqInt == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt must be equal to 32"))
+	}
+	if !(obj.FieldEqInt8 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt8 must be equal to 32"))
+	}
+	if !(obj.FieldEqInt16 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt16 must be equal to 32"))
+	}
+	if !(obj.FieldEqInt32 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt32 must be equal to 32"))
+	}
+	if !(obj.FieldEqInt64 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt64 must be equal to 32"))
+	}
+	if !(obj.FieldEqUint == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint must be equal to 32"))
+	}
+	if !(obj.FieldEqUint8 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint8 must be equal to 32"))
+	}
+	if !(obj.FieldEqUint16 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint16 must be equal to 32"))
+	}
+	if !(obj.FieldEqUint32 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint32 must be equal to 32"))
+	}
+	if !(obj.FieldEqUint64 == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint64 must be equal to 32"))
+	}
+	if !(obj.FieldEqFloat32 == 12.34) {
+		errs = append(errs, types.NewValidationError("FieldEqFloat32 must be equal to 12.34"))
+	}
+	if !(obj.FieldEqFloat64 == 12.34) {
+		errs = append(errs, types.NewValidationError("FieldEqFloat64 must be equal to 12.34"))
+	}
+	if !(obj.FieldEqBool == true) {
+		errs = append(errs, types.NewValidationError("FieldEqBool must be equal to true"))
+	}
+	return errs
+}
+func eqStructFieldsPointerValidate(obj *eqStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldEqStringPointer != nil && *obj.FieldEqStringPointer == "abcde") {
+		errs = append(errs, types.NewValidationError("FieldEqStringPointer must be equal to 'abcde'"))
+	}
+	if !(obj.FieldEqIntPointer != nil && *obj.FieldEqIntPointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqIntPointer must be equal to 32"))
+	}
+	if !(obj.FieldEqInt8Pointer != nil && *obj.FieldEqInt8Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt8Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqInt16Pointer != nil && *obj.FieldEqInt16Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt16Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqInt32Pointer != nil && *obj.FieldEqInt32Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt32Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqInt64Pointer != nil && *obj.FieldEqInt64Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqInt64Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqUintPointer != nil && *obj.FieldEqUintPointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUintPointer must be equal to 32"))
+	}
+	if !(obj.FieldEqUint8Pointer != nil && *obj.FieldEqUint8Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint8Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqUint16Pointer != nil && *obj.FieldEqUint16Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint16Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqUint32Pointer != nil && *obj.FieldEqUint32Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint32Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqUint64Pointer != nil && *obj.FieldEqUint64Pointer == 32) {
+		errs = append(errs, types.NewValidationError("FieldEqUint64Pointer must be equal to 32"))
+	}
+	if !(obj.FieldEqFloat32Pointer != nil && *obj.FieldEqFloat32Pointer == 12.34) {
+		errs = append(errs, types.NewValidationError("FieldEqFloat32Pointer must be equal to 12.34"))
+	}
+	if !(obj.FieldEqFloat64Pointer != nil && *obj.FieldEqFloat64Pointer == 12.34) {
+		errs = append(errs, types.NewValidationError("FieldEqFloat64Pointer must be equal to 12.34"))
+	}
+	if !(obj.FieldEqBoolPointer != nil && *obj.FieldEqBoolPointer == true) {
+		errs = append(errs, types.NewValidationError("FieldEqBoolPointer must be equal to true"))
+	}
+	return errs
+}
+func eq_ignore_caseStructFieldsValidate(obj *eq_ignore_caseStructFields) []error {
+	var errs []error
+	if !(types.EqualFold(obj.FieldEq_ignore_caseString, "abcde")) {
+		errs = append(errs, types.NewValidationError("FieldEq_ignore_caseString must be equal to 'abcde'"))
+	}
+	return errs
+}
+func eq_ignore_caseStructFieldsPointerValidate(obj *eq_ignore_caseStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldEq_ignore_caseStringPointer != nil && types.EqualFold(*obj.FieldEq_ignore_caseStringPointer, "abcde")) {
+		errs = append(errs, types.NewValidationError("FieldEq_ignore_caseStringPointer must be equal to 'abcde'"))
+	}
+	return errs
+}
+func gtStructFieldsValidate(obj *gtStructFields) []error {
+	var errs []error
+	if !(obj.FieldGtInt > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt must be > 32"))
+	}
+	if !(obj.FieldGtInt8 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt8 must be > 32"))
+	}
+	if !(obj.FieldGtInt16 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt16 must be > 32"))
+	}
+	if !(obj.FieldGtInt32 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt32 must be > 32"))
+	}
+	if !(obj.FieldGtInt64 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt64 must be > 32"))
+	}
+	if !(obj.FieldGtUint > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint must be > 32"))
+	}
+	if !(obj.FieldGtUint8 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint8 must be > 32"))
+	}
+	if !(obj.FieldGtUint16 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint16 must be > 32"))
+	}
+	if !(obj.FieldGtUint32 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint32 must be > 32"))
+	}
+	if !(obj.FieldGtUint64 > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint64 must be > 32"))
+	}
+	if !(obj.FieldGtFloat32 > 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGtFloat32 must be > 12.34"))
+	}
+	if !(obj.FieldGtFloat64 > 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGtFloat64 must be > 12.34"))
+	}
+	return errs
+}
+func gtStructFieldsPointerValidate(obj *gtStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldGtIntPointer != nil && *obj.FieldGtIntPointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtIntPointer must be > 32"))
+	}
+	if !(obj.FieldGtInt8Pointer != nil && *obj.FieldGtInt8Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt8Pointer must be > 32"))
+	}
+	if !(obj.FieldGtInt16Pointer != nil && *obj.FieldGtInt16Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt16Pointer must be > 32"))
+	}
+	if !(obj.FieldGtInt32Pointer != nil && *obj.FieldGtInt32Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt32Pointer must be > 32"))
+	}
+	if !(obj.FieldGtInt64Pointer != nil && *obj.FieldGtInt64Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtInt64Pointer must be > 32"))
+	}
+	if !(obj.FieldGtUintPointer != nil && *obj.FieldGtUintPointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUintPointer must be > 32"))
+	}
+	if !(obj.FieldGtUint8Pointer != nil && *obj.FieldGtUint8Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint8Pointer must be > 32"))
+	}
+	if !(obj.FieldGtUint16Pointer != nil && *obj.FieldGtUint16Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint16Pointer must be > 32"))
+	}
+	if !(obj.FieldGtUint32Pointer != nil && *obj.FieldGtUint32Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint32Pointer must be > 32"))
+	}
+	if !(obj.FieldGtUint64Pointer != nil && *obj.FieldGtUint64Pointer > 32) {
+		errs = append(errs, types.NewValidationError("FieldGtUint64Pointer must be > 32"))
+	}
+	if !(obj.FieldGtFloat32Pointer != nil && *obj.FieldGtFloat32Pointer > 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGtFloat32Pointer must be > 12.34"))
+	}
+	if !(obj.FieldGtFloat64Pointer != nil && *obj.FieldGtFloat64Pointer > 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGtFloat64Pointer must be > 12.34"))
+	}
+	return errs
+}
+func gteStructFieldsValidate(obj *gteStructFields) []error {
+	var errs []error
+	if !(obj.FieldGteInt >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt must be >= 32"))
+	}
+	if !(obj.FieldGteInt8 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt8 must be >= 32"))
+	}
+	if !(obj.FieldGteInt16 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt16 must be >= 32"))
+	}
+	if !(obj.FieldGteInt32 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt32 must be >= 32"))
+	}
+	if !(obj.FieldGteInt64 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt64 must be >= 32"))
+	}
+	if !(obj.FieldGteUint >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint must be >= 32"))
+	}
+	if !(obj.FieldGteUint8 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint8 must be >= 32"))
+	}
+	if !(obj.FieldGteUint16 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint16 must be >= 32"))
+	}
+	if !(obj.FieldGteUint32 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint32 must be >= 32"))
+	}
+	if !(obj.FieldGteUint64 >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint64 must be >= 32"))
+	}
+	if !(obj.FieldGteFloat32 >= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGteFloat32 must be >= 12.34"))
+	}
+	if !(obj.FieldGteFloat64 >= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGteFloat64 must be >= 12.34"))
+	}
+	return errs
+}
+func gteStructFieldsPointerValidate(obj *gteStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldGteIntPointer != nil && *obj.FieldGteIntPointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteIntPointer must be >= 32"))
+	}
+	if !(obj.FieldGteInt8Pointer != nil && *obj.FieldGteInt8Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt8Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteInt16Pointer != nil && *obj.FieldGteInt16Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt16Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteInt32Pointer != nil && *obj.FieldGteInt32Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt32Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteInt64Pointer != nil && *obj.FieldGteInt64Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteInt64Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteUintPointer != nil && *obj.FieldGteUintPointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUintPointer must be >= 32"))
+	}
+	if !(obj.FieldGteUint8Pointer != nil && *obj.FieldGteUint8Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint8Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteUint16Pointer != nil && *obj.FieldGteUint16Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint16Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteUint32Pointer != nil && *obj.FieldGteUint32Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint32Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteUint64Pointer != nil && *obj.FieldGteUint64Pointer >= 32) {
+		errs = append(errs, types.NewValidationError("FieldGteUint64Pointer must be >= 32"))
+	}
+	if !(obj.FieldGteFloat32Pointer != nil && *obj.FieldGteFloat32Pointer >= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGteFloat32Pointer must be >= 12.34"))
+	}
+	if !(obj.FieldGteFloat64Pointer != nil && *obj.FieldGteFloat64Pointer >= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldGteFloat64Pointer must be >= 12.34"))
+	}
+	return errs
+}
+func inStructFieldsValidate(obj *inStructFields) []error {
+	var errs []error
+	if !(obj.FieldInString == "ab" || obj.FieldInString == "cd" || obj.FieldInString == "ef") {
+		errs = append(errs, types.NewValidationError("FieldInString must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldInInt == 12 || obj.FieldInInt == 34 || obj.FieldInInt == 56) {
+		errs = append(errs, types.NewValidationError("FieldInInt must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt8 == 12 || obj.FieldInInt8 == 34 || obj.FieldInInt8 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInInt8 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt16 == 12 || obj.FieldInInt16 == 34 || obj.FieldInInt16 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInInt16 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt32 == 12 || obj.FieldInInt32 == 34 || obj.FieldInInt32 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInInt32 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt64 == 12 || obj.FieldInInt64 == 34 || obj.FieldInInt64 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInInt64 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint == 12 || obj.FieldInUint == 34 || obj.FieldInUint == 56) {
+		errs = append(errs, types.NewValidationError("FieldInUint must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint8 == 12 || obj.FieldInUint8 == 34 || obj.FieldInUint8 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInUint8 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint16 == 12 || obj.FieldInUint16 == 34 || obj.FieldInUint16 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInUint16 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint32 == 12 || obj.FieldInUint32 == 34 || obj.FieldInUint32 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInUint32 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint64 == 12 || obj.FieldInUint64 == 34 || obj.FieldInUint64 == 56) {
+		errs = append(errs, types.NewValidationError("FieldInUint64 must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInFloat32 == 11.11 || obj.FieldInFloat32 == 22.22 || obj.FieldInFloat32 == 33.33) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32 must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInFloat64 == 11.11 || obj.FieldInFloat64 == 22.22 || obj.FieldInFloat64 == 33.33) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64 must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInBool == true) {
+		errs = append(errs, types.NewValidationError("FieldInBool must be one of 'true'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInStringSlice, []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringSlice elements must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInIntSlice, []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInIntSlice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt8Slice, []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt16Slice, []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt32Slice, []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt64Slice, []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUintSlice, []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUintSlice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint8Slice, []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint16Slice, []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint32Slice, []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint64Slice, []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64Slice elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInFloat32Slice, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32Slice elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInFloat64Slice, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64Slice elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInBoolSlice, []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolSlice elements must be one of 'true'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInStringArray[:], []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringArray elements must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInIntArray[:], []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInIntArray elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt8Array[:], []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt16Array[:], []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt32Array[:], []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInInt64Array[:], []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUintArray[:], []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUintArray elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint8Array[:], []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint16Array[:], []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint32Array[:], []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInUint64Array[:], []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64Array elements must be one of '12' '34' '56'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInFloat32Array[:], []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32Array elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInFloat64Array[:], []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64Array elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceOnlyContains(obj.FieldInBoolArray[:], []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolArray elements must be one of 'true'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInStringMap, []string{"a", "b", "c"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringMap elements must be one of 'a' 'b' 'c'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInIntMap, []int{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInIntMap elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInInt8Map, []int8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInInt16Map, []int16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInInt32Map, []int32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInInt64Map, []int64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInUintMap, []uint{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUintMap elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInUint8Map, []uint8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInUint16Map, []uint16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInUint32Map, []uint32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInUint64Map, []uint64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64Map elements must be one of '1' '2' '3'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInFloat32Map, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32Map elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInFloat64Map, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64Map elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.MapOnlyContains(obj.FieldInBoolMap, []bool{false})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolMap elements must be one of 'false'"))
+	}
+	return errs
+}
+func inStructFieldsPointerValidate(obj *inStructFieldsPointer) []error {
+	var errs []error
+	if !((obj.FieldInStringPointer != nil && *obj.FieldInStringPointer == "ab") || (obj.FieldInStringPointer != nil && *obj.FieldInStringPointer == "cd") || (obj.FieldInStringPointer != nil && *obj.FieldInStringPointer == "ef")) {
+		errs = append(errs, types.NewValidationError("FieldInStringPointer must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !((obj.FieldInIntPointer != nil && *obj.FieldInIntPointer == 12) || (obj.FieldInIntPointer != nil && *obj.FieldInIntPointer == 34) || (obj.FieldInIntPointer != nil && *obj.FieldInIntPointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInIntPointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInInt8Pointer != nil && *obj.FieldInInt8Pointer == 12) || (obj.FieldInInt8Pointer != nil && *obj.FieldInInt8Pointer == 34) || (obj.FieldInInt8Pointer != nil && *obj.FieldInInt8Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInInt8Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInInt16Pointer != nil && *obj.FieldInInt16Pointer == 12) || (obj.FieldInInt16Pointer != nil && *obj.FieldInInt16Pointer == 34) || (obj.FieldInInt16Pointer != nil && *obj.FieldInInt16Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInInt16Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInInt32Pointer != nil && *obj.FieldInInt32Pointer == 12) || (obj.FieldInInt32Pointer != nil && *obj.FieldInInt32Pointer == 34) || (obj.FieldInInt32Pointer != nil && *obj.FieldInInt32Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInInt32Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInInt64Pointer != nil && *obj.FieldInInt64Pointer == 12) || (obj.FieldInInt64Pointer != nil && *obj.FieldInInt64Pointer == 34) || (obj.FieldInInt64Pointer != nil && *obj.FieldInInt64Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInInt64Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInUintPointer != nil && *obj.FieldInUintPointer == 12) || (obj.FieldInUintPointer != nil && *obj.FieldInUintPointer == 34) || (obj.FieldInUintPointer != nil && *obj.FieldInUintPointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInUintPointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInUint8Pointer != nil && *obj.FieldInUint8Pointer == 12) || (obj.FieldInUint8Pointer != nil && *obj.FieldInUint8Pointer == 34) || (obj.FieldInUint8Pointer != nil && *obj.FieldInUint8Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInUint8Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInUint16Pointer != nil && *obj.FieldInUint16Pointer == 12) || (obj.FieldInUint16Pointer != nil && *obj.FieldInUint16Pointer == 34) || (obj.FieldInUint16Pointer != nil && *obj.FieldInUint16Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInUint16Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInUint32Pointer != nil && *obj.FieldInUint32Pointer == 12) || (obj.FieldInUint32Pointer != nil && *obj.FieldInUint32Pointer == 34) || (obj.FieldInUint32Pointer != nil && *obj.FieldInUint32Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInUint32Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInUint64Pointer != nil && *obj.FieldInUint64Pointer == 12) || (obj.FieldInUint64Pointer != nil && *obj.FieldInUint64Pointer == 34) || (obj.FieldInUint64Pointer != nil && *obj.FieldInUint64Pointer == 56)) {
+		errs = append(errs, types.NewValidationError("FieldInUint64Pointer must be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldInFloat32Pointer != nil && *obj.FieldInFloat32Pointer == 11.11) || (obj.FieldInFloat32Pointer != nil && *obj.FieldInFloat32Pointer == 22.22) || (obj.FieldInFloat32Pointer != nil && *obj.FieldInFloat32Pointer == 33.33)) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32Pointer must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !((obj.FieldInFloat64Pointer != nil && *obj.FieldInFloat64Pointer == 11.11) || (obj.FieldInFloat64Pointer != nil && *obj.FieldInFloat64Pointer == 22.22) || (obj.FieldInFloat64Pointer != nil && *obj.FieldInFloat64Pointer == 33.33)) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64Pointer must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInBoolPointer != nil && *obj.FieldInBoolPointer == true) {
+		errs = append(errs, types.NewValidationError("FieldInBoolPointer must be one of 'true'"))
+	}
+	if !(obj.FieldInStringSlicePointer != nil && types.SliceOnlyContains(*obj.FieldInStringSlicePointer, []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringSlicePointer elements must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldInIntSlicePointer != nil && types.SliceOnlyContains(*obj.FieldInIntSlicePointer, []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInIntSlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt8SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInInt8SlicePointer, []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt16SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInInt16SlicePointer, []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt32SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInInt32SlicePointer, []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt64SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInInt64SlicePointer, []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUintSlicePointer != nil && types.SliceOnlyContains(*obj.FieldInUintSlicePointer, []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUintSlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint8SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInUint8SlicePointer, []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint16SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInUint16SlicePointer, []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint32SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInUint32SlicePointer, []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint64SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInUint64SlicePointer, []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64SlicePointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInFloat32SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInFloat32SlicePointer, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32SlicePointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInFloat64SlicePointer != nil && types.SliceOnlyContains(*obj.FieldInFloat64SlicePointer, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64SlicePointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInBoolSlicePointer != nil && types.SliceOnlyContains(*obj.FieldInBoolSlicePointer, []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolSlicePointer elements must be one of 'true'"))
+	}
+	if !(obj.FieldInStringArrayPointer != nil && types.SliceOnlyContains(obj.FieldInStringArrayPointer[:], []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringArrayPointer elements must be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldInIntArrayPointer != nil && types.SliceOnlyContains(obj.FieldInIntArrayPointer[:], []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInIntArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt8ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInInt8ArrayPointer[:], []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt16ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInInt16ArrayPointer[:], []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt32ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInInt32ArrayPointer[:], []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInInt64ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInInt64ArrayPointer[:], []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUintArrayPointer != nil && types.SliceOnlyContains(obj.FieldInUintArrayPointer[:], []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUintArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint8ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInUint8ArrayPointer[:], []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint16ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInUint16ArrayPointer[:], []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint32ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInUint32ArrayPointer[:], []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInUint64ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInUint64ArrayPointer[:], []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64ArrayPointer elements must be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldInFloat32ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInFloat32ArrayPointer[:], []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32ArrayPointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInFloat64ArrayPointer != nil && types.SliceOnlyContains(obj.FieldInFloat64ArrayPointer[:], []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64ArrayPointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInBoolArrayPointer != nil && types.SliceOnlyContains(obj.FieldInBoolArrayPointer[:], []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolArrayPointer elements must be one of 'true'"))
+	}
+	if !(obj.FieldInStringMapPointer != nil && types.MapOnlyContains(*obj.FieldInStringMapPointer, []string{"a", "b", "c"})) {
+		errs = append(errs, types.NewValidationError("FieldInStringMapPointer elements must be one of 'a' 'b' 'c'"))
+	}
+	if !(obj.FieldInIntMapPointer != nil && types.MapOnlyContains(*obj.FieldInIntMapPointer, []int{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInIntMapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInInt8MapPointer != nil && types.MapOnlyContains(*obj.FieldInInt8MapPointer, []int8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt8MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInInt16MapPointer != nil && types.MapOnlyContains(*obj.FieldInInt16MapPointer, []int16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt16MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInInt32MapPointer != nil && types.MapOnlyContains(*obj.FieldInInt32MapPointer, []int32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt32MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInInt64MapPointer != nil && types.MapOnlyContains(*obj.FieldInInt64MapPointer, []int64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInInt64MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInUintMapPointer != nil && types.MapOnlyContains(*obj.FieldInUintMapPointer, []uint{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUintMapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInUint8MapPointer != nil && types.MapOnlyContains(*obj.FieldInUint8MapPointer, []uint8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint8MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInUint16MapPointer != nil && types.MapOnlyContains(*obj.FieldInUint16MapPointer, []uint16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint16MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInUint32MapPointer != nil && types.MapOnlyContains(*obj.FieldInUint32MapPointer, []uint32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint32MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInUint64MapPointer != nil && types.MapOnlyContains(*obj.FieldInUint64MapPointer, []uint64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldInUint64MapPointer elements must be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldInFloat32MapPointer != nil && types.MapOnlyContains(*obj.FieldInFloat32MapPointer, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat32MapPointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInFloat64MapPointer != nil && types.MapOnlyContains(*obj.FieldInFloat64MapPointer, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldInFloat64MapPointer elements must be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldInBoolMapPointer != nil && types.MapOnlyContains(*obj.FieldInBoolMapPointer, []bool{false})) {
+		errs = append(errs, types.NewValidationError("FieldInBoolMapPointer elements must be one of 'false'"))
+	}
+	return errs
+}
+func lenStructFieldsValidate(obj *lenStructFields) []error {
+	var errs []error
+	if !(len(obj.FieldLenString) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenString length must be 2"))
+	}
+	if !(len(obj.FieldLenStringSlice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenStringSlice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenIntSlice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenIntSlice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt8Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt8Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt16Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt16Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt32Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt32Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt64Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt64Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUintSlice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUintSlice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint8Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint8Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint16Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint16Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint32Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint32Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint64Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint64Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenFloat32Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat32Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenFloat64Slice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat64Slice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenBoolSlice) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenBoolSlice must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenStringMap) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenStringMap must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenIntMap) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenIntMap must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt8Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt8Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt16Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt16Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt32Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt32Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenInt64Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt64Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUintMap) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUintMap must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint8Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint8Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint16Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint16Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint32Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint32Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenUint64Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint64Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenFloat32Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat32Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenFloat64Map) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat64Map must have exactly 2 elements"))
+	}
+	if !(len(obj.FieldLenBoolMap) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenBoolMap must have exactly 2 elements"))
+	}
+	return errs
+}
+func lenStructFieldsPointerValidate(obj *lenStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldLenStringPointer != nil && len(*obj.FieldLenStringPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenStringPointer length must be 2"))
+	}
+	if !(obj.FieldLenStringSlicePointer != nil && len(*obj.FieldLenStringSlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenStringSlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenIntSlicePointer != nil && len(*obj.FieldLenIntSlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenIntSlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt8SlicePointer != nil && len(*obj.FieldLenInt8SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt8SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt16SlicePointer != nil && len(*obj.FieldLenInt16SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt16SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt32SlicePointer != nil && len(*obj.FieldLenInt32SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt32SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt64SlicePointer != nil && len(*obj.FieldLenInt64SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt64SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUintSlicePointer != nil && len(*obj.FieldLenUintSlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUintSlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint8SlicePointer != nil && len(*obj.FieldLenUint8SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint8SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint16SlicePointer != nil && len(*obj.FieldLenUint16SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint16SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint32SlicePointer != nil && len(*obj.FieldLenUint32SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint32SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint64SlicePointer != nil && len(*obj.FieldLenUint64SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint64SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenFloat32SlicePointer != nil && len(*obj.FieldLenFloat32SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat32SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenFloat64SlicePointer != nil && len(*obj.FieldLenFloat64SlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat64SlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenBoolSlicePointer != nil && len(*obj.FieldLenBoolSlicePointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenBoolSlicePointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenStringMapPointer != nil && len(*obj.FieldLenStringMapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenStringMapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenIntMapPointer != nil && len(*obj.FieldLenIntMapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenIntMapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt8MapPointer != nil && len(*obj.FieldLenInt8MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt8MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt16MapPointer != nil && len(*obj.FieldLenInt16MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt16MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt32MapPointer != nil && len(*obj.FieldLenInt32MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt32MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenInt64MapPointer != nil && len(*obj.FieldLenInt64MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenInt64MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUintMapPointer != nil && len(*obj.FieldLenUintMapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUintMapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint8MapPointer != nil && len(*obj.FieldLenUint8MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint8MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint16MapPointer != nil && len(*obj.FieldLenUint16MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint16MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint32MapPointer != nil && len(*obj.FieldLenUint32MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint32MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenUint64MapPointer != nil && len(*obj.FieldLenUint64MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenUint64MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenFloat32MapPointer != nil && len(*obj.FieldLenFloat32MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat32MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenFloat64MapPointer != nil && len(*obj.FieldLenFloat64MapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenFloat64MapPointer must have exactly 2 elements"))
+	}
+	if !(obj.FieldLenBoolMapPointer != nil && len(*obj.FieldLenBoolMapPointer) == 2) {
+		errs = append(errs, types.NewValidationError("FieldLenBoolMapPointer must have exactly 2 elements"))
+	}
+	return errs
+}
+func ltStructFieldsValidate(obj *ltStructFields) []error {
+	var errs []error
+	if !(obj.FieldLtInt < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt must be < 32"))
+	}
+	if !(obj.FieldLtInt8 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt8 must be < 32"))
+	}
+	if !(obj.FieldLtInt16 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt16 must be < 32"))
+	}
+	if !(obj.FieldLtInt32 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt32 must be < 32"))
+	}
+	if !(obj.FieldLtInt64 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt64 must be < 32"))
+	}
+	if !(obj.FieldLtUint < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint must be < 32"))
+	}
+	if !(obj.FieldLtUint8 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint8 must be < 32"))
+	}
+	if !(obj.FieldLtUint16 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint16 must be < 32"))
+	}
+	if !(obj.FieldLtUint32 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint32 must be < 32"))
+	}
+	if !(obj.FieldLtUint64 < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint64 must be < 32"))
+	}
+	if !(obj.FieldLtFloat32 < 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLtFloat32 must be < 12.34"))
+	}
+	if !(obj.FieldLtFloat64 < 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLtFloat64 must be < 12.34"))
+	}
+	return errs
+}
+func ltStructFieldsPointerValidate(obj *ltStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldLtIntPointer != nil && *obj.FieldLtIntPointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtIntPointer must be < 32"))
+	}
+	if !(obj.FieldLtInt8Pointer != nil && *obj.FieldLtInt8Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt8Pointer must be < 32"))
+	}
+	if !(obj.FieldLtInt16Pointer != nil && *obj.FieldLtInt16Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt16Pointer must be < 32"))
+	}
+	if !(obj.FieldLtInt32Pointer != nil && *obj.FieldLtInt32Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt32Pointer must be < 32"))
+	}
+	if !(obj.FieldLtInt64Pointer != nil && *obj.FieldLtInt64Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtInt64Pointer must be < 32"))
+	}
+	if !(obj.FieldLtUintPointer != nil && *obj.FieldLtUintPointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUintPointer must be < 32"))
+	}
+	if !(obj.FieldLtUint8Pointer != nil && *obj.FieldLtUint8Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint8Pointer must be < 32"))
+	}
+	if !(obj.FieldLtUint16Pointer != nil && *obj.FieldLtUint16Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint16Pointer must be < 32"))
+	}
+	if !(obj.FieldLtUint32Pointer != nil && *obj.FieldLtUint32Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint32Pointer must be < 32"))
+	}
+	if !(obj.FieldLtUint64Pointer != nil && *obj.FieldLtUint64Pointer < 32) {
+		errs = append(errs, types.NewValidationError("FieldLtUint64Pointer must be < 32"))
+	}
+	if !(obj.FieldLtFloat32Pointer != nil && *obj.FieldLtFloat32Pointer < 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLtFloat32Pointer must be < 12.34"))
+	}
+	if !(obj.FieldLtFloat64Pointer != nil && *obj.FieldLtFloat64Pointer < 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLtFloat64Pointer must be < 12.34"))
+	}
+	return errs
+}
+func lteStructFieldsValidate(obj *lteStructFields) []error {
+	var errs []error
+	if !(obj.FieldLteInt <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt must be <= 32"))
+	}
+	if !(obj.FieldLteInt8 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt8 must be <= 32"))
+	}
+	if !(obj.FieldLteInt16 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt16 must be <= 32"))
+	}
+	if !(obj.FieldLteInt32 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt32 must be <= 32"))
+	}
+	if !(obj.FieldLteInt64 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt64 must be <= 32"))
+	}
+	if !(obj.FieldLteUint <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint must be <= 32"))
+	}
+	if !(obj.FieldLteUint8 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint8 must be <= 32"))
+	}
+	if !(obj.FieldLteUint16 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint16 must be <= 32"))
+	}
+	if !(obj.FieldLteUint32 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint32 must be <= 32"))
+	}
+	if !(obj.FieldLteUint64 <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint64 must be <= 32"))
+	}
+	if !(obj.FieldLteFloat32 <= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLteFloat32 must be <= 12.34"))
+	}
+	if !(obj.FieldLteFloat64 <= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLteFloat64 must be <= 12.34"))
+	}
+	return errs
+}
+func lteStructFieldsPointerValidate(obj *lteStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldLteIntPointer != nil && *obj.FieldLteIntPointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteIntPointer must be <= 32"))
+	}
+	if !(obj.FieldLteInt8Pointer != nil && *obj.FieldLteInt8Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt8Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteInt16Pointer != nil && *obj.FieldLteInt16Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt16Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteInt32Pointer != nil && *obj.FieldLteInt32Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt32Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteInt64Pointer != nil && *obj.FieldLteInt64Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteInt64Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteUintPointer != nil && *obj.FieldLteUintPointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUintPointer must be <= 32"))
+	}
+	if !(obj.FieldLteUint8Pointer != nil && *obj.FieldLteUint8Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint8Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteUint16Pointer != nil && *obj.FieldLteUint16Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint16Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteUint32Pointer != nil && *obj.FieldLteUint32Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint32Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteUint64Pointer != nil && *obj.FieldLteUint64Pointer <= 32) {
+		errs = append(errs, types.NewValidationError("FieldLteUint64Pointer must be <= 32"))
+	}
+	if !(obj.FieldLteFloat32Pointer != nil && *obj.FieldLteFloat32Pointer <= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLteFloat32Pointer must be <= 12.34"))
+	}
+	if !(obj.FieldLteFloat64Pointer != nil && *obj.FieldLteFloat64Pointer <= 12.34) {
+		errs = append(errs, types.NewValidationError("FieldLteFloat64Pointer must be <= 12.34"))
+	}
+	return errs
+}
+func maxStructFieldsValidate(obj *maxStructFields) []error {
+	var errs []error
+	if !(len(obj.FieldMaxString) <= 3) {
+		errs = append(errs, types.NewValidationError("FieldMaxString length must be <= 3"))
+	}
+	if !(len(obj.FieldMaxStringSlice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxStringSlice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxIntSlice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxIntSlice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt8Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt8Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt16Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt16Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt32Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt32Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt64Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt64Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUintSlice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUintSlice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint8Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint8Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint16Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint16Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint32Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint32Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint64Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint64Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxFloat32Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat32Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxFloat64Slice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat64Slice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxBoolSlice) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxBoolSlice must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxStringMap) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxStringMap must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxIntMap) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxIntMap must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt8Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt8Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt16Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt16Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt32Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt32Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxInt64Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt64Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUintMap) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUintMap must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint8Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint8Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint16Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint16Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint32Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint32Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxUint64Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint64Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxFloat32Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat32Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxFloat64Map) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat64Map must have at most 2 elements"))
+	}
+	if !(len(obj.FieldMaxBoolMap) <= 1) {
+		errs = append(errs, types.NewValidationError("FieldMaxBoolMap must have at most 1 elements"))
+	}
+	return errs
+}
+func maxStructFieldsPointerValidate(obj *maxStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldMaxStringPointer != nil && len(*obj.FieldMaxStringPointer) <= 3) {
+		errs = append(errs, types.NewValidationError("FieldMaxStringPointer length must be <= 3"))
+	}
+	if !(obj.FieldMaxStringSlicePointer != nil && len(*obj.FieldMaxStringSlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxStringSlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxIntSlicePointer != nil && len(*obj.FieldMaxIntSlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxIntSlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt8SlicePointer != nil && len(*obj.FieldMaxInt8SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt8SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt16SlicePointer != nil && len(*obj.FieldMaxInt16SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt16SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt32SlicePointer != nil && len(*obj.FieldMaxInt32SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt32SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt64SlicePointer != nil && len(*obj.FieldMaxInt64SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt64SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUintSlicePointer != nil && len(*obj.FieldMaxUintSlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUintSlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint8SlicePointer != nil && len(*obj.FieldMaxUint8SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint8SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint16SlicePointer != nil && len(*obj.FieldMaxUint16SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint16SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint32SlicePointer != nil && len(*obj.FieldMaxUint32SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint32SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint64SlicePointer != nil && len(*obj.FieldMaxUint64SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint64SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxFloat32SlicePointer != nil && len(*obj.FieldMaxFloat32SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat32SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxFloat64SlicePointer != nil && len(*obj.FieldMaxFloat64SlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat64SlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxBoolSlicePointer != nil && len(*obj.FieldMaxBoolSlicePointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxBoolSlicePointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxStringMapPointer != nil && len(*obj.FieldMaxStringMapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxStringMapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxIntMapPointer != nil && len(*obj.FieldMaxIntMapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxIntMapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt8MapPointer != nil && len(*obj.FieldMaxInt8MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt8MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt16MapPointer != nil && len(*obj.FieldMaxInt16MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt16MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt32MapPointer != nil && len(*obj.FieldMaxInt32MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt32MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxInt64MapPointer != nil && len(*obj.FieldMaxInt64MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxInt64MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUintMapPointer != nil && len(*obj.FieldMaxUintMapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUintMapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint8MapPointer != nil && len(*obj.FieldMaxUint8MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint8MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint16MapPointer != nil && len(*obj.FieldMaxUint16MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint16MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint32MapPointer != nil && len(*obj.FieldMaxUint32MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint32MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxUint64MapPointer != nil && len(*obj.FieldMaxUint64MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxUint64MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxFloat32MapPointer != nil && len(*obj.FieldMaxFloat32MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat32MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxFloat64MapPointer != nil && len(*obj.FieldMaxFloat64MapPointer) <= 2) {
+		errs = append(errs, types.NewValidationError("FieldMaxFloat64MapPointer must have at most 2 elements"))
+	}
+	if !(obj.FieldMaxBoolMapPointer != nil && len(*obj.FieldMaxBoolMapPointer) <= 1) {
+		errs = append(errs, types.NewValidationError("FieldMaxBoolMapPointer must have at most 1 elements"))
+	}
+	return errs
+}
+func minStructFieldsValidate(obj *minStructFields) []error {
+	var errs []error
+	if !(len(obj.FieldMinString) >= 5) {
+		errs = append(errs, types.NewValidationError("FieldMinString length must be >= 5"))
+	}
+	if !(len(obj.FieldMinStringSlice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinStringSlice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinIntSlice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinIntSlice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt8Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt8Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt16Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt16Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt32Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt32Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt64Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt64Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUintSlice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUintSlice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint8Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint8Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint16Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint16Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint32Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint32Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint64Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint64Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinFloat32Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat32Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinFloat64Slice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat64Slice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinBoolSlice) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinBoolSlice must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinStringMap) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinStringMap must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinIntMap) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinIntMap must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt8Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt8Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt16Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt16Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt32Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt32Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinInt64Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt64Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUintMap) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUintMap must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint8Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint8Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint16Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint16Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint32Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint32Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinUint64Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint64Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinFloat32Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat32Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinFloat64Map) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat64Map must have at least 2 elements"))
+	}
+	if !(len(obj.FieldMinBoolMap) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinBoolMap must have at least 2 elements"))
+	}
+	return errs
+}
+func minStructFieldsPointerValidate(obj *minStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldMinStringPointer != nil && len(*obj.FieldMinStringPointer) >= 5) {
+		errs = append(errs, types.NewValidationError("FieldMinStringPointer length must be >= 5"))
+	}
+	if !(obj.FieldMinStringSlicePointer != nil && len(*obj.FieldMinStringSlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinStringSlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinIntSlicePointer != nil && len(*obj.FieldMinIntSlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinIntSlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt8SlicePointer != nil && len(*obj.FieldMinInt8SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt8SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt16SlicePointer != nil && len(*obj.FieldMinInt16SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt16SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt32SlicePointer != nil && len(*obj.FieldMinInt32SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt32SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt64SlicePointer != nil && len(*obj.FieldMinInt64SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt64SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUintSlicePointer != nil && len(*obj.FieldMinUintSlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUintSlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint8SlicePointer != nil && len(*obj.FieldMinUint8SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint8SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint16SlicePointer != nil && len(*obj.FieldMinUint16SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint16SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint32SlicePointer != nil && len(*obj.FieldMinUint32SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint32SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint64SlicePointer != nil && len(*obj.FieldMinUint64SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint64SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinFloat32SlicePointer != nil && len(*obj.FieldMinFloat32SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat32SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinFloat64SlicePointer != nil && len(*obj.FieldMinFloat64SlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat64SlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinBoolSlicePointer != nil && len(*obj.FieldMinBoolSlicePointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinBoolSlicePointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinStringMapPointer != nil && len(*obj.FieldMinStringMapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinStringMapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinIntMapPointer != nil && len(*obj.FieldMinIntMapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinIntMapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt8MapPointer != nil && len(*obj.FieldMinInt8MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt8MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt16MapPointer != nil && len(*obj.FieldMinInt16MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt16MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt32MapPointer != nil && len(*obj.FieldMinInt32MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt32MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinInt64MapPointer != nil && len(*obj.FieldMinInt64MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinInt64MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUintMapPointer != nil && len(*obj.FieldMinUintMapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUintMapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint8MapPointer != nil && len(*obj.FieldMinUint8MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint8MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint16MapPointer != nil && len(*obj.FieldMinUint16MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint16MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint32MapPointer != nil && len(*obj.FieldMinUint32MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint32MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinUint64MapPointer != nil && len(*obj.FieldMinUint64MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinUint64MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinFloat32MapPointer != nil && len(*obj.FieldMinFloat32MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat32MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinFloat64MapPointer != nil && len(*obj.FieldMinFloat64MapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinFloat64MapPointer must have at least 2 elements"))
+	}
+	if !(obj.FieldMinBoolMapPointer != nil && len(*obj.FieldMinBoolMapPointer) >= 2) {
+		errs = append(errs, types.NewValidationError("FieldMinBoolMapPointer must have at least 2 elements"))
+	}
+	return errs
+}
+func neqStructFieldsValidate(obj *neqStructFields) []error {
+	var errs []error
+	if !(obj.FieldNeqString != "abcde") {
+		errs = append(errs, types.NewValidationError("FieldNeqString must not be equal to 'abcde'"))
+	}
+	if !(obj.FieldNeqInt != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt8 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt8 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt16 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt16 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt32 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt32 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt64 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt64 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint8 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint8 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint16 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint16 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint32 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint32 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint64 != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint64 must not be equal to 32"))
+	}
+	if !(obj.FieldNeqFloat32 != 12.34) {
+		errs = append(errs, types.NewValidationError("FieldNeqFloat32 must not be equal to 12.34"))
+	}
+	if !(obj.FieldNeqFloat64 != 12.34) {
+		errs = append(errs, types.NewValidationError("FieldNeqFloat64 must not be equal to 12.34"))
+	}
+	if !(obj.FieldNeqBool != true) {
+		errs = append(errs, types.NewValidationError("FieldNeqBool must not be equal to true"))
+	}
+	return errs
+}
+func neqStructFieldsPointerValidate(obj *neqStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldNeqStringPointer != nil && *obj.FieldNeqStringPointer != "abcde") {
+		errs = append(errs, types.NewValidationError("FieldNeqStringPointer must not be equal to 'abcde'"))
+	}
+	if !(obj.FieldNeqIntPointer != nil && *obj.FieldNeqIntPointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqIntPointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt8Pointer != nil && *obj.FieldNeqInt8Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt8Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt16Pointer != nil && *obj.FieldNeqInt16Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt16Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt32Pointer != nil && *obj.FieldNeqInt32Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt32Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqInt64Pointer != nil && *obj.FieldNeqInt64Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqInt64Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUintPointer != nil && *obj.FieldNeqUintPointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUintPointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint8Pointer != nil && *obj.FieldNeqUint8Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint8Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint16Pointer != nil && *obj.FieldNeqUint16Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint16Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint32Pointer != nil && *obj.FieldNeqUint32Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint32Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqUint64Pointer != nil && *obj.FieldNeqUint64Pointer != 32) {
+		errs = append(errs, types.NewValidationError("FieldNeqUint64Pointer must not be equal to 32"))
+	}
+	if !(obj.FieldNeqFloat32Pointer != nil && *obj.FieldNeqFloat32Pointer != 12.34) {
+		errs = append(errs, types.NewValidationError("FieldNeqFloat32Pointer must not be equal to 12.34"))
+	}
+	if !(obj.FieldNeqFloat64Pointer != nil && *obj.FieldNeqFloat64Pointer != 12.34) {
+		errs = append(errs, types.NewValidationError("FieldNeqFloat64Pointer must not be equal to 12.34"))
+	}
+	if !(obj.FieldNeqBoolPointer != nil && *obj.FieldNeqBoolPointer != true) {
+		errs = append(errs, types.NewValidationError("FieldNeqBoolPointer must not be equal to true"))
+	}
+	return errs
+}
+func neq_ignore_caseStructFieldsValidate(obj *neq_ignore_caseStructFields) []error {
+	var errs []error
+	if !(!types.EqualFold(obj.FieldNeq_ignore_caseString, "abcde")) {
+		errs = append(errs, types.NewValidationError("FieldNeq_ignore_caseString must not be equal to 'abcde'"))
+	}
+	return errs
+}
+func neq_ignore_caseStructFieldsPointerValidate(obj *neq_ignore_caseStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldNeq_ignore_caseStringPointer != nil && !types.EqualFold(*obj.FieldNeq_ignore_caseStringPointer, "abcde")) {
+		errs = append(errs, types.NewValidationError("FieldNeq_ignore_caseStringPointer must not be equal to 'abcde'"))
+	}
+	return errs
+}
+func ninStructFieldsValidate(obj *ninStructFields) []error {
+	var errs []error
+	if !(obj.FieldNinString != "ab" && obj.FieldNinString != "cd" && obj.FieldNinString != "ef") {
+		errs = append(errs, types.NewValidationError("FieldNinString must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldNinInt != 12 && obj.FieldNinInt != 34 && obj.FieldNinInt != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinInt must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt8 != 12 && obj.FieldNinInt8 != 34 && obj.FieldNinInt8 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt16 != 12 && obj.FieldNinInt16 != 34 && obj.FieldNinInt16 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt32 != 12 && obj.FieldNinInt32 != 34 && obj.FieldNinInt32 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt64 != 12 && obj.FieldNinInt64 != 34 && obj.FieldNinInt64 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint != 12 && obj.FieldNinUint != 34 && obj.FieldNinUint != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinUint must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint8 != 12 && obj.FieldNinUint8 != 34 && obj.FieldNinUint8 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint16 != 12 && obj.FieldNinUint16 != 34 && obj.FieldNinUint16 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint32 != 12 && obj.FieldNinUint32 != 34 && obj.FieldNinUint32 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint64 != 12 && obj.FieldNinUint64 != 34 && obj.FieldNinUint64 != 56) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64 must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinFloat32 != 11.11 && obj.FieldNinFloat32 != 22.22 && obj.FieldNinFloat32 != 33.33) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32 must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinFloat64 != 11.11 && obj.FieldNinFloat64 != 22.22 && obj.FieldNinFloat64 != 33.33) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64 must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinBool != true) {
+		errs = append(errs, types.NewValidationError("FieldNinBool must not be one of 'true'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinStringSlice, []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringSlice elements must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinIntSlice, []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntSlice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt8Slice, []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt16Slice, []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt32Slice, []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt64Slice, []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUintSlice, []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintSlice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint8Slice, []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint16Slice, []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint32Slice, []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint64Slice, []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64Slice elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinFloat32Slice, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32Slice elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinFloat64Slice, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64Slice elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinBoolSlice, []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolSlice elements must not be one of 'true'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinStringArray[:], []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringArray elements must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinIntArray[:], []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntArray elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt8Array[:], []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt16Array[:], []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt32Array[:], []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinInt64Array[:], []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUintArray[:], []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintArray elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint8Array[:], []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint16Array[:], []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint32Array[:], []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinUint64Array[:], []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64Array elements must not be one of '12' '34' '56'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinFloat32Array[:], []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32Array elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinFloat64Array[:], []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64Array elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.SliceNotContains(obj.FieldNinBoolArray[:], []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolArray elements must not be one of 'true'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinStringMap, []string{"a", "b", "c"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringMap elements must not be one of 'a' 'b' 'c'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinIntMap, []int{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntMap elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinInt8Map, []int8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinInt16Map, []int16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinInt32Map, []int32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinInt64Map, []int64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinUintMap, []uint{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintMap elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinUint8Map, []uint8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinUint16Map, []uint16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinUint32Map, []uint32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinUint64Map, []uint64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64Map elements must not be one of '1' '2' '3'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinFloat32Map, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32Map elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinFloat64Map, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64Map elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(types.MapNotContains(obj.FieldNinBoolMap, []bool{false})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolMap elements must not be one of 'false'"))
+	}
+	return errs
+}
+func ninStructFieldsPointerValidate(obj *ninStructFieldsPointer) []error {
+	var errs []error
+	if !((obj.FieldNinStringPointer != nil && *obj.FieldNinStringPointer != "ab") && (obj.FieldNinStringPointer != nil && *obj.FieldNinStringPointer != "cd") && (obj.FieldNinStringPointer != nil && *obj.FieldNinStringPointer != "ef")) {
+		errs = append(errs, types.NewValidationError("FieldNinStringPointer must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !((obj.FieldNinIntPointer != nil && *obj.FieldNinIntPointer != 12) && (obj.FieldNinIntPointer != nil && *obj.FieldNinIntPointer != 34) && (obj.FieldNinIntPointer != nil && *obj.FieldNinIntPointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinIntPointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinInt8Pointer != nil && *obj.FieldNinInt8Pointer != 12) && (obj.FieldNinInt8Pointer != nil && *obj.FieldNinInt8Pointer != 34) && (obj.FieldNinInt8Pointer != nil && *obj.FieldNinInt8Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinInt16Pointer != nil && *obj.FieldNinInt16Pointer != 12) && (obj.FieldNinInt16Pointer != nil && *obj.FieldNinInt16Pointer != 34) && (obj.FieldNinInt16Pointer != nil && *obj.FieldNinInt16Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinInt32Pointer != nil && *obj.FieldNinInt32Pointer != 12) && (obj.FieldNinInt32Pointer != nil && *obj.FieldNinInt32Pointer != 34) && (obj.FieldNinInt32Pointer != nil && *obj.FieldNinInt32Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinInt64Pointer != nil && *obj.FieldNinInt64Pointer != 12) && (obj.FieldNinInt64Pointer != nil && *obj.FieldNinInt64Pointer != 34) && (obj.FieldNinInt64Pointer != nil && *obj.FieldNinInt64Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinUintPointer != nil && *obj.FieldNinUintPointer != 12) && (obj.FieldNinUintPointer != nil && *obj.FieldNinUintPointer != 34) && (obj.FieldNinUintPointer != nil && *obj.FieldNinUintPointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinUintPointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinUint8Pointer != nil && *obj.FieldNinUint8Pointer != 12) && (obj.FieldNinUint8Pointer != nil && *obj.FieldNinUint8Pointer != 34) && (obj.FieldNinUint8Pointer != nil && *obj.FieldNinUint8Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinUint16Pointer != nil && *obj.FieldNinUint16Pointer != 12) && (obj.FieldNinUint16Pointer != nil && *obj.FieldNinUint16Pointer != 34) && (obj.FieldNinUint16Pointer != nil && *obj.FieldNinUint16Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinUint32Pointer != nil && *obj.FieldNinUint32Pointer != 12) && (obj.FieldNinUint32Pointer != nil && *obj.FieldNinUint32Pointer != 34) && (obj.FieldNinUint32Pointer != nil && *obj.FieldNinUint32Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinUint64Pointer != nil && *obj.FieldNinUint64Pointer != 12) && (obj.FieldNinUint64Pointer != nil && *obj.FieldNinUint64Pointer != 34) && (obj.FieldNinUint64Pointer != nil && *obj.FieldNinUint64Pointer != 56)) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64Pointer must not be one of '12' '34' '56'"))
+	}
+	if !((obj.FieldNinFloat32Pointer != nil && *obj.FieldNinFloat32Pointer != 11.11) && (obj.FieldNinFloat32Pointer != nil && *obj.FieldNinFloat32Pointer != 22.22) && (obj.FieldNinFloat32Pointer != nil && *obj.FieldNinFloat32Pointer != 33.33)) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32Pointer must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !((obj.FieldNinFloat64Pointer != nil && *obj.FieldNinFloat64Pointer != 11.11) && (obj.FieldNinFloat64Pointer != nil && *obj.FieldNinFloat64Pointer != 22.22) && (obj.FieldNinFloat64Pointer != nil && *obj.FieldNinFloat64Pointer != 33.33)) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64Pointer must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinBoolPointer != nil && *obj.FieldNinBoolPointer != true) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolPointer must not be one of 'true'"))
+	}
+	if !(obj.FieldNinStringSlicePointer != nil && types.SliceNotContains(*obj.FieldNinStringSlicePointer, []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringSlicePointer elements must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldNinIntSlicePointer != nil && types.SliceNotContains(*obj.FieldNinIntSlicePointer, []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntSlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt8SlicePointer != nil && types.SliceNotContains(*obj.FieldNinInt8SlicePointer, []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt16SlicePointer != nil && types.SliceNotContains(*obj.FieldNinInt16SlicePointer, []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt32SlicePointer != nil && types.SliceNotContains(*obj.FieldNinInt32SlicePointer, []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt64SlicePointer != nil && types.SliceNotContains(*obj.FieldNinInt64SlicePointer, []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUintSlicePointer != nil && types.SliceNotContains(*obj.FieldNinUintSlicePointer, []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintSlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint8SlicePointer != nil && types.SliceNotContains(*obj.FieldNinUint8SlicePointer, []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint16SlicePointer != nil && types.SliceNotContains(*obj.FieldNinUint16SlicePointer, []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint32SlicePointer != nil && types.SliceNotContains(*obj.FieldNinUint32SlicePointer, []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint64SlicePointer != nil && types.SliceNotContains(*obj.FieldNinUint64SlicePointer, []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64SlicePointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinFloat32SlicePointer != nil && types.SliceNotContains(*obj.FieldNinFloat32SlicePointer, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32SlicePointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinFloat64SlicePointer != nil && types.SliceNotContains(*obj.FieldNinFloat64SlicePointer, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64SlicePointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinBoolSlicePointer != nil && types.SliceNotContains(*obj.FieldNinBoolSlicePointer, []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolSlicePointer elements must not be one of 'true'"))
+	}
+	if !(obj.FieldNinStringArrayPointer != nil && types.SliceNotContains(obj.FieldNinStringArrayPointer[:], []string{"ab", "cd", "ef"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringArrayPointer elements must not be one of 'ab' 'cd' 'ef'"))
+	}
+	if !(obj.FieldNinIntArrayPointer != nil && types.SliceNotContains(obj.FieldNinIntArrayPointer[:], []int{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt8ArrayPointer != nil && types.SliceNotContains(obj.FieldNinInt8ArrayPointer[:], []int8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt16ArrayPointer != nil && types.SliceNotContains(obj.FieldNinInt16ArrayPointer[:], []int16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt32ArrayPointer != nil && types.SliceNotContains(obj.FieldNinInt32ArrayPointer[:], []int32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinInt64ArrayPointer != nil && types.SliceNotContains(obj.FieldNinInt64ArrayPointer[:], []int64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUintArrayPointer != nil && types.SliceNotContains(obj.FieldNinUintArrayPointer[:], []uint{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint8ArrayPointer != nil && types.SliceNotContains(obj.FieldNinUint8ArrayPointer[:], []uint8{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint16ArrayPointer != nil && types.SliceNotContains(obj.FieldNinUint16ArrayPointer[:], []uint16{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint32ArrayPointer != nil && types.SliceNotContains(obj.FieldNinUint32ArrayPointer[:], []uint32{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinUint64ArrayPointer != nil && types.SliceNotContains(obj.FieldNinUint64ArrayPointer[:], []uint64{12, 34, 56})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64ArrayPointer elements must not be one of '12' '34' '56'"))
+	}
+	if !(obj.FieldNinFloat32ArrayPointer != nil && types.SliceNotContains(obj.FieldNinFloat32ArrayPointer[:], []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32ArrayPointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinFloat64ArrayPointer != nil && types.SliceNotContains(obj.FieldNinFloat64ArrayPointer[:], []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64ArrayPointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinBoolArrayPointer != nil && types.SliceNotContains(obj.FieldNinBoolArrayPointer[:], []bool{true})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolArrayPointer elements must not be one of 'true'"))
+	}
+	if !(obj.FieldNinStringMapPointer != nil && types.MapNotContains(*obj.FieldNinStringMapPointer, []string{"a", "b", "c"})) {
+		errs = append(errs, types.NewValidationError("FieldNinStringMapPointer elements must not be one of 'a' 'b' 'c'"))
+	}
+	if !(obj.FieldNinIntMapPointer != nil && types.MapNotContains(*obj.FieldNinIntMapPointer, []int{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinIntMapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinInt8MapPointer != nil && types.MapNotContains(*obj.FieldNinInt8MapPointer, []int8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt8MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinInt16MapPointer != nil && types.MapNotContains(*obj.FieldNinInt16MapPointer, []int16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt16MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinInt32MapPointer != nil && types.MapNotContains(*obj.FieldNinInt32MapPointer, []int32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt32MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinInt64MapPointer != nil && types.MapNotContains(*obj.FieldNinInt64MapPointer, []int64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinInt64MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinUintMapPointer != nil && types.MapNotContains(*obj.FieldNinUintMapPointer, []uint{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUintMapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinUint8MapPointer != nil && types.MapNotContains(*obj.FieldNinUint8MapPointer, []uint8{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint8MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinUint16MapPointer != nil && types.MapNotContains(*obj.FieldNinUint16MapPointer, []uint16{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint16MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinUint32MapPointer != nil && types.MapNotContains(*obj.FieldNinUint32MapPointer, []uint32{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint32MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinUint64MapPointer != nil && types.MapNotContains(*obj.FieldNinUint64MapPointer, []uint64{1, 2, 3})) {
+		errs = append(errs, types.NewValidationError("FieldNinUint64MapPointer elements must not be one of '1' '2' '3'"))
+	}
+	if !(obj.FieldNinFloat32MapPointer != nil && types.MapNotContains(*obj.FieldNinFloat32MapPointer, []float32{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat32MapPointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinFloat64MapPointer != nil && types.MapNotContains(*obj.FieldNinFloat64MapPointer, []float64{11.11, 22.22, 33.33})) {
+		errs = append(errs, types.NewValidationError("FieldNinFloat64MapPointer elements must not be one of '11.11' '22.22' '33.33'"))
+	}
+	if !(obj.FieldNinBoolMapPointer != nil && types.MapNotContains(*obj.FieldNinBoolMapPointer, []bool{false})) {
+		errs = append(errs, types.NewValidationError("FieldNinBoolMapPointer elements must not be one of 'false'"))
+	}
+	return errs
+}
+func requiredStructFieldsValidate(obj *requiredStructFields) []error {
+	var errs []error
+	if !(obj.FieldRequiredString != "") {
+		errs = append(errs, types.NewValidationError("FieldRequiredString is required"))
+	}
+	if !(obj.FieldRequiredInt != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt is required"))
+	}
+	if !(obj.FieldRequiredInt8 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8 is required"))
+	}
+	if !(obj.FieldRequiredInt16 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16 is required"))
+	}
+	if !(obj.FieldRequiredInt32 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32 is required"))
+	}
+	if !(obj.FieldRequiredInt64 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64 is required"))
+	}
+	if !(obj.FieldRequiredUint != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint is required"))
+	}
+	if !(obj.FieldRequiredUint8 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8 is required"))
+	}
+	if !(obj.FieldRequiredUint16 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16 is required"))
+	}
+	if !(obj.FieldRequiredUint32 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32 is required"))
+	}
+	if !(obj.FieldRequiredUint64 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64 is required"))
+	}
+	if !(obj.FieldRequiredFloat32 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32 is required"))
+	}
+	if !(obj.FieldRequiredFloat64 != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64 is required"))
+	}
+	if !(obj.FieldRequiredBool != false) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBool is required"))
+	}
+	if !(len(obj.FieldRequiredStringSlice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringSlice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredIntSlice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntSlice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt8Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt16Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt32Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt64Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUintSlice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintSlice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint8Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint16Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint32Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint64Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredFloat32Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredFloat64Slice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64Slice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredBoolSlice) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolSlice must not be empty"))
+	}
+	if !(len(obj.FieldRequiredStringMap) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringMap must not be empty"))
+	}
+	if !(len(obj.FieldRequiredIntMap) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntMap must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt8Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt16Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt32Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredInt64Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUintMap) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintMap must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint8Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint16Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint32Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredUint64Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredFloat32Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredFloat64Map) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64Map must not be empty"))
+	}
+	if !(len(obj.FieldRequiredBoolMap) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolMap must not be empty"))
+	}
+	return errs
+}
+func requiredStructFieldsPointerValidate(obj *requiredStructFieldsPointer) []error {
+	var errs []error
+	if !(obj.FieldRequiredStringPointer != nil && *obj.FieldRequiredStringPointer != "") {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringPointer is required"))
+	}
+	if !(obj.FieldRequiredIntPointer != nil && *obj.FieldRequiredIntPointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntPointer is required"))
+	}
+	if !(obj.FieldRequiredInt8Pointer != nil && *obj.FieldRequiredInt8Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8Pointer is required"))
+	}
+	if !(obj.FieldRequiredInt16Pointer != nil && *obj.FieldRequiredInt16Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16Pointer is required"))
+	}
+	if !(obj.FieldRequiredInt32Pointer != nil && *obj.FieldRequiredInt32Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32Pointer is required"))
+	}
+	if !(obj.FieldRequiredInt64Pointer != nil && *obj.FieldRequiredInt64Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64Pointer is required"))
+	}
+	if !(obj.FieldRequiredUintPointer != nil && *obj.FieldRequiredUintPointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintPointer is required"))
+	}
+	if !(obj.FieldRequiredUint8Pointer != nil && *obj.FieldRequiredUint8Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8Pointer is required"))
+	}
+	if !(obj.FieldRequiredUint16Pointer != nil && *obj.FieldRequiredUint16Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16Pointer is required"))
+	}
+	if !(obj.FieldRequiredUint32Pointer != nil && *obj.FieldRequiredUint32Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32Pointer is required"))
+	}
+	if !(obj.FieldRequiredUint64Pointer != nil && *obj.FieldRequiredUint64Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64Pointer is required"))
+	}
+	if !(obj.FieldRequiredFloat32Pointer != nil && *obj.FieldRequiredFloat32Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32Pointer is required"))
+	}
+	if !(obj.FieldRequiredFloat64Pointer != nil && *obj.FieldRequiredFloat64Pointer != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64Pointer is required"))
+	}
+	if !(obj.FieldRequiredBoolPointer != nil && *obj.FieldRequiredBoolPointer != false) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolPointer is required"))
+	}
+	if !(obj.FieldRequiredStringSlicePointer != nil && len(*obj.FieldRequiredStringSlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringSlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredIntSlicePointer != nil && len(*obj.FieldRequiredIntSlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntSlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt8SlicePointer != nil && len(*obj.FieldRequiredInt8SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt16SlicePointer != nil && len(*obj.FieldRequiredInt16SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt32SlicePointer != nil && len(*obj.FieldRequiredInt32SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt64SlicePointer != nil && len(*obj.FieldRequiredInt64SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUintSlicePointer != nil && len(*obj.FieldRequiredUintSlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintSlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint8SlicePointer != nil && len(*obj.FieldRequiredUint8SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint16SlicePointer != nil && len(*obj.FieldRequiredUint16SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint32SlicePointer != nil && len(*obj.FieldRequiredUint32SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint64SlicePointer != nil && len(*obj.FieldRequiredUint64SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat32SlicePointer != nil && len(*obj.FieldRequiredFloat32SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat64SlicePointer != nil && len(*obj.FieldRequiredFloat64SlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64SlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredBoolSlicePointer != nil && len(*obj.FieldRequiredBoolSlicePointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolSlicePointer must not be empty"))
+	}
+	if !(obj.FieldRequiredStringArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredIntArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt8ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt16ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt32ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt64ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUintArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint8ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint16ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint32ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint64ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat32ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat64ArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64ArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredBoolArrayPointer != nil) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolArrayPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredStringMapPointer != nil && len(*obj.FieldRequiredStringMapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredStringMapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredIntMapPointer != nil && len(*obj.FieldRequiredIntMapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredIntMapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt8MapPointer != nil && len(*obj.FieldRequiredInt8MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt8MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt16MapPointer != nil && len(*obj.FieldRequiredInt16MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt16MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt32MapPointer != nil && len(*obj.FieldRequiredInt32MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt32MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredInt64MapPointer != nil && len(*obj.FieldRequiredInt64MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredInt64MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUintMapPointer != nil && len(*obj.FieldRequiredUintMapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUintMapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint8MapPointer != nil && len(*obj.FieldRequiredUint8MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint8MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint16MapPointer != nil && len(*obj.FieldRequiredUint16MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint16MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint32MapPointer != nil && len(*obj.FieldRequiredUint32MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint32MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredUint64MapPointer != nil && len(*obj.FieldRequiredUint64MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredUint64MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat32MapPointer != nil && len(*obj.FieldRequiredFloat32MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat32MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredFloat64MapPointer != nil && len(*obj.FieldRequiredFloat64MapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredFloat64MapPointer must not be empty"))
+	}
+	if !(obj.FieldRequiredBoolMapPointer != nil && len(*obj.FieldRequiredBoolMapPointer) != 0) {
+		errs = append(errs, types.NewValidationError("FieldRequiredBoolMapPointer must not be empty"))
+	}
+	return errs
+}
diff --git a/types/string_utils.go b/types/string_utils.go
index 1aecbeb..73cd342 100644
--- a/types/string_utils.go
+++ b/types/string_utils.go
@@ -16,12 +16,7 @@ func EqualFold(s, t string) bool {
 
 // IsValidEmail validates if a string is a valid email format
 // Returns true for valid email format, false otherwise
-// Empty string returns true (for optional email fields)
 func IsValidEmail(email string) bool {
-	if email == "" {
-		return true // Empty email is valid for optional fields
-	}
-
 	// Use pre-compiled regex for better performance
 	return emailRegex.MatchString(email)
 }
diff --git a/types/string_utils_test.go b/types/string_utils_test.go
index 27c1480..7451f4e 100644
--- a/types/string_utils_test.go
+++ b/types/string_utils_test.go
@@ -8,11 +8,6 @@ func TestIsValidEmail(t *testing.T) {
 		email string
 		want  bool
 	}{
-		{
-			name:  "empty email (valid for optional fields)",
-			email: "",
-			want:  true,
-		},
 		{
 			name:  "valid simple email",
 			email: "test@example.com",
@@ -77,4 +72,4 @@ func TestIsValidEmail(t *testing.T) {
 			}
 		})
 	}
-}
\ No newline at end of file
+}