From 1d9fd75bbd960764bc72b7cea2854b2e738ab260 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 03:43:07 +0800
Subject: [PATCH 01/11] feat: add rules and filters for validation

---
 validation/benchmark_test.go   |  221 ++
 validation/errors_test.go      |  274 ++-
 validation/filters.go          |   96 +-
 validation/filters_test.go     |  517 +++++
 validation/options_test.go     |   17 +-
 validation/rules.go            | 1653 ++++++++++++++-
 validation/rules_db.go         |   82 +
 validation/rules_db_test.go    |  438 ++++
 validation/rules_test.go       | 3589 ++++++++++++++++++++++++++++++++
 validation/service_provider.go |    5 +
 validation/utils.go            |  356 ++++
 validation/utils_test.go       |   57 +
 validation/validation_test.go  | 2475 ++++------------------
 validation/validator_test.go   |  475 ++---
 14 files changed, 7739 insertions(+), 2516 deletions(-)
 create mode 100644 validation/benchmark_test.go
 create mode 100644 validation/filters_test.go
 create mode 100644 validation/rules_db.go
 create mode 100644 validation/rules_db_test.go
 create mode 100644 validation/rules_test.go

diff --git a/validation/benchmark_test.go b/validation/benchmark_test.go
new file mode 100644
index 000000000..4964f061d
--- /dev/null
+++ b/validation/benchmark_test.go
@@ -0,0 +1,221 @@
+package validation
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	contractsvalidation "github.com/goravel/framework/contracts/validation"
+)
+
+// --- End-to-end validation benchmarks ---
+
+func BenchmarkValidation_Simple(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	data := map[string]any{
+		"name":  "John",
+		"email": "john@example.com",
+		"age":   "25",
+	}
+	rules := map[string]any{
+		"name":  "required|string|max:255",
+		"email": "required|email",
+		"age":   "required|integer|min:1|max:150",
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = v.Make(ctx, data, rules)
+	}
+}
+
+func BenchmarkValidation_ManyFields(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	data := make(map[string]any, 50)
+	rules := make(map[string]any, 50)
+	for i := range 50 {
+		key := fmt.Sprintf("field_%d", i)
+		data[key] = fmt.Sprintf("value_%d", i)
+		rules[key] = "required|string|min:1|max:255"
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = v.Make(ctx, data, rules)
+	}
+}
+
+func BenchmarkValidation_ComplexRules(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	data := map[string]any{
+		"email":                 "test@example.com",
+		"website":               "https://example.com",
+		"code":                  "ABC-123",
+		"start_date":            "2024-01-01",
+		"end_date":              "2024-12-31",
+		"password":              "secret123",
+		"password_confirmation": "secret123",
+	}
+	rules := map[string]any{
+		"email":      "required|email",
+		"website":    "required|url",
+		"code":       []string{"required", "regex:^[A-Z]{3}-[0-9]{3}$"},
+		"start_date": "required|date|before:end_date",
+		"end_date":   "required|date|after:start_date",
+		"password":   "required|string|min:8|confirmed",
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = v.Make(ctx, data, rules)
+	}
+}
+
+func BenchmarkValidation_Wildcards(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	items := make([]any, 20)
+	for i := range 20 {
+		items[i] = map[string]any{
+			"name":  fmt.Sprintf("Item %d", i),
+			"price": fmt.Sprintf("%d.99", i+1),
+			"qty":   fmt.Sprintf("%d", i+1),
+		}
+	}
+	data := map[string]any{"items": items}
+	rules := map[string]any{
+		"items":         "required|array|min:1",
+		"items.*.name":  "required|string|max:100",
+		"items.*.price": "required|numeric|min:0",
+		"items.*.qty":   "required|integer|min:1",
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = v.Make(ctx, data, rules)
+	}
+}
+
+func BenchmarkValidation_AllInvalid(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	data := map[string]any{
+		"name":  "",
+		"email": "not-an-email",
+		"age":   "not-a-number",
+		"url":   "not-a-url",
+		"date":  "not-a-date",
+	}
+	rules := map[string]any{
+		"name":  "required|string|min:1",
+		"email": "required|email",
+		"age":   "required|integer|min:1|max:150",
+		"url":   "required|url",
+		"date":  "required|date",
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = v.Make(ctx, data, rules)
+	}
+}
+
+func BenchmarkValidation_WithFilters(b *testing.B) {
+	v := NewValidation()
+	ctx := context.Background()
+	rules := map[string]any{
+		"name":  "required|string|max:255",
+		"email": "required|email",
+		"bio":   "required|string",
+	}
+	opts := []contractsvalidation.Option{
+		Filters(map[string]any{
+			"name":  "trim",
+			"email": "trim|lower",
+			"bio":   "trim|strip_tags",
+		}),
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		// Data is mutated by filters, so recreate it each iteration
+		dataCopy := map[string]any{
+			"name":  "  John Doe  ",
+			"email": "  JOHN@EXAMPLE.COM  ",
+			"bio":   "  <b>Hello</b> World  ",
+		}
+		_, _ = v.Make(ctx, dataCopy, rules, opts...)
+	}
+}
+
+// --- Component benchmarks ---
+
+func BenchmarkRuleParser_Simple(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		ParseRules("required|string|max:255")
+	}
+}
+
+func BenchmarkRuleParser_Complex(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		ParseRules("required|string|min:1|max:255|in:a,b,c,d,e")
+	}
+}
+
+func BenchmarkDataBag_Get_Flat(b *testing.B) {
+	bag, _ := NewDataBag(map[string]any{"name": "John", "age": 25})
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = bag.Get("name")
+	}
+}
+
+func BenchmarkDataBag_Get_Nested(b *testing.B) {
+	bag, _ := NewDataBag(map[string]any{
+		"user": map[string]any{
+			"profile": map[string]any{
+				"name": "John",
+			},
+		},
+	})
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _ = bag.Get("user.profile.name")
+	}
+}
+
+func BenchmarkExpandWildcardFields(b *testing.B) {
+	rules := map[string][]ParsedRule{
+		"items.*.name":  {{Name: "required"}, {Name: "string"}},
+		"items.*.price": {{Name: "required"}, {Name: "numeric"}},
+		"items.*.qty":   {{Name: "required"}, {Name: "integer"}},
+	}
+	keys := make([]string, 0, 100)
+	for i := range 20 {
+		keys = append(keys, fmt.Sprintf("items.%d", i))
+		keys = append(keys, fmt.Sprintf("items.%d.name", i))
+		keys = append(keys, fmt.Sprintf("items.%d.price", i))
+		keys = append(keys, fmt.Sprintf("items.%d.qty", i))
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = expandWildcardFields(rules, keys, true)
+	}
+}
diff --git a/validation/errors_test.go b/validation/errors_test.go
index 4175a32e9..0d6b4cff0 100644
--- a/validation/errors_test.go
+++ b/validation/errors_test.go
@@ -1,87 +1,229 @@
 package validation
 
 import (
+	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-)
 
-func TestErrors_One(t *testing.T) {
-	t.Run("empty errors", func(t *testing.T) {
-		errors := NewErrors()
-		assert.Equal(t, "", errors.One())
-	})
+	httpvalidate "github.com/goravel/framework/contracts/validation"
+)
 
-	t.Run("returns first error", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		assert.Equal(t, "The a field is required.", errors.One())
-	})
+func TestOne(t *testing.T) {
+	tests := []struct {
+		describe  string
+		data      any
+		rules     map[string]any
+		options   []httpvalidate.Option
+		expectRes string
+	}{
+		{
+			describe: "errors is empty",
+			data:     map[string]any{"a": "aa"},
+			rules:    map[string]any{"a": "required"},
+			options: []httpvalidate.Option{
+				Filters(map[string]any{"a": "trim"}),
+			},
+		},
+		{
+			describe: "errors isn't empty",
+			data:     map[string]any{"a": ""},
+			rules:    map[string]any{"a": "required"},
+			options: []httpvalidate.Option{
+				Filters(map[string]any{"a": "trim"}),
+			},
+			expectRes: "The a field is required.",
+		},
+		{
+			describe: "errors isn't empty when setting messages option",
+			data:     map[string]any{"a": ""},
+			rules:    map[string]any{"a": "required"},
+			options: []httpvalidate.Option{
+				Filters(map[string]any{"a": "trim"}),
+				Messages(map[string]string{"a.required": "a can't be empty"}),
+			},
+			expectRes: "a can't be empty",
+		},
+		{
+			describe: "errors isn't empty when setting attributes option",
+			data:     map[string]any{"a": ""},
+			rules:    map[string]any{"a": "required"},
+			options: []httpvalidate.Option{
+				Filters(map[string]any{"a": "trim"}),
+				Attributes(map[string]string{"a": "aa"}),
+			},
+			expectRes: "The aa field is required.",
+		},
+		{
+			describe: "errors isn't empty when setting messages and attributes option",
+			data:     map[string]any{"a": ""},
+			rules:    map[string]any{"a": "required"},
+			options: []httpvalidate.Option{
+				Filters(map[string]any{"a": "trim"}),
+				Messages(map[string]string{"a.required": ":attribute can't be empty"}),
+				Attributes(map[string]string{"a": "aa"}),
+			},
+			expectRes: "aa can't be empty",
+		},
+	}
 
-	t.Run("returns first error for specific field", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		errors.Add("b", "required", "The b field is required.")
-		assert.Equal(t, "The a field is required.", errors.One("a"))
-		assert.Equal(t, "The b field is required.", errors.One("b"))
-	})
-}
+	for _, test := range tests {
+		t.Run(test.describe, func(t *testing.T) {
+			maker := NewValidation()
+			validator, err := maker.Make(
+				context.Background(),
+				test.data,
+				test.rules,
+				test.options...,
+			)
 
-func TestErrors_Get(t *testing.T) {
-	t.Run("empty errors", func(t *testing.T) {
-		errors := NewErrors()
-		assert.Empty(t, errors.Get("a"))
-	})
+			assert.Nil(t, err, test.describe)
+			assert.NotNil(t, validator, test.describe)
 
-	t.Run("returns field errors", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		errors.Add("b", "required", "The b field is required.")
-		assert.Equal(t, map[string]string{"required": "The a field is required."}, errors.Get("a"))
-		assert.Equal(t, map[string]string{"required": "The b field is required."}, errors.Get("b"))
-	})
+			if test.expectRes != "" {
+				errors := validator.Errors()
+				assert.NotNil(t, errors)
+				assert.Equal(t, test.expectRes, errors.One(), test.describe)
+			}
+		})
+	}
 }
 
-func TestErrors_All(t *testing.T) {
-	t.Run("empty errors", func(t *testing.T) {
-		errors := NewErrors()
-		assert.Empty(t, errors.All())
-	})
+func TestGet(t *testing.T) {
+	tests := []struct {
+		describe string
+		data     any
+		rules    map[string]any
+		filters  map[string]any
+		expectA  map[string]string
+		expectB  map[string]string
+	}{
+		{
+			describe: "errors is empty",
+			data:     map[string]any{"a": "aa", "b": "bb"},
+			rules:    map[string]any{"a": "required", "b": "required"},
+			filters:  map[string]any{"a": "trim", "b": "trim"},
+		},
+		{
+			describe: "errors isn't empty",
+			data:     map[string]any{"c": "cc"},
+			rules:    map[string]any{"a": "required", "b": "required"},
+			filters:  map[string]any{"a": "trim", "b": "trim"},
+			expectA:  map[string]string{"required": "The a field is required."},
+			expectB:  map[string]string{"required": "The b field is required."},
+		},
+	}
 
-	t.Run("returns all errors", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		errors.Add("b", "required", "The b field is required.")
-		assert.Equal(t, map[string]map[string]string{
-			"a": {"required": "The a field is required."},
-			"b": {"required": "The b field is required."},
-		}, errors.All())
-	})
+	for _, test := range tests {
+		t.Run(test.describe, func(t *testing.T) {
+			maker := NewValidation()
+			validator, err := maker.Make(
+				context.Background(),
+				test.data,
+				test.rules,
+				Filters(test.filters),
+			)
+			assert.Nil(t, err, test.describe)
+			if len(test.expectA) > 0 {
+				errors := validator.Errors()
+				assert.NotNil(t, errors)
+				assert.Equal(t, test.expectA, errors.Get("a"), test.describe)
+			}
+			if len(test.expectB) > 0 {
+				errors := validator.Errors()
+				assert.NotNil(t, errors)
+				assert.Equal(t, test.expectB, errors.Get("b"), test.describe)
+			}
+		})
+	}
 }
 
-func TestErrors_Has(t *testing.T) {
-	t.Run("empty errors", func(t *testing.T) {
-		errors := NewErrors()
-		assert.False(t, errors.Has("a"))
-	})
+func TestAll(t *testing.T) {
+	tests := []struct {
+		describe  string
+		data      any
+		rules     map[string]any
+		filters   map[string]any
+		expectRes map[string]map[string]string
+	}{
+		{
+			describe:  "errors is empty",
+			data:      map[string]any{"a": "aa", "b": "bb"},
+			rules:     map[string]any{"a": "required", "b": "required"},
+			filters:   map[string]any{"a": "trim", "b": "trim"},
+			expectRes: nil,
+		},
+		{
+			describe: "errors isn't empty",
+			data:     map[string]any{"c": "cc"},
+			rules:    map[string]any{"a": "required", "b": "required"},
+			filters:  map[string]any{"a": "trim", "b": "trim"},
+			expectRes: map[string]map[string]string{
+				"a": {"required": "The a field is required."},
+				"b": {"required": "The b field is required."},
+			},
+		},
+	}
 
-	t.Run("has field with errors", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		assert.True(t, errors.Has("a"))
-		assert.False(t, errors.Has("b"))
-	})
+	for _, test := range tests {
+		t.Run(test.describe, func(t *testing.T) {
+			maker := NewValidation()
+			validator, err := maker.Make(
+				context.Background(),
+				test.data,
+				test.rules,
+				Filters(test.filters),
+			)
+			assert.Nil(t, err, test.describe)
+			if len(test.expectRes) > 0 {
+				errors := validator.Errors()
+				assert.NotNil(t, errors)
+				assert.Equal(t, test.expectRes, errors.All(), test.describe)
+			} else {
+				assert.Nil(t, validator.Errors(), test.describe)
+			}
+		})
+	}
 }
 
-func TestErrors_IsEmpty(t *testing.T) {
-	t.Run("empty", func(t *testing.T) {
-		errors := NewErrors()
-		assert.True(t, errors.IsEmpty())
-	})
+func TestHas(t *testing.T) {
+	tests := []struct {
+		describe  string
+		data      any
+		rules     map[string]any
+		filters   map[string]any
+		expectRes bool
+	}{
+		{
+			describe: "errors is empty",
+			data:     map[string]any{"a": "aa", "b": "bb"},
+			rules:    map[string]any{"a": "required", "b": "required"},
+			filters:  map[string]any{"a": "trim", "b": "trim"},
+		},
+		{
+			describe:  "errors isn't empty",
+			data:      map[string]any{"c": "cc"},
+			rules:     map[string]any{"a": "required", "b": "required"},
+			filters:   map[string]any{"a": "trim", "b": "trim"},
+			expectRes: true,
+		},
+	}
 
-	t.Run("not empty", func(t *testing.T) {
-		errors := NewErrors()
-		errors.Add("a", "required", "The a field is required.")
-		assert.False(t, errors.IsEmpty())
-	})
+	for _, test := range tests {
+		t.Run(test.describe, func(t *testing.T) {
+			maker := NewValidation()
+			validator, err := maker.Make(
+				context.Background(),
+				test.data,
+				test.rules,
+				Filters(test.filters),
+			)
+			assert.Nil(t, err, test.describe)
+			if test.expectRes {
+				errors := validator.Errors()
+				assert.NotNil(t, errors)
+				assert.Equal(t, test.expectRes, errors.Has("a"), test.describe)
+			}
+		})
+	}
 }
diff --git a/validation/filters.go b/validation/filters.go
index f5964c6ab..a38a79f43 100644
--- a/validation/filters.go
+++ b/validation/filters.go
@@ -3,16 +3,110 @@ package validation
 import (
 	"context"
 	"fmt"
+	"html"
+	"net/url"
 	"reflect"
+	"strings"
+	"unicode"
 
 	"github.com/spf13/cast"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
 
 	validatecontract "github.com/goravel/framework/contracts/validation"
 	"github.com/goravel/framework/errors"
 )
 
 // builtinFilters contains all built-in filter functions.
-var builtinFilters = map[string]func(val any) any{}
+var builtinFilters = map[string]func(val any) any{
+	// String cleaning
+	"trim": func(val any) any {
+		return strings.TrimSpace(cast.ToString(val))
+	},
+	"ltrim": func(val any) any {
+		return strings.TrimLeft(cast.ToString(val), " \t\n\r")
+	},
+	"rtrim": func(val any) any {
+		return strings.TrimRight(cast.ToString(val), " \t\n\r")
+	},
+
+	// Case conversion
+	"lower": func(val any) any {
+		return strings.ToLower(cast.ToString(val))
+	},
+	"upper": func(val any) any {
+		return strings.ToUpper(cast.ToString(val))
+	},
+	"title": func(val any) any {
+		return cases.Title(language.Und).String(cast.ToString(val))
+	},
+	"ucfirst": func(val any) any {
+		s := cast.ToString(val)
+		if len(s) == 0 {
+			return s
+		}
+		runes := []rune(s)
+		runes[0] = unicode.ToUpper(runes[0])
+		return string(runes)
+	},
+	"lcfirst": func(val any) any {
+		s := cast.ToString(val)
+		if len(s) == 0 {
+			return s
+		}
+		runes := []rune(s)
+		runes[0] = unicode.ToLower(runes[0])
+		return string(runes)
+	},
+
+	// Naming style
+	"camel": func(val any) any {
+		return toCamelCase(cast.ToString(val))
+	},
+	"snake": func(val any) any {
+		return toSnakeCase(cast.ToString(val))
+	},
+
+	// Type conversion
+	"to_int": func(val any) any {
+		return cast.ToInt(val)
+	},
+	"to_uint": func(val any) any {
+		return cast.ToUint(val)
+	},
+	"to_float": func(val any) any {
+		return cast.ToFloat64(val)
+	},
+	"to_bool": func(val any) any {
+		return cast.ToBool(val)
+	},
+	"to_string": func(val any) any {
+		return cast.ToString(val)
+	},
+	"to_time": func(val any) any {
+		return cast.ToTime(val)
+	},
+
+	// Encoding
+	"escape_html": func(val any) any {
+		return html.EscapeString(cast.ToString(val))
+	},
+	"url_encode": func(val any) any {
+		return url.QueryEscape(cast.ToString(val))
+	},
+	"url_decode": func(val any) any {
+		decoded, err := url.QueryUnescape(cast.ToString(val))
+		if err != nil {
+			return cast.ToString(val)
+		}
+		return decoded
+	},
+
+	// Cleaning
+	"strip_tags": func(val any) any {
+		return stripHTMLTags(cast.ToString(val))
+	},
+}
 
 // applyFilters applies filter rules to the DataBag.
 // Supports wildcard patterns (e.g., "users.*.name": "trim") that expand
diff --git a/validation/filters_test.go b/validation/filters_test.go
new file mode 100644
index 000000000..b51a50596
--- /dev/null
+++ b/validation/filters_test.go
@@ -0,0 +1,517 @@
+package validation
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	contractsvalidation "github.com/goravel/framework/contracts/validation"
+)
+
+func TestBuiltinFilters(t *testing.T) {
+	tests := []struct {
+		name     string
+		filter   string
+		input    any
+		expected any
+	}{
+		// String cleaning
+		{"trim", "trim", "  hello  ", "hello"},
+		{"ltrim", "ltrim", "  hello  ", "hello  "},
+		{"rtrim", "rtrim", "  hello  ", "  hello"},
+
+		// Case conversion
+		{"lower", "lower", "HELLO", "hello"},
+		{"upper", "upper", "hello", "HELLO"},
+		{"title", "title", "hello world", "Hello World"},
+		{"ucfirst", "ucfirst", "hello", "Hello"},
+		{"ucfirst empty", "ucfirst", "", ""},
+		{"lcfirst", "lcfirst", "Hello", "hello"},
+		{"lcfirst empty", "lcfirst", "", ""},
+
+		// Naming style
+		{"camel from snake", "camel", "hello_world", "helloWorld"},
+		{"camel from words", "camel", "hello world", "helloWorld"},
+		{"snake from camel", "snake", "helloWorld", "hello_world"},
+		{"snake from words", "snake", "hello world", "hello_world"},
+
+		// Type conversion
+		{"to_int from string", "to_int", "42", 42},
+		{"to_int from float", "to_int", 42.9, 42},
+		{"to_uint from string", "to_uint", "42", uint(42)},
+		{"to_float from string", "to_float", "3.14", 3.14},
+		{"to_bool true", "to_bool", "true", true},
+		{"to_bool false", "to_bool", "false", false},
+		{"to_string from int", "to_string", 42, "42"},
+
+		// Encoding
+		{"escape_html", "escape_html", "<script>alert('xss')</script>", "&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;"},
+		{"url_encode", "url_encode", "hello world&foo=bar", "hello+world%26foo%3Dbar"},
+		{"url_decode", "url_decode", "hello+world%26foo%3Dbar", "hello world&foo=bar"},
+		{"url_decode invalid", "url_decode", "%zz", "%zz"},
+
+		// Cleaning
+		{"strip_tags", "strip_tags", "<p>Hello <b>World</b></p>", "Hello World"},
+		{"strip_tags no tags", "strip_tags", "Hello World", "Hello World"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fn, ok := builtinFilters[tt.filter]
+			require.True(t, ok, "builtin filter %s not found", tt.filter)
+			result := fn(tt.input)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestApplyFilters(t *testing.T) {
+	t.Run("apply builtin filters", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name":  "  Hello World  ",
+			"email": "TEST@EXAMPLE.COM",
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"name":  "trim|lower",
+			"email": "lower",
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("name")
+		assert.Equal(t, "hello world", val)
+
+		val, _ = bag.Get("email")
+		assert.Equal(t, "test@example.com", val)
+	})
+
+	t.Run("skip non-existent field", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "hello",
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"nonexistent": "trim",
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("name")
+		assert.Equal(t, "hello", val)
+	})
+
+	t.Run("empty filter rules", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "hello",
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("name")
+		assert.Equal(t, "hello", val)
+	})
+
+	t.Run("apply custom filter", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "hello",
+		})
+		require.NoError(t, err)
+
+		customFilter := &mockFilter{
+			signature: "reverse",
+			handler: func(val string) string {
+				runes := []rune(val)
+				for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+					runes[i], runes[j] = runes[j], runes[i]
+				}
+				return string(runes)
+			},
+		}
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"name": "reverse",
+		}, []contractsvalidation.Filter{customFilter})
+		require.NoError(t, err)
+
+		val, _ := bag.Get("name")
+		assert.Equal(t, "olleh", val)
+	})
+
+	t.Run("chain builtin and custom filters", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "  Hello  ",
+		})
+		require.NoError(t, err)
+
+		customFilter := &mockFilter{
+			signature: "append_exclaim",
+			handler: func(val string) string {
+				return val + "!"
+			},
+		}
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"name": "trim|lower|append_exclaim",
+		}, []contractsvalidation.Filter{customFilter})
+		require.NoError(t, err)
+
+		val, _ := bag.Get("name")
+		assert.Equal(t, "hello!", val)
+	})
+
+	t.Run("invalid filter type returns error", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "hello",
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"name": 123,
+		}, nil)
+		assert.Error(t, err)
+	})
+}
+
+func TestCallFilterFunc(t *testing.T) {
+	t.Run("single return value", func(t *testing.T) {
+		filter := &mockFilter{
+			signature: "double",
+			handler: func(val int) int {
+				return val * 2
+			},
+		}
+
+		result, err := callFilterFunc(context.Background(), filter, 5, nil)
+		assert.NoError(t, err)
+		assert.Equal(t, 10, result)
+	})
+
+	t.Run("return value with error", func(t *testing.T) {
+		filter := &mockFilter{
+			signature: "safe_parse",
+			handler: func(val string) (int, error) {
+				if val == "bad" {
+					return 0, fmt.Errorf("bad value")
+				}
+				return 42, nil
+			},
+		}
+
+		result, err := callFilterFunc(context.Background(), filter, "good", nil)
+		assert.NoError(t, err)
+		assert.Equal(t, 42, result)
+
+		_, err = callFilterFunc(context.Background(), filter, "bad", nil)
+		assert.Error(t, err)
+	})
+
+	t.Run("variadic arguments", func(t *testing.T) {
+		filter := &mockFilter{
+			signature: "default_val",
+			handler: func(val string, def ...string) string {
+				if val == "" && len(def) > 0 {
+					return def[0]
+				}
+				return val
+			},
+		}
+
+		result, err := callFilterFunc(context.Background(), filter, "", []string{"default"})
+		assert.NoError(t, err)
+		assert.Equal(t, "default", result)
+
+		result, err = callFilterFunc(context.Background(), filter, "actual", nil)
+		assert.NoError(t, err)
+		assert.Equal(t, "actual", result)
+	})
+
+	t.Run("nil handler", func(t *testing.T) {
+		filter := &mockFilter{
+			signature: "nil_handler",
+			handler:   nil,
+		}
+
+		_, err := callFilterFunc(context.Background(), filter, "test", nil)
+		assert.Error(t, err)
+	})
+
+	t.Run("non-function handler", func(t *testing.T) {
+		filter := &mockFilter{
+			signature: "not_func",
+			handler:   "not a function",
+		}
+
+		_, err := callFilterFunc(context.Background(), filter, "test", nil)
+		assert.Error(t, err)
+	})
+}
+
+func TestFiltersIntegration(t *testing.T) {
+	t.Run("filters applied before validation", func(t *testing.T) {
+		validation := NewValidation()
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"name": "  goravel  ",
+		}, map[string]any{
+			"name": "required|string",
+		}, Filters(map[string]any{
+			"name": "trim",
+		}))
+		assert.NoError(t, err)
+		assert.False(t, validator.Fails())
+
+		val := validator.Validated()
+		assert.Equal(t, "goravel", val["name"])
+	})
+
+	t.Run("filters with type conversion", func(t *testing.T) {
+		validation := NewValidation()
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"age": "25",
+		}, map[string]any{
+			"age": "required",
+		}, Filters(map[string]any{
+			"age": "to_int",
+		}))
+		assert.NoError(t, err)
+		assert.False(t, validator.Fails())
+
+		val := validator.Validated()
+		assert.Equal(t, 25, val["age"])
+	})
+
+	t.Run("filters with custom filter via AddFilters", func(t *testing.T) {
+		validation := NewValidation()
+		err := validation.AddFilters([]contractsvalidation.Filter{
+			&mockFilter{
+				signature: "prefix_hello",
+				handler: func(val string) string {
+					return "hello_" + val
+				},
+			},
+		})
+		require.NoError(t, err)
+
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"name": "world",
+		}, map[string]any{
+			"name": "required",
+		}, Filters(map[string]any{
+			"name": "prefix_hello",
+		}))
+		assert.NoError(t, err)
+		assert.False(t, validator.Fails())
+
+		val := validator.Validated()
+		assert.Equal(t, "hello_world", val["name"])
+	})
+
+	t.Run("filters with custom filter via option", func(t *testing.T) {
+		validation := NewValidation()
+
+		customFilter := &mockFilter{
+			signature: "suffix_test",
+			handler: func(val string) string {
+				return val + "_test"
+			},
+		}
+
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"name": "hello",
+		}, map[string]any{
+			"name": "required",
+		},
+			Filters(map[string]any{
+				"name": "suffix_test",
+			}),
+			CustomFilters([]contractsvalidation.Filter{customFilter}),
+		)
+		assert.NoError(t, err)
+		assert.False(t, validator.Fails())
+
+		val := validator.Validated()
+		assert.Equal(t, "hello_test", val["name"])
+	})
+}
+
+func TestApplyFiltersWithWildcards(t *testing.T) {
+	t.Run("wildcard filter on nested slice", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"users": []any{
+				map[string]any{"name": "  Alice  ", "email": "ALICE@EXAMPLE.COM"},
+				map[string]any{"name": "  Bob  ", "email": "BOB@EXAMPLE.COM"},
+			},
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"users.*.name":  "trim",
+			"users.*.email": "lower",
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("users.0.name")
+		assert.Equal(t, "Alice", val)
+		val, _ = bag.Get("users.1.name")
+		assert.Equal(t, "Bob", val)
+		val, _ = bag.Get("users.0.email")
+		assert.Equal(t, "alice@example.com", val)
+		val, _ = bag.Get("users.1.email")
+		assert.Equal(t, "bob@example.com", val)
+	})
+
+	t.Run("wildcard filter with chained filters", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"items": []any{
+				map[string]any{"title": "  HELLO WORLD  "},
+				map[string]any{"title": "  FOO BAR  "},
+			},
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"items.*.title": "trim|lower",
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("items.0.title")
+		assert.Equal(t, "hello world", val)
+		val, _ = bag.Get("items.1.title")
+		assert.Equal(t, "foo bar", val)
+	})
+
+	t.Run("wildcard filter with no matching data", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"name": "  hello  ",
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"users.*.name": "trim",
+		}, nil)
+		require.NoError(t, err)
+
+		// Original data should not be affected
+		val, _ := bag.Get("name")
+		assert.Equal(t, "  hello  ", val)
+	})
+
+	t.Run("wildcard filter with slice syntax", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"tags": []any{
+				map[string]any{"value": "  Go  "},
+				map[string]any{"value": "  Rust  "},
+			},
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"tags.*.value": []string{"trim", "upper"},
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("tags.0.value")
+		assert.Equal(t, "GO", val)
+		val, _ = bag.Get("tags.1.value")
+		assert.Equal(t, "RUST", val)
+	})
+
+	t.Run("mixed wildcard and direct fields", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"title": "  ADMIN  ",
+			"users": []any{
+				map[string]any{"name": "  Alice  "},
+			},
+		})
+		require.NoError(t, err)
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"title":        "trim|lower",
+			"users.*.name": "trim",
+		}, nil)
+		require.NoError(t, err)
+
+		val, _ := bag.Get("title")
+		assert.Equal(t, "admin", val)
+		val, _ = bag.Get("users.0.name")
+		assert.Equal(t, "Alice", val)
+	})
+
+	t.Run("wildcard filter with custom filter", func(t *testing.T) {
+		bag, err := NewDataBag(map[string]any{
+			"items": []any{
+				map[string]any{"code": "abc"},
+				map[string]any{"code": "def"},
+			},
+		})
+		require.NoError(t, err)
+
+		customFilter := &mockFilter{
+			signature: "prefix_item",
+			handler: func(val string) string {
+				return "item_" + val
+			},
+		}
+
+		err = applyFilters(context.Background(), bag, map[string]any{
+			"items.*.code": "prefix_item",
+		}, []contractsvalidation.Filter{customFilter})
+		require.NoError(t, err)
+
+		val, _ := bag.Get("items.0.code")
+		assert.Equal(t, "item_abc", val)
+		val, _ = bag.Get("items.1.code")
+		assert.Equal(t, "item_def", val)
+	})
+}
+
+func TestAddFilters(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		validation := NewValidation()
+		err := validation.AddFilters([]contractsvalidation.Filter{
+			&mockFilter{signature: "test_filter"},
+		})
+		assert.NoError(t, err)
+		assert.Len(t, validation.Filters(), 1)
+	})
+
+	t.Run("duplicate filter", func(t *testing.T) {
+		validation := NewValidation()
+		err := validation.AddFilters([]contractsvalidation.Filter{
+			&mockFilter{signature: "test_filter"},
+		})
+		assert.NoError(t, err)
+
+		err = validation.AddFilters([]contractsvalidation.Filter{
+			&mockFilter{signature: "test_filter"},
+		})
+		assert.Error(t, err)
+	})
+
+	t.Run("duplicate builtin filter", func(t *testing.T) {
+		validation := NewValidation()
+		err := validation.AddFilters([]contractsvalidation.Filter{
+			&mockFilter{signature: "trim"},
+		})
+		assert.Error(t, err)
+	})
+}
+
+// mockFilter is a test helper that implements the Filter interface.
+type mockFilter struct {
+	signature string
+	handler   any
+}
+
+func (m *mockFilter) Signature() string {
+	return m.signature
+}
+
+func (m *mockFilter) Handle(_ context.Context) any {
+	return m.handler
+}
diff --git a/validation/options_test.go b/validation/options_test.go
index fd427f56a..a562bbff1 100644
--- a/validation/options_test.go
+++ b/validation/options_test.go
@@ -19,8 +19,8 @@ func TestFiltersOption(t *testing.T) {
 }
 
 func TestCustomFiltersOption(t *testing.T) {
-	mockFilter := &mockFilter{signature: "test"}
-	customFilters := []contractsvalidation.Filter{mockFilter}
+	f := &mockFilter{signature: "test"}
+	customFilters := []contractsvalidation.Filter{f}
 
 	opts := &contractsvalidation.Options{}
 	CustomFilters(customFilters)(opts)
@@ -58,19 +58,6 @@ func TestPrepareForValidationOption(t *testing.T) {
 	assert.NotNil(t, opts.PrepareForValidation)
 }
 
-type mockFilter struct {
-	signature string
-	handler   any
-}
-
-func (m *mockFilter) Signature() string {
-	return m.signature
-}
-
-func (m *mockFilter) Handle(_ context.Context) any {
-	return m.handler
-}
-
 func TestApplyOptions(t *testing.T) {
 	tests := []struct {
 		name    string
diff --git a/validation/rules.go b/validation/rules.go
index f71253a92..390f29aa9 100644
--- a/validation/rules.go
+++ b/validation/rules.go
@@ -2,6 +2,25 @@ package validation
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
+	"image"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"io"
+	"math"
+	"mime/multipart"
+	"net"
+	"net/mail"
+	"net/url"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
 )
 
 // RuleContext provides context for rule evaluation.
@@ -15,13 +34,1639 @@ type RuleContext struct {
 }
 
 // builtinRules maps rule names to their implementations.
-var builtinRules = map[string]func(ctx *RuleContext) bool{}
+var builtinRules = map[string]func(ctx *RuleContext) bool{
+	// Existence
+	"required":             ruleRequired,
+	"required_if":          ruleRequiredIf,
+	"required_unless":      ruleRequiredUnless,
+	"required_with":        ruleRequiredWith,
+	"required_with_all":    ruleRequiredWithAll,
+	"required_without":     ruleRequiredWithout,
+	"required_without_all": ruleRequiredWithoutAll,
+	"required_if_accepted": ruleRequiredIfAccepted,
+	"required_if_declined": ruleRequiredIfDeclined,
+	"filled":               ruleFilled,
+	"present":              rulePresent,
+	"present_if":           rulePresentIf,
+	"present_unless":       rulePresentUnless,
+	"present_with":         rulePresentWith,
+	"present_with_all":     rulePresentWithAll,
+	"missing":              ruleMissing,
+	"missing_if":           ruleMissingIf,
+	"missing_unless":       ruleMissingUnless,
+	"missing_with":         ruleMissingWith,
+	"missing_with_all":     ruleMissingWithAll,
+
+	// Accept/Decline
+	"accepted":    ruleAccepted,
+	"accepted_if": ruleAcceptedIf,
+	"declined":    ruleDeclined,
+	"declined_if": ruleDeclinedIf,
+
+	// Prohibition
+	"prohibited":             ruleProhibited,
+	"prohibited_if":          ruleProhibitedIf,
+	"prohibited_unless":      ruleProhibitedUnless,
+	"prohibited_if_accepted": ruleProhibitedIfAccepted,
+	"prohibited_if_declined": ruleProhibitedIfDeclined,
+	"prohibits":              ruleProhibits,
+
+	// Type
+	"string":  ruleString,
+	"integer": ruleInteger,
+	"int":     ruleInteger, // Go alias
+	"numeric": ruleNumeric,
+	"boolean": ruleBoolean,
+	"bool":    ruleBoolean, // Go alias
+	"float":   ruleFloat,   // Go-specific
+	"array":   ruleArray,
+	"list":    ruleList,
+	"slice":   ruleSlice, // Go alias for list
+	"map":     ruleMap,   // Go-specific
+
+	// Size
+	"size":    ruleSize,
+	"min":     ruleMin,
+	"max":     ruleMax,
+	"between": ruleBetween,
+	"gt":      ruleGt,
+	"gte":     ruleGte,
+	"lt":      ruleLt,
+	"lte":     ruleLte,
+
+	// Numeric
+	"digits":         ruleDigits,
+	"digits_between": ruleDigitsBetween,
+	"decimal":        ruleDecimal,
+	"multiple_of":    ruleMultipleOf,
+	"min_digits":     ruleMinDigits,
+	"max_digits":     ruleMaxDigits,
+
+	// String format
+	"alpha":       ruleAlpha,
+	"alpha_num":   ruleAlphaNum,
+	"alpha_dash":  ruleAlphaDash,
+	"ascii":       ruleAscii,
+	"email":       ruleEmail,
+	"url":         ruleUrl,
+	"active_url":  ruleActiveUrl,
+	"ip":          ruleIp,
+	"ipv4":        ruleIpv4,
+	"ipv6":        ruleIpv6,
+	"mac_address": ruleMacAddress,
+	"mac":         ruleMacAddress, // alias
+	"json":        ruleJson,
+	"uuid":        ruleUuid,
+	"ulid":        ruleUlid,
+	"hex_color":   ruleHexColor,
+	"regex":       ruleRegex,
+	"not_regex":   ruleNotRegex,
+	"lowercase":   ruleLowercase,
+	"uppercase":   ruleUppercase,
+
+	// String content
+	"starts_with":       ruleStartsWith,
+	"doesnt_start_with": ruleDoesntStartWith,
+	"ends_with":         ruleEndsWith,
+	"doesnt_end_with":   ruleDoesntEndWith,
+	"contains":          ruleContains,
+	"doesnt_contain":    ruleDoesntContain,
+	"confirmed":         ruleConfirmed,
+
+	// Comparison
+	"same":          ruleSame,
+	"different":     ruleDifferent,
+	"in":            ruleIn,
+	"not_in":        ruleNotIn,
+	"in_array":      ruleInArray,
+	"in_array_keys": ruleInArrayKeys,
+
+	// Date
+	"date":            ruleDate,
+	"date_format":     ruleDateFormat,
+	"date_equals":     ruleDateEquals,
+	"before":          ruleBefore,
+	"before_or_equal": ruleBeforeOrEqual,
+	"after":           ruleAfter,
+	"after_or_equal":  ruleAfterOrEqual,
+	"timezone":        ruleTimezone,
+
+	// Exclude (always return true; engine handles exclusion logic)
+	"exclude":         ruleExclude,
+	"exclude_if":      ruleExcludeIf,
+	"exclude_unless":  ruleExcludeUnless,
+	"exclude_with":    ruleExcludeWith,
+	"exclude_without": ruleExcludeWithout,
+
+	// File
+	"file":       ruleFile,
+	"image":      ruleImage,
+	"mimes":      ruleMimes,
+	"mimetypes":  ruleMimetypes,
+	"extensions": ruleExtensions,
+	"dimensions": ruleDimensions,
+	"encoding":   ruleEncoding,
+
+	// Control (always pass; handled by engine)
+	"bail":      ruleBail,
+	"nullable":  ruleNullable,
+	"sometimes": ruleSometimes,
+
+	// Other
+	"distinct":            ruleDistinct,
+	"required_array_keys": ruleRequiredArrayKeys,
+
+	// Database
+	"exists": ruleExists,
+	"unique": ruleUnique,
+}
 
 // implicitRules are rules that run even when the field is missing or empty.
-var implicitRules = map[string]bool{}
+var implicitRules = map[string]bool{
+	"required": true, "required_if": true, "required_unless": true,
+	"required_with": true, "required_with_all": true,
+	"required_without": true, "required_without_all": true,
+	"required_if_accepted": true, "required_if_declined": true,
+	"required_array_keys": true,
+	"filled":              true,
+	"present":             true, "present_if": true, "present_unless": true,
+	"present_with": true, "present_with_all": true,
+	"missing": true, "missing_if": true, "missing_unless": true,
+	"missing_with": true, "missing_with_all": true,
+	"accepted": true, "accepted_if": true,
+	"declined": true, "declined_if": true,
+	"prohibited": true, "prohibited_if": true, "prohibited_unless": true,
+	"prohibited_if_accepted": true, "prohibited_if_declined": true,
+	"prohibits": true,
+}
 
 // excludeRules are rules that may cause a field to be excluded from validated data.
-var excludeRules = map[string]bool{}
+var excludeRules = map[string]bool{
+	"exclude": true, "exclude_if": true, "exclude_unless": true,
+	"exclude_with": true, "exclude_without": true,
+}
 
 // numericRuleNames are rules that indicate a field should be treated as numeric for size rules.
-var numericRuleNames = map[string]bool{}
+var numericRuleNames = map[string]bool{
+	"numeric": true, "integer": true, "decimal": true,
+}
+
+// ---- Existence Rules ----
+
+func ruleRequired(ctx *RuleContext) bool {
+	if ctx.Value == nil {
+		return false
+	}
+	return isValuePresent(ctx.Value)
+}
+
+func ruleRequiredIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleRequiredUnless(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if !matchesOtherValue(otherValue, comparisonValues) {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleRequiredWith(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if val, ok := ctx.Data.Get(field); ok && isValuePresent(val) {
+			return ruleRequired(ctx)
+		}
+	}
+	return true
+}
+
+func ruleRequiredWithAll(ctx *RuleContext) bool {
+	allPresent := true
+	for _, field := range ctx.Parameters {
+		if val, ok := ctx.Data.Get(field); !ok || !isValuePresent(val) {
+			allPresent = false
+			break
+		}
+	}
+	if allPresent {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleRequiredWithout(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if val, ok := ctx.Data.Get(field); !ok || !isValuePresent(val) {
+			return ruleRequired(ctx)
+		}
+	}
+	return true
+}
+
+func ruleRequiredWithoutAll(ctx *RuleContext) bool {
+	nonePresent := true
+	for _, field := range ctx.Parameters {
+		if val, ok := ctx.Data.Get(field); ok && isValuePresent(val) {
+			nonePresent = false
+			break
+		}
+	}
+	if nonePresent {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleRequiredIfAccepted(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return true
+	}
+	otherValue, _ := ctx.Data.Get(ctx.Parameters[0])
+	if isAcceptedValue(otherValue) {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleRequiredIfDeclined(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return true
+	}
+	otherValue, _ := ctx.Data.Get(ctx.Parameters[0])
+	if isDeclinedValue(otherValue) {
+		return ruleRequired(ctx)
+	}
+	return true
+}
+
+func ruleFilled(ctx *RuleContext) bool {
+	if !ctx.Data.Has(ctx.Attribute) {
+		return true // Not present = ok for filled
+	}
+	return isValuePresent(ctx.Value)
+}
+
+func rulePresent(ctx *RuleContext) bool {
+	return ctx.Data.Has(ctx.Attribute)
+}
+
+func rulePresentIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return ctx.Data.Has(ctx.Attribute)
+	}
+	return true
+}
+
+func rulePresentUnless(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if !matchesOtherValue(otherValue, comparisonValues) {
+		return ctx.Data.Has(ctx.Attribute)
+	}
+	return true
+}
+
+func rulePresentWith(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if ctx.Data.Has(field) {
+			return ctx.Data.Has(ctx.Attribute)
+		}
+	}
+	return true
+}
+
+func rulePresentWithAll(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if !ctx.Data.Has(field) {
+			return true
+		}
+	}
+	return ctx.Data.Has(ctx.Attribute)
+}
+
+func ruleMissing(ctx *RuleContext) bool {
+	return !ctx.Data.Has(ctx.Attribute)
+}
+
+func ruleMissingIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return !ctx.Data.Has(ctx.Attribute)
+	}
+	return true
+}
+
+func ruleMissingUnless(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if !matchesOtherValue(otherValue, comparisonValues) {
+		return !ctx.Data.Has(ctx.Attribute)
+	}
+	return true
+}
+
+func ruleMissingWith(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if ctx.Data.Has(field) {
+			return !ctx.Data.Has(ctx.Attribute)
+		}
+	}
+	return true
+}
+
+func ruleMissingWithAll(ctx *RuleContext) bool {
+	for _, field := range ctx.Parameters {
+		if !ctx.Data.Has(field) {
+			return true
+		}
+	}
+	return !ctx.Data.Has(ctx.Attribute)
+}
+
+// ---- Accept/Decline Rules ----
+
+func ruleAccepted(ctx *RuleContext) bool {
+	return isValuePresent(ctx.Value) && isAcceptedValue(ctx.Value)
+}
+
+func ruleAcceptedIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return isValuePresent(ctx.Value) && isAcceptedValue(ctx.Value)
+	}
+	return true
+}
+
+func ruleDeclined(ctx *RuleContext) bool {
+	return isValuePresent(ctx.Value) && isDeclinedValue(ctx.Value)
+}
+
+func ruleDeclinedIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return isValuePresent(ctx.Value) && isDeclinedValue(ctx.Value)
+	}
+	return true
+}
+
+// ---- Prohibition Rules ----
+
+func ruleProhibited(ctx *RuleContext) bool {
+	return isValueEmpty(ctx.Value)
+}
+
+func ruleProhibitedIf(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if matchesOtherValue(otherValue, comparisonValues) {
+		return isValueEmpty(ctx.Value)
+	}
+	return true
+}
+
+func ruleProhibitedUnless(ctx *RuleContext) bool {
+	otherValue, comparisonValues, _ := parseDependentValues(ctx)
+	if !matchesOtherValue(otherValue, comparisonValues) {
+		return isValueEmpty(ctx.Value)
+	}
+	return true
+}
+
+func ruleProhibitedIfAccepted(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return true
+	}
+	otherValue, _ := ctx.Data.Get(ctx.Parameters[0])
+	if isAcceptedValue(otherValue) {
+		return isValueEmpty(ctx.Value)
+	}
+	return true
+}
+
+func ruleProhibitedIfDeclined(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return true
+	}
+	otherValue, _ := ctx.Data.Get(ctx.Parameters[0])
+	if isDeclinedValue(otherValue) {
+		return isValueEmpty(ctx.Value)
+	}
+	return true
+}
+
+func ruleProhibits(ctx *RuleContext) bool {
+	if isValueEmpty(ctx.Value) {
+		return true
+	}
+	for _, field := range ctx.Parameters {
+		if val, ok := ctx.Data.Get(field); ok && !isValueEmpty(val) {
+			return false
+		}
+	}
+	return true
+}
+
+// ---- Type Rules ----
+
+func ruleString(ctx *RuleContext) bool {
+	_, ok := ctx.Value.(string)
+	return ok
+}
+
+func ruleInteger(ctx *RuleContext) bool {
+	switch v := ctx.Value.(type) {
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
+		return true
+	case float32:
+		return v == float32(int64(v))
+	case float64:
+		if v > float64(math.MaxInt64) || v < float64(math.MinInt64) {
+			return false
+		}
+		return v == float64(int64(v))
+	case json.Number:
+		_, err := v.Int64()
+		return err == nil
+	case string:
+		_, err := strconv.ParseInt(strings.TrimSpace(v), 10, 64)
+		return err == nil
+	}
+	return false
+}
+
+func ruleNumeric(ctx *RuleContext) bool {
+	_, ok := toFloat64(ctx.Value)
+	return ok
+}
+
+func ruleBoolean(ctx *RuleContext) bool {
+	switch v := ctx.Value.(type) {
+	case bool:
+		return true
+	case int:
+		return v == 0 || v == 1
+	case int64:
+		return v == 0 || v == 1
+	case float64:
+		return v == 0 || v == 1
+	case string:
+		v = strings.TrimSpace(v)
+		return v == "true" || v == "false" || v == "0" || v == "1" || v == "on" || v == "off" || v == "yes" || v == "no"
+	}
+	return false
+}
+
+func ruleFloat(ctx *RuleContext) bool {
+	switch ctx.Value.(type) {
+	case float32, float64:
+		return true
+	case string:
+		_, err := strconv.ParseFloat(ctx.Value.(string), 64)
+		return err == nil
+	}
+	return false
+}
+
+func ruleArray(ctx *RuleContext) bool {
+	if ctx.Value == nil {
+		return false
+	}
+	rv := reflect.ValueOf(ctx.Value)
+	kind := rv.Kind()
+	return kind == reflect.Slice || kind == reflect.Array || kind == reflect.Map
+}
+
+func ruleList(ctx *RuleContext) bool {
+	// A list is an array with sequential integer keys (a Go slice)
+	if ctx.Value == nil {
+		return false
+	}
+	kind := reflect.ValueOf(ctx.Value).Kind()
+	return kind == reflect.Slice || kind == reflect.Array
+}
+
+func ruleSlice(ctx *RuleContext) bool {
+	// Alias for list — validates value is a Go slice
+	return ruleList(ctx)
+}
+
+func ruleMap(ctx *RuleContext) bool {
+	// Validates value is a Go map
+	if ctx.Value == nil {
+		return false
+	}
+	return reflect.ValueOf(ctx.Value).Kind() == reflect.Map
+}
+
+// ---- Size Rules ----
+
+func ruleSize(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	expected, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	return size == expected
+}
+
+func ruleMin(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	minV, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	return size >= minV
+}
+
+func ruleMax(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	maxV, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	return size <= maxV
+}
+
+func ruleBetween(ctx *RuleContext) bool {
+	if len(ctx.Parameters) < 2 {
+		return false
+	}
+	minV, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	maxV, err := strconv.ParseFloat(ctx.Parameters[1], 64)
+	if err != nil {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	return size >= minV && size <= maxV
+}
+
+func ruleGt(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	// Try as field reference
+	if otherVal, exists := ctx.Data.Get(ctx.Parameters[0]); exists {
+		otherType := getAttributeType(ctx.Parameters[0], otherVal, ctx.Rules)
+		otherSize, ok := getSize(otherVal, otherType)
+		if ok {
+			return size > otherSize
+		}
+	}
+	// Try as numeric value
+	threshold, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	return size > threshold
+}
+
+func ruleGte(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	if otherVal, exists := ctx.Data.Get(ctx.Parameters[0]); exists {
+		otherType := getAttributeType(ctx.Parameters[0], otherVal, ctx.Rules)
+		otherSize, ok := getSize(otherVal, otherType)
+		if ok {
+			return size >= otherSize
+		}
+	}
+	threshold, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	return size >= threshold
+}
+
+func ruleLt(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	if otherVal, exists := ctx.Data.Get(ctx.Parameters[0]); exists {
+		otherType := getAttributeType(ctx.Parameters[0], otherVal, ctx.Rules)
+		otherSize, ok := getSize(otherVal, otherType)
+		if ok {
+			return size < otherSize
+		}
+	}
+	threshold, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	return size < threshold
+}
+
+func ruleLte(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	attrType := getAttributeType(ctx.Attribute, ctx.Value, ctx.Rules)
+	size, ok := getSize(ctx.Value, attrType)
+	if !ok {
+		return false
+	}
+	if otherVal, exists := ctx.Data.Get(ctx.Parameters[0]); exists {
+		otherType := getAttributeType(ctx.Parameters[0], otherVal, ctx.Rules)
+		otherSize, ok := getSize(otherVal, otherType)
+		if ok {
+			return size <= otherSize
+		}
+	}
+	threshold, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil {
+		return false
+	}
+	return size <= threshold
+}
+
+// ---- Numeric Rules ----
+
+func ruleDigits(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	s = strings.TrimSpace(s)
+	expected, err := strconv.Atoi(ctx.Parameters[0])
+	if err != nil {
+		return false
+	}
+	// Must be all digits
+	for _, r := range s {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	return len(s) == expected
+}
+
+func ruleDigitsBetween(ctx *RuleContext) bool {
+	if len(ctx.Parameters) < 2 {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	s = strings.TrimSpace(s)
+	minV, err := strconv.Atoi(ctx.Parameters[0])
+	if err != nil {
+		return false
+	}
+	maxV, err := strconv.Atoi(ctx.Parameters[1])
+	if err != nil {
+		return false
+	}
+	for _, r := range s {
+		if r < '0' || r > '9' {
+			return false
+		}
+	}
+	l := len(s)
+	return l >= minV && l <= maxV
+}
+
+func ruleDecimal(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	s = strings.TrimSpace(s)
+
+	// Parse expected decimal places
+	minPlaces, err := strconv.Atoi(ctx.Parameters[0])
+	if err != nil {
+		return false
+	}
+	maxPlaces := minPlaces
+	if len(ctx.Parameters) > 1 {
+		maxPlaces, err = strconv.Atoi(ctx.Parameters[1])
+		if err != nil {
+			return false
+		}
+	}
+
+	// Must be numeric
+	if _, err := strconv.ParseFloat(s, 64); err != nil {
+		return false
+	}
+
+	parts := strings.Split(s, ".")
+	if len(parts) == 1 {
+		return minPlaces == 0
+	}
+	decimalLen := len(parts[1])
+	return decimalLen >= minPlaces && decimalLen <= maxPlaces
+}
+
+func ruleMultipleOf(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	val, ok := toFloat64(ctx.Value)
+	if !ok {
+		return false
+	}
+	divisor, err := strconv.ParseFloat(ctx.Parameters[0], 64)
+	if err != nil || divisor == 0 {
+		return false
+	}
+	remainder := math.Mod(val, divisor)
+	epsilon := 1e-9
+	return math.Abs(remainder) < epsilon || math.Abs(remainder-divisor) < epsilon
+}
+
+func ruleMinDigits(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	s = strings.TrimSpace(s)
+	// Remove non-digit characters for counting
+	digitCount := 0
+	for _, r := range s {
+		if r >= '0' && r <= '9' {
+			digitCount++
+		}
+	}
+	minV, err := strconv.Atoi(ctx.Parameters[0])
+	if err != nil {
+		return false
+	}
+	// Must be numeric
+	if _, err = strconv.ParseFloat(s, 64); err != nil {
+		return false
+	}
+	return digitCount >= minV
+}
+
+func ruleMaxDigits(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	s = strings.TrimSpace(s)
+	digitCount := 0
+	for _, r := range s {
+		if r >= '0' && r <= '9' {
+			digitCount++
+		}
+	}
+	maxV, err := strconv.Atoi(ctx.Parameters[0])
+	if err != nil {
+		return false
+	}
+	if _, err = strconv.ParseFloat(s, 64); err != nil {
+		return false
+	}
+	return digitCount <= maxV
+}
+
+// ---- String Format Rules ----
+
+func ruleAlpha(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	for _, r := range s {
+		if !unicode.IsLetter(r) {
+			return false
+		}
+	}
+	return len(s) > 0
+}
+
+func ruleAlphaNum(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	for _, r := range s {
+		if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
+			return false
+		}
+	}
+	return len(s) > 0
+}
+
+func ruleAlphaDash(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	for _, r := range s {
+		if !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != '-' && r != '_' {
+			return false
+		}
+	}
+	return len(s) > 0
+}
+
+func ruleAscii(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	for _, r := range s {
+		if r > unicode.MaxASCII {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleEmail(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	addr, err := mail.ParseAddress(s)
+	if err != nil {
+		return false
+	}
+	// mail.ParseAddress accepts "Name <email>" format, but validation
+	// should only accept bare email addresses.
+	return addr.Address == s
+}
+
+func ruleUrl(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	u, err := url.Parse(s)
+	if err != nil {
+		return false
+	}
+	return u.Scheme != "" && u.Host != ""
+}
+
+func ruleActiveUrl(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	u, err := url.Parse(s)
+	if err != nil || u.Host == "" {
+		return false
+	}
+	resolver := net.Resolver{}
+	_, err = resolver.LookupHost(ctx.Ctx, u.Hostname())
+	return err == nil
+}
+
+func ruleIp(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return net.ParseIP(s) != nil
+}
+
+func ruleIpv4(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	ip := net.ParseIP(s)
+	return ip != nil && ip.To4() != nil
+}
+
+func ruleIpv6(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	ip := net.ParseIP(s)
+	return ip != nil && ip.To4() == nil
+}
+
+var macRegex = regexp.MustCompile(`^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$`)
+
+func ruleMacAddress(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return macRegex.MatchString(s)
+}
+
+func ruleJson(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	var js json.RawMessage
+	return json.Unmarshal([]byte(s), &js) == nil
+}
+
+var uuidRegex = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
+
+func ruleUuid(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return uuidRegex.MatchString(s)
+}
+
+var ulidRegex = regexp.MustCompile(`^[0-9A-HJ-KM-NP-TV-Za-hj-km-np-tv-z]{26}$`)
+
+func ruleUlid(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return ulidRegex.MatchString(s)
+}
+
+var hexColorRegex = regexp.MustCompile(`^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$`)
+
+func ruleHexColor(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return hexColorRegex.MatchString(s)
+}
+
+func ruleRegex(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	if len(ctx.Parameters) == 0 || ctx.Parameters[0] == "" {
+		return false
+	}
+	pattern := ctx.Parameters[0]
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return false
+	}
+	return re.MatchString(s)
+}
+
+func ruleNotRegex(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	pattern := ctx.Parameters[0]
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return false
+	}
+	return !re.MatchString(s)
+}
+
+func ruleLowercase(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return s == strings.ToLower(s)
+}
+
+func ruleUppercase(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return s == strings.ToUpper(s)
+}
+
+// ---- String Content Rules ----
+
+func ruleStartsWith(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, prefix := range ctx.Parameters {
+		if strings.HasPrefix(s, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+func ruleDoesntStartWith(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, prefix := range ctx.Parameters {
+		if strings.HasPrefix(s, prefix) {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleEndsWith(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, suffix := range ctx.Parameters {
+		if strings.HasSuffix(s, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func ruleDoesntEndWith(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, suffix := range ctx.Parameters {
+		if strings.HasSuffix(s, suffix) {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleContains(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, substr := range ctx.Parameters {
+		if !strings.Contains(s, substr) {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleDoesntContain(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, substr := range ctx.Parameters {
+		if strings.Contains(s, substr) {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleConfirmed(ctx *RuleContext) bool {
+	confirmField := ctx.Attribute + "_confirmation"
+	confirmVal, ok := ctx.Data.Get(confirmField)
+	if !ok {
+		return false
+	}
+	return fmt.Sprintf("%v", ctx.Value) == fmt.Sprintf("%v", confirmVal)
+}
+
+// ---- Comparison Rules ----
+
+func ruleSame(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	otherVal, ok := ctx.Data.Get(ctx.Parameters[0])
+	if !ok {
+		return false
+	}
+	return fmt.Sprintf("%v", ctx.Value) == fmt.Sprintf("%v", otherVal)
+}
+
+func ruleDifferent(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	otherVal, ok := ctx.Data.Get(ctx.Parameters[0])
+	if !ok {
+		return true
+	}
+	return fmt.Sprintf("%v", ctx.Value) != fmt.Sprintf("%v", otherVal)
+}
+
+func ruleIn(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, allowed := range ctx.Parameters {
+		if s == allowed {
+			return true
+		}
+	}
+	return false
+}
+
+func ruleNotIn(ctx *RuleContext) bool {
+	s := fmt.Sprintf("%v", ctx.Value)
+	for _, disallowed := range ctx.Parameters {
+		if s == disallowed {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleInArray(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	otherField := ctx.Parameters[0]
+	otherVal, ok := ctx.Data.Get(otherField)
+	if !ok {
+		return false
+	}
+	s := fmt.Sprintf("%v", ctx.Value)
+	switch arr := otherVal.(type) {
+	case []any:
+		for _, item := range arr {
+			if fmt.Sprintf("%v", item) == s {
+				return true
+			}
+		}
+	case []string:
+		for _, item := range arr {
+			if item == s {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// ---- Date Rules ----
+
+func ruleDate(ctx *RuleContext) bool {
+	_, ok := parseDate(ctx.Value)
+	return ok
+}
+
+func ruleDateFormat(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	// Parameters[0] is a Go time layout (e.g., "2006-01-02 15:04:05")
+	_, err := time.Parse(ctx.Parameters[0], s)
+	return err == nil
+}
+
+func ruleDateEquals(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	valDate, ok := parseDate(ctx.Value)
+	if !ok {
+		return false
+	}
+	otherDate, ok := parseDateValue(ctx.Parameters[0], ctx.Data)
+	if !ok {
+		return false
+	}
+	return valDate.Equal(otherDate)
+}
+
+func ruleBefore(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	valDate, ok := parseDate(ctx.Value)
+	if !ok {
+		return false
+	}
+	otherDate, ok := parseDateValue(ctx.Parameters[0], ctx.Data)
+	if !ok {
+		return false
+	}
+	return valDate.Before(otherDate)
+}
+
+func ruleBeforeOrEqual(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	valDate, ok := parseDate(ctx.Value)
+	if !ok {
+		return false
+	}
+	otherDate, ok := parseDateValue(ctx.Parameters[0], ctx.Data)
+	if !ok {
+		return false
+	}
+	return valDate.Before(otherDate) || valDate.Equal(otherDate)
+}
+
+func ruleAfter(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	valDate, ok := parseDate(ctx.Value)
+	if !ok {
+		return false
+	}
+	otherDate, ok := parseDateValue(ctx.Parameters[0], ctx.Data)
+	if !ok {
+		return false
+	}
+	return valDate.After(otherDate)
+}
+
+func ruleAfterOrEqual(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	valDate, ok := parseDate(ctx.Value)
+	if !ok {
+		return false
+	}
+	otherDate, ok := parseDateValue(ctx.Parameters[0], ctx.Data)
+	if !ok {
+		return false
+	}
+	return valDate.After(otherDate) || valDate.Equal(otherDate)
+}
+
+// ---- Exclude Rules ----
+// These always return true; the engine handles the actual exclusion logic.
+
+func ruleExclude(ctx *RuleContext) bool {
+	return true
+}
+
+func ruleExcludeIf(ctx *RuleContext) bool {
+	return true
+}
+
+func ruleExcludeUnless(ctx *RuleContext) bool {
+	return true
+}
+
+func ruleExcludeWith(ctx *RuleContext) bool {
+	return true
+}
+
+func ruleExcludeWithout(ctx *RuleContext) bool {
+	return true
+}
+
+// ---- File Rules ----
+
+func ruleFile(ctx *RuleContext) bool {
+	if _, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return true
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		return len(fhs) > 0
+	}
+	return false
+}
+
+func ruleImage(ctx *RuleContext) bool {
+	check := func(fh *multipart.FileHeader) bool {
+		mtype, err := detectMIME(fh)
+		if err != nil {
+			return false
+		}
+		imageTypes := []string{"image/jpeg", "image/png", "image/gif", "image/bmp", "image/svg+xml", "image/webp"}
+		for _, t := range imageTypes {
+			if mtype.Is(t) {
+				return true
+			}
+		}
+		return false
+	}
+
+	if fh, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return check(fh)
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		for _, fh := range fhs {
+			if !check(fh) {
+				return false
+			}
+		}
+		return len(fhs) > 0
+	}
+	return false
+}
+
+func ruleMimes(ctx *RuleContext) bool {
+	check := func(fh *multipart.FileHeader) bool {
+		mtype, err := detectMIME(fh)
+		if err != nil {
+			return false
+		}
+		ext := strings.TrimPrefix(mtype.Extension(), ".")
+		for _, allowed := range ctx.Parameters {
+			if strings.EqualFold(ext, allowed) {
+				return true
+			}
+		}
+		return false
+	}
+
+	if fh, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return check(fh)
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		for _, fh := range fhs {
+			if !check(fh) {
+				return false
+			}
+		}
+		return len(fhs) > 0
+	}
+	return false
+}
+
+func ruleMimetypes(ctx *RuleContext) bool {
+	check := func(fh *multipart.FileHeader) bool {
+		mtype, err := detectMIME(fh)
+		if err != nil {
+			return false
+		}
+		for _, allowed := range ctx.Parameters {
+			if mtype.Is(allowed) {
+				return true
+			}
+		}
+		return false
+	}
+
+	if fh, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return check(fh)
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		for _, fh := range fhs {
+			if !check(fh) {
+				return false
+			}
+		}
+		return len(fhs) > 0
+	}
+	return false
+}
+
+func ruleExtensions(ctx *RuleContext) bool {
+	check := func(fh *multipart.FileHeader) bool {
+		ext := strings.ToLower(getFileExtension(fh.Filename))
+		for _, allowed := range ctx.Parameters {
+			if ext == strings.ToLower(allowed) {
+				return true
+			}
+		}
+		return false
+	}
+
+	if fh, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return check(fh)
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		for _, fh := range fhs {
+			if !check(fh) {
+				return false
+			}
+		}
+		return len(fhs) > 0
+	}
+	return false
+}
+
+func ruleDimensions(ctx *RuleContext) bool {
+	// Parse named parameters: "min_width=100,max_width=500,width=200,height=200,ratio=3/2"
+	constraints := make(map[string]string, len(ctx.Parameters))
+	for _, p := range ctx.Parameters {
+		if k, v, found := strings.Cut(p, "="); found {
+			constraints[k] = v
+		}
+	}
+
+	check := func(fh *multipart.FileHeader) bool {
+		f, err := fh.Open()
+		if err != nil {
+			return false
+		}
+		defer func(f multipart.File) { _ = f.Close() }(f)
+
+		cfg, _, err := image.DecodeConfig(f)
+		if err != nil {
+			return false
+		}
+
+		width, height := cfg.Width, cfg.Height
+
+		if v, ok := constraints["width"]; ok {
+			if w, err := strconv.Atoi(v); err == nil && width != w {
+				return false
+			}
+		}
+		if v, ok := constraints["height"]; ok {
+			if h, err := strconv.Atoi(v); err == nil && height != h {
+				return false
+			}
+		}
+		if v, ok := constraints["min_width"]; ok {
+			if mw, err := strconv.Atoi(v); err == nil && width < mw {
+				return false
+			}
+		}
+		if v, ok := constraints["max_width"]; ok {
+			if mw, err := strconv.Atoi(v); err == nil && width > mw {
+				return false
+			}
+		}
+		if v, ok := constraints["min_height"]; ok {
+			if mh, err := strconv.Atoi(v); err == nil && height < mh {
+				return false
+			}
+		}
+		if v, ok := constraints["max_height"]; ok {
+			if mh, err := strconv.Atoi(v); err == nil && height > mh {
+				return false
+			}
+		}
+
+		if v, ok := constraints["ratio"]; ok {
+			var targetRatio float64
+			if num, den, found := strings.Cut(v, "/"); found {
+				n, err1 := strconv.ParseFloat(num, 64)
+				d, err2 := strconv.ParseFloat(den, 64)
+				if err1 != nil || err2 != nil || d == 0 {
+					return false
+				}
+				targetRatio = n / d
+			} else {
+				r, err := strconv.ParseFloat(v, 64)
+				if err != nil {
+					return false
+				}
+				targetRatio = r
+			}
+			actualRatio := float64(width) / float64(height)
+			if math.Abs(actualRatio-targetRatio) > 0.01 {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	if fh, ok := ctx.Value.(*multipart.FileHeader); ok {
+		return check(fh)
+	}
+	if fhs, ok := ctx.Value.([]*multipart.FileHeader); ok {
+		for _, fh := range fhs {
+			if !check(fh) {
+				return false
+			}
+		}
+		return len(fhs) > 0
+	}
+	return false
+}
+
+// ---- Control Rules ----
+
+func ruleBail(_ *RuleContext) bool {
+	return true
+}
+
+func ruleNullable(_ *RuleContext) bool {
+	return true
+}
+
+func ruleSometimes(_ *RuleContext) bool {
+	return true
+}
+
+// ---- Other Rules ----
+
+func ruleDistinct(ctx *RuleContext) bool {
+	// Distinct checks for duplicate values in array fields.
+	// The engine handles tracking unique values across wildcard-expanded fields.
+	return true
+}
+
+func ruleRequiredArrayKeys(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	if ctx.Value == nil {
+		return false
+	}
+	rv := reflect.ValueOf(ctx.Value)
+	if rv.Kind() != reflect.Map {
+		return false
+	}
+	keys := rv.MapKeys()
+	for _, param := range ctx.Parameters {
+		found := false
+		for _, k := range keys {
+			if fmt.Sprintf("%v", k.Interface()) == param {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return false
+		}
+	}
+	return true
+}
+
+func ruleInArrayKeys(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	if ctx.Value == nil {
+		return false
+	}
+	rv := reflect.ValueOf(ctx.Value)
+	if rv.Kind() != reflect.Map {
+		return false
+	}
+	keys := rv.MapKeys()
+	for _, param := range ctx.Parameters {
+		for _, k := range keys {
+			if fmt.Sprintf("%v", k.Interface()) == param {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func ruleTimezone(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	_, err := time.LoadLocation(s)
+	return err == nil
+}
+
+func ruleEncoding(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+
+	var data []byte
+	switch v := ctx.Value.(type) {
+	case string:
+		data = []byte(v)
+	case *multipart.FileHeader:
+		f, err := v.Open()
+		if err != nil {
+			return false
+		}
+		defer func(f multipart.File) { _ = f.Close() }(f)
+		data, err = io.ReadAll(f)
+		if err != nil {
+			return false
+		}
+	default:
+		return false
+	}
+
+	enc := strings.ToLower(ctx.Parameters[0])
+	switch enc {
+	case "utf-8", "utf8":
+		return utf8.Valid(data)
+	case "ascii", "us-ascii":
+		for _, b := range data {
+			if b > 127 {
+				return false
+			}
+		}
+		return true
+	default:
+		return false
+	}
+}
diff --git a/validation/rules_db.go b/validation/rules_db.go
new file mode 100644
index 000000000..d8043fccd
--- /dev/null
+++ b/validation/rules_db.go
@@ -0,0 +1,82 @@
+package validation
+
+// ruleExists validates that the given value exists in the specified database table.
+// Syntax: exists:table,column1,column2,...
+//   - table: required, supports "connection.table" format
+//   - columns: optional, defaults to the current field name. Multiple columns are joined with OR.
+func ruleExists(ctx *RuleContext) bool {
+	if ormFacade == nil {
+		return false
+	}
+
+	table, columns, connection := parseExistsParams(ctx)
+	if table == "" {
+		return false
+	}
+
+	query := getOrmQuery(ctx, connection).Table(table)
+
+	if len(columns) == 1 {
+		query = query.Where(columns[0], ctx.Value)
+	} else {
+		// Multiple columns: WHERE col1 = value OR col2 = value OR ...
+		for i, col := range columns {
+			if i == 0 {
+				query = query.Where(col, ctx.Value)
+			} else {
+				query = query.OrWhere(col, ctx.Value)
+			}
+		}
+	}
+
+	exists, err := query.Exists()
+	if err != nil {
+		return false
+	}
+	return exists
+}
+
+// ruleUnique validates that the given value is unique in the specified database table.
+// Syntax: unique:table,column,idColumn,except1,except2,...
+//   - table: required, supports "connection.table" format
+//   - column: optional, defaults to the current field name
+//   - idColumn: optional, defaults to "id", the column to use for the except clause
+//   - except values: optional, values to exclude from the unique check (for update scenarios)
+func ruleUnique(ctx *RuleContext) bool {
+	if ormFacade == nil {
+		return false
+	}
+
+	table, column, connection := parseUniqueParams(ctx)
+	if table == "" {
+		return false
+	}
+
+	query := getOrmQuery(ctx, connection).Table(table).Where(column, ctx.Value)
+
+	// Handle except (ignore specific records for updates)
+	// Parameters: table, column, idColumn, except1, except2, ...
+	if len(ctx.Parameters) >= 4 {
+		idColumn := "id"
+		if len(ctx.Parameters) >= 3 && ctx.Parameters[2] != "" {
+			idColumn = ctx.Parameters[2]
+		}
+
+		var exceptValues []any
+		for i := 3; i < len(ctx.Parameters); i++ {
+			if ctx.Parameters[i] != "" {
+				exceptValues = append(exceptValues, ctx.Parameters[i])
+			}
+		}
+
+		if len(exceptValues) > 0 {
+			query = query.WhereNotIn(idColumn, exceptValues)
+		}
+	}
+
+	count, err := query.Count()
+	if err != nil {
+		return false
+	}
+	return count == 0
+}
diff --git a/validation/rules_db_test.go b/validation/rules_db_test.go
new file mode 100644
index 000000000..d3cde75a2
--- /dev/null
+++ b/validation/rules_db_test.go
@@ -0,0 +1,438 @@
+package validation
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	mocksorm "github.com/goravel/framework/mocks/database/orm"
+)
+
+type DBRulesTestSuite struct {
+	suite.Suite
+	mockOrm   *mocksorm.Orm
+	mockQuery *mocksorm.Query
+}
+
+func TestDBRulesTestSuite(t *testing.T) {
+	suite.Run(t, new(DBRulesTestSuite))
+}
+
+func (s *DBRulesTestSuite) SetupTest() {
+	s.mockOrm = mocksorm.NewOrm(s.T())
+	s.mockQuery = mocksorm.NewQuery(s.T())
+	ormFacade = s.mockOrm
+}
+
+func (s *DBRulesTestSuite) TearDownTest() {
+	ormFacade = nil
+}
+
+// --- exists rule tests ---
+
+func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_Found() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_NotFound() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "notfound@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "notfound@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_DefaultColumn() {
+	// When no column specified, defaults to field name
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_OR() {
+	// exists:users,email,username — WHERE email = value OR username = value
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("username", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "username"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_ThreeFields() {
+	// exists:users,email,username,phone
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("username", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("phone", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "value",
+		Parameters: []string{"users", "email", "username", "phone"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_ConnectionTable() {
+	// exists:mysql.users,email — specify connection
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Connection("mysql").Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"mysql.users", "email"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_OrmNil() {
+	ormFacade = nil
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_NoParameters() {
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{},
+	}
+	// No table specified, should return false
+	s.False(ruleExists(ctx))
+}
+
+// --- unique rule tests ---
+
+func (s *DBRulesTestSuite) TestRuleUnique_IsUnique() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_NotUnique() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "taken@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(1), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "taken@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_DefaultColumn() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithExcept() {
+	// unique:users,email,id,5 — exclude record where id=5
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "id", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithCustomIdColumnAndExcept() {
+	// unique:users,email,user_id,5 — exclude record where user_id=5
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("user_id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "user_id", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithMultipleExcepts() {
+	// unique:users,email,id,1,2,3 — exclude records where id IN (1, 2, 3)
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"1", "2", "3"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "id", "1", "2", "3"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithDefaultIdColumn() {
+	// unique:users,email,,5 — idColumn defaults to "id"
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_ConnectionTable() {
+	// unique:pgsql.users,email
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Connection("pgsql").Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"pgsql.users", "email"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_OrmNil() {
+	ormFacade = nil
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleUnique(ctx))
+}
+
+// --- parseExistsParams tests ---
+
+func (s *DBRulesTestSuite) TestParseExistsParams() {
+	tests := []struct {
+		name          string
+		attribute     string
+		parameters    []string
+		expectedTable string
+		expectedCols  []string
+		expectedConn  string
+	}{
+		{
+			name:          "no parameters",
+			attribute:     "email",
+			parameters:    []string{},
+			expectedTable: "",
+			expectedCols:  []string{"email"},
+			expectedConn:  "",
+		},
+		{
+			name:          "table only",
+			attribute:     "email",
+			parameters:    []string{"users"},
+			expectedTable: "users",
+			expectedCols:  []string{"email"},
+			expectedConn:  "",
+		},
+		{
+			name:          "table and column",
+			attribute:     "email",
+			parameters:    []string{"users", "user_email"},
+			expectedTable: "users",
+			expectedCols:  []string{"user_email"},
+			expectedConn:  "",
+		},
+		{
+			name:          "table and multiple columns",
+			attribute:     "email",
+			parameters:    []string{"users", "email", "username", "phone"},
+			expectedTable: "users",
+			expectedCols:  []string{"email", "username", "phone"},
+			expectedConn:  "",
+		},
+		{
+			name:          "connection.table",
+			attribute:     "email",
+			parameters:    []string{"mysql.users", "email"},
+			expectedTable: "users",
+			expectedCols:  []string{"email"},
+			expectedConn:  "mysql",
+		},
+	}
+
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			ctx := &RuleContext{
+				Attribute:  tt.attribute,
+				Parameters: tt.parameters,
+			}
+			table, cols, conn := parseExistsParams(ctx)
+			s.Equal(tt.expectedTable, table)
+			s.Equal(tt.expectedCols, cols)
+			s.Equal(tt.expectedConn, conn)
+		})
+	}
+}
+
+// --- parseUniqueParams tests ---
+
+func (s *DBRulesTestSuite) TestParseUniqueParams() {
+	tests := []struct {
+		name          string
+		attribute     string
+		parameters    []string
+		expectedTable string
+		expectedCol   string
+		expectedConn  string
+	}{
+		{
+			name:          "no parameters",
+			attribute:     "email",
+			parameters:    []string{},
+			expectedTable: "",
+			expectedCol:   "email",
+			expectedConn:  "",
+		},
+		{
+			name:          "table only",
+			attribute:     "email",
+			parameters:    []string{"users"},
+			expectedTable: "users",
+			expectedCol:   "email",
+			expectedConn:  "",
+		},
+		{
+			name:          "table and column",
+			attribute:     "email",
+			parameters:    []string{"users", "user_email"},
+			expectedTable: "users",
+			expectedCol:   "user_email",
+			expectedConn:  "",
+		},
+		{
+			name:          "connection.table",
+			attribute:     "email",
+			parameters:    []string{"pgsql.users", "email"},
+			expectedTable: "users",
+			expectedCol:   "email",
+			expectedConn:  "pgsql",
+		},
+	}
+
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			ctx := &RuleContext{
+				Attribute:  tt.attribute,
+				Parameters: tt.parameters,
+			}
+			table, col, conn := parseUniqueParams(ctx)
+			s.Equal(tt.expectedTable, table)
+			s.Equal(tt.expectedCol, col)
+			s.Equal(tt.expectedConn, conn)
+		})
+	}
+}
diff --git a/validation/rules_test.go b/validation/rules_test.go
new file mode 100644
index 000000000..0efe03062
--- /dev/null
+++ b/validation/rules_test.go
@@ -0,0 +1,3589 @@
+package validation
+
+import (
+	"bytes"
+	"context"
+	"mime/multipart"
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+
+	contractsvalidation "github.com/goravel/framework/contracts/validation"
+)
+
+type RulesTestSuite struct {
+	suite.Suite
+	validation *Validation
+}
+
+func (s *RulesTestSuite) SetupTest() {
+	s.validation = NewValidation()
+}
+
+func (s *RulesTestSuite) makeValidator(data map[string]any, rules map[string]any, options ...contractsvalidation.Option) contractsvalidation.Validator {
+	validator, err := s.validation.Make(context.Background(), data, rules, options...)
+	s.Require().NoError(err)
+	return validator
+}
+
+func TestRulesTestSuite(t *testing.T) {
+	suite.Run(t, new(RulesTestSuite))
+}
+
+// ===== 1. Existence Rules =====
+
+func (s *RulesTestSuite) TestRequired() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_with_value", map[string]any{"name": "goravel"}, map[string]any{"name": "required"}, false},
+		{"pass_with_int", map[string]any{"age": 18}, map[string]any{"age": "required"}, false},
+		{"pass_with_int_zero", map[string]any{"age": 0}, map[string]any{"age": "required"}, false},
+		{"pass_with_bool_true", map[string]any{"ok": true}, map[string]any{"ok": "required"}, false},
+		{"pass_with_bool_false", map[string]any{"ok": false}, map[string]any{"ok": "required"}, false},
+		{"pass_with_float", map[string]any{"score": 3.14}, map[string]any{"score": "required"}, false},
+		{"pass_with_slice", map[string]any{"items": []any{1, 2}}, map[string]any{"items": "required"}, false},
+		{"pass_with_map", map[string]any{"meta": map[string]any{"k": "v"}}, map[string]any{"meta": "required"}, false},
+		{"pass_zero_float", map[string]any{"val": 0.0}, map[string]any{"val": "required"}, false},
+		{"fail_empty_string", map[string]any{"name": ""}, map[string]any{"name": "required"}, true},
+		{"fail_whitespace_only", map[string]any{"name": "   "}, map[string]any{"name": "required"}, true},
+		{"fail_nil", map[string]any{"name": nil}, map[string]any{"name": "required"}, true},
+		{"fail_missing_key", map[string]any{"other": "x"}, map[string]any{"name": "required"}, true},
+		{"pass_multiple_required", map[string]any{"a": "1", "b": "2"}, map[string]any{"a": "required", "b": "required"}, false},
+		{"fail_one_of_multiple_missing", map[string]any{"a": "1"}, map[string]any{"a": "required", "b": "required"}, true},
+		{"fail_empty_slice", map[string]any{"items": []any{}}, map[string]any{"items": "required"}, true},
+		{"fail_empty_map", map[string]any{"data": map[string]any{}}, map[string]any{"data": "required"}, true},
+		{"fail_nested_empty_string", map[string]any{"user": map[string]any{"name": ""}}, map[string]any{"user.name": "required"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_when_condition_met_and_present", map[string]any{"type": "admin", "role": "manager"}, map[string]any{"role": "required_if:type,admin"}, false},
+		{"pass_when_condition_not_met", map[string]any{"type": "user"}, map[string]any{"role": "required_if:type,admin"}, false},
+		{"fail_when_condition_met_and_missing", map[string]any{"type": "admin"}, map[string]any{"role": "required_if:type,admin"}, true},
+		{"fail_when_condition_met_and_empty", map[string]any{"type": "admin", "role": ""}, map[string]any{"role": "required_if:type,admin"}, true},
+		{"pass_multiple_values_no_match", map[string]any{"type": "guest"}, map[string]any{"role": "required_if:type,admin,manager"}, false},
+		{"fail_multiple_values_match_second", map[string]any{"type": "manager", "role": ""}, map[string]any{"role": "required_if:type,admin,manager"}, true},
+		{"pass_bool_condition_true", map[string]any{"active": true, "name": "go"}, map[string]any{"name": "required_if:active,true"}, false},
+		{"fail_bool_condition_true_missing", map[string]any{"active": true}, map[string]any{"name": "required_if:active,true"}, true},
+		{"pass_bool_condition_false_no_trigger", map[string]any{"active": false}, map[string]any{"name": "required_if:active,true"}, false},
+		{"pass_other_field_missing", map[string]any{}, map[string]any{"role": "required_if:type,admin"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredUnless() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_when_other_matches", map[string]any{"role": "admin"}, map[string]any{"name": "required_unless:role,admin"}, false},
+		{"pass_when_other_no_match_and_present", map[string]any{"role": "user", "name": "John"}, map[string]any{"name": "required_unless:role,admin"}, false},
+		{"fail_when_other_no_match_and_missing", map[string]any{"role": "user"}, map[string]any{"name": "required_unless:role,admin"}, true},
+		{"fail_when_other_no_match_and_empty", map[string]any{"role": "user", "name": ""}, map[string]any{"name": "required_unless:role,admin"}, true},
+		{"pass_multiple_unless_match", map[string]any{"role": "mod"}, map[string]any{"name": "required_unless:role,admin,mod"}, false},
+		{"fail_multiple_unless_no_match", map[string]any{"role": "user"}, map[string]any{"name": "required_unless:role,admin,mod"}, true},
+		{"pass_other_field_missing_and_filled", map[string]any{"name": "go"}, map[string]any{"name": "required_unless:role,admin"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_when_other_present_and_filled", map[string]any{"first": "A", "last": "B"}, map[string]any{"last": "required_with:first"}, false},
+		{"pass_when_other_absent", map[string]any{"other": "x"}, map[string]any{"last": "required_with:first"}, false},
+		{"fail_when_other_present_and_empty", map[string]any{"first": "A", "last": ""}, map[string]any{"last": "required_with:first"}, true},
+		{"fail_when_other_present_and_missing", map[string]any{"first": "A"}, map[string]any{"last": "required_with:first"}, true},
+		{"pass_multiple_one_present", map[string]any{"a": "1", "c": "3"}, map[string]any{"c": "required_with:a,b"}, false},
+		{"fail_multiple_one_present_target_missing", map[string]any{"a": "1"}, map[string]any{"c": "required_with:a,b"}, true},
+		{"pass_other_present_but_empty_value", map[string]any{"first": "", "last": "B"}, map[string]any{"last": "required_with:first"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredWithAll() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_all_present_and_filled", map[string]any{"a": "1", "b": "2", "c": "3"}, map[string]any{"c": "required_with_all:a,b"}, false},
+		{"pass_not_all_present", map[string]any{"a": "1"}, map[string]any{"c": "required_with_all:a,b"}, false},
+		{"fail_all_present_and_empty", map[string]any{"a": "1", "b": "2", "c": ""}, map[string]any{"c": "required_with_all:a,b"}, true},
+		{"fail_all_present_and_missing", map[string]any{"a": "1", "b": "2"}, map[string]any{"c": "required_with_all:a,b"}, true},
+		{"pass_one_other_empty_str", map[string]any{"a": "1", "b": "", "c": "3"}, map[string]any{"c": "required_with_all:a,b"}, false},
+		{"pass_three_others_not_all", map[string]any{"a": "1", "b": "2"}, map[string]any{"d": "required_with_all:a,b,c"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredWithout() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_when_other_absent_and_filled", map[string]any{"email": "a@b.com"}, map[string]any{"email": "required_without:phone"}, false},
+		{"pass_when_other_present", map[string]any{"phone": "123"}, map[string]any{"email": "required_without:phone"}, false},
+		{"fail_when_other_absent_and_empty", map[string]any{"other": "x"}, map[string]any{"email": "required_without:phone"}, true},
+		{"fail_when_other_absent_and_missing", map[string]any{}, map[string]any{"email": "required_without:phone"}, true},
+		{"pass_multiple_one_absent", map[string]any{"a": "1", "c": "3"}, map[string]any{"c": "required_without:a,b"}, false},
+		{"pass_both_present", map[string]any{"a": "1", "b": "2", "c": "3"}, map[string]any{"c": "required_without:a,b"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredWithoutAll() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_none_present_and_filled", map[string]any{"c": "val"}, map[string]any{"c": "required_without_all:a,b"}, false},
+		{"pass_some_present", map[string]any{"a": "1"}, map[string]any{"c": "required_without_all:a,b"}, false},
+		{"pass_all_present", map[string]any{"a": "1", "b": "2"}, map[string]any{"c": "required_without_all:a,b"}, false},
+		{"fail_none_present_and_empty", map[string]any{"other": "x"}, map[string]any{"c": "required_without_all:a,b"}, true},
+		{"fail_none_present_and_missing", map[string]any{}, map[string]any{"c": "required_without_all:a,b"}, true},
+		{"pass_one_of_three_present", map[string]any{"b": "2"}, map[string]any{"d": "required_without_all:a,b,c"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredIfAccepted() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_accepted_and_filled", map[string]any{"terms": true, "sig": "yes"}, map[string]any{"sig": "required_if_accepted:terms"}, false},
+		{"pass_not_accepted_bool", map[string]any{"terms": false}, map[string]any{"sig": "required_if_accepted:terms"}, false},
+		{"pass_not_accepted_string", map[string]any{"terms": "no"}, map[string]any{"sig": "required_if_accepted:terms"}, false},
+		{"fail_accepted_bool_and_missing", map[string]any{"terms": true}, map[string]any{"sig": "required_if_accepted:terms"}, true},
+		{"fail_accepted_string_yes", map[string]any{"terms": "yes"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
+		{"fail_accepted_string_on", map[string]any{"terms": "on"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
+		{"fail_accepted_string_1", map[string]any{"terms": "1"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
+		{"fail_accepted_int_1", map[string]any{"terms": 1}, map[string]any{"sig": "required_if_accepted:terms"}, true},
+		{"pass_other_field_missing", map[string]any{}, map[string]any{"sig": "required_if_accepted:terms"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRequiredIfDeclined() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_declined_and_filled", map[string]any{"auto": false, "reason": "manual"}, map[string]any{"reason": "required_if_declined:auto"}, false},
+		{"pass_not_declined_bool", map[string]any{"auto": true}, map[string]any{"reason": "required_if_declined:auto"}, false},
+		{"pass_not_declined_string", map[string]any{"auto": "yes"}, map[string]any{"reason": "required_if_declined:auto"}, false},
+		{"fail_declined_bool_and_missing", map[string]any{"auto": false}, map[string]any{"reason": "required_if_declined:auto"}, true},
+		{"fail_declined_string_no", map[string]any{"auto": "no"}, map[string]any{"reason": "required_if_declined:auto"}, true},
+		{"fail_declined_string_off", map[string]any{"auto": "off"}, map[string]any{"reason": "required_if_declined:auto"}, true},
+		{"fail_declined_string_0", map[string]any{"auto": "0"}, map[string]any{"reason": "required_if_declined:auto"}, true},
+		{"fail_declined_int_0", map[string]any{"auto": 0}, map[string]any{"reason": "required_if_declined:auto"}, true},
+		{"pass_other_field_missing", map[string]any{}, map[string]any{"reason": "required_if_declined:auto"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestFilled() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_present_with_value", map[string]any{"name": "go"}, map[string]any{"name": "filled"}, false},
+		{"pass_present_with_int", map[string]any{"age": 0}, map[string]any{"age": "filled"}, false},
+		{"pass_present_with_bool", map[string]any{"ok": false}, map[string]any{"ok": "filled"}, false},
+		{"pass_not_present", map[string]any{"other": "x"}, map[string]any{"name": "filled"}, false},
+		{"fail_present_empty", map[string]any{"name": ""}, map[string]any{"name": "filled"}, true},
+		{"fail_present_whitespace", map[string]any{"name": "  "}, map[string]any{"name": "filled"}, true},
+		{"fail_present_nil", map[string]any{"name": nil}, map[string]any{"name": "filled"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestPresent() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_present_with_value", map[string]any{"name": "go"}, map[string]any{"name": "present"}, false},
+		{"pass_present_empty", map[string]any{"name": ""}, map[string]any{"name": "present"}, false},
+		{"pass_present_nil", map[string]any{"name": nil}, map[string]any{"name": "present"}, false},
+		{"fail_missing", map[string]any{"other": "x"}, map[string]any{"name": "present"}, true},
+		{"fail_empty_data", map[string]any{}, map[string]any{"name": "present"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestPresentIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met_and_present", map[string]any{"type": "a", "name": ""}, map[string]any{"name": "present_if:type,a"}, false},
+		{"pass_condition_not_met", map[string]any{"type": "b"}, map[string]any{"name": "present_if:type,a"}, false},
+		{"fail_condition_met_and_missing", map[string]any{"type": "a"}, map[string]any{"name": "present_if:type,a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestPresentUnless() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met", map[string]any{"role": "admin"}, map[string]any{"name": "present_unless:role,admin"}, false},
+		{"pass_condition_not_met_and_present", map[string]any{"role": "user", "name": ""}, map[string]any{"name": "present_unless:role,admin"}, false},
+		{"fail_condition_not_met_and_missing", map[string]any{"role": "user"}, map[string]any{"name": "present_unless:role,admin"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestPresentWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_other_present_and_self_present", map[string]any{"a": "1", "b": ""}, map[string]any{"b": "present_with:a"}, false},
+		{"pass_other_absent", map[string]any{"c": "1"}, map[string]any{"b": "present_with:a"}, false},
+		{"fail_other_present_and_self_missing", map[string]any{"a": "1"}, map[string]any{"b": "present_with:a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestPresentWithAll() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_all_present_and_self_present", map[string]any{"a": "1", "b": "2", "c": ""}, map[string]any{"c": "present_with_all:a,b"}, false},
+		{"pass_not_all_present", map[string]any{"a": "1"}, map[string]any{"c": "present_with_all:a,b"}, false},
+		{"fail_all_present_and_self_missing", map[string]any{"a": "1", "b": "2"}, map[string]any{"c": "present_with_all:a,b"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMissing() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_when_missing", map[string]any{"other": "x"}, map[string]any{"name": "missing"}, false},
+		{"pass_empty_data", map[string]any{}, map[string]any{"name": "missing"}, false},
+		{"fail_when_present", map[string]any{"name": "go"}, map[string]any{"name": "missing"}, true},
+		{"fail_when_present_empty", map[string]any{"name": ""}, map[string]any{"name": "missing"}, true},
+		{"fail_when_present_nil", map[string]any{"name": nil}, map[string]any{"name": "missing"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMissingIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met_and_missing", map[string]any{"type": "a"}, map[string]any{"name": "missing_if:type,a"}, false},
+		{"pass_condition_not_met", map[string]any{"type": "b", "name": "go"}, map[string]any{"name": "missing_if:type,a"}, false},
+		{"fail_condition_met_and_present", map[string]any{"type": "a", "name": "go"}, map[string]any{"name": "missing_if:type,a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMissingUnless() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met", map[string]any{"role": "admin", "name": "go"}, map[string]any{"name": "missing_unless:role,admin"}, false},
+		{"pass_condition_not_met_and_missing", map[string]any{"role": "user"}, map[string]any{"name": "missing_unless:role,admin"}, false},
+		{"fail_condition_not_met_and_present", map[string]any{"role": "user", "name": "go"}, map[string]any{"name": "missing_unless:role,admin"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMissingWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_other_present_and_self_missing", map[string]any{"a": "1"}, map[string]any{"b": "missing_with:a"}, false},
+		{"pass_other_absent", map[string]any{"b": "1"}, map[string]any{"b": "missing_with:a"}, false},
+		{"fail_other_present_and_self_present", map[string]any{"a": "1", "b": "2"}, map[string]any{"b": "missing_with:a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMissingWithAll() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_all_present_and_self_missing", map[string]any{"a": "1", "b": "2"}, map[string]any{"c": "missing_with_all:a,b"}, false},
+		{"pass_not_all_present", map[string]any{"a": "1", "c": "3"}, map[string]any{"c": "missing_with_all:a,b"}, false},
+		{"fail_all_present_and_self_present", map[string]any{"a": "1", "b": "2", "c": "3"}, map[string]any{"c": "missing_with_all:a,b"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 2. Accept/Decline Rules =====
+
+func (s *RulesTestSuite) TestAccepted() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_bool_true", map[string]any{"terms": true}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_yes", map[string]any{"terms": "yes"}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_on", map[string]any{"terms": "on"}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_1", map[string]any{"terms": "1"}, map[string]any{"terms": "accepted"}, false},
+		{"pass_int_1", map[string]any{"terms": 1}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_true", map[string]any{"terms": "true"}, map[string]any{"terms": "accepted"}, false},
+		{"pass_float_1", map[string]any{"terms": float64(1)}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_YES_case", map[string]any{"terms": "YES"}, map[string]any{"terms": "accepted"}, false},
+		{"pass_string_True_case", map[string]any{"terms": "True"}, map[string]any{"terms": "accepted"}, false},
+		{"fail_bool_false", map[string]any{"terms": false}, map[string]any{"terms": "accepted"}, true},
+		{"fail_string_no", map[string]any{"terms": "no"}, map[string]any{"terms": "accepted"}, true},
+		{"fail_int_0", map[string]any{"terms": 0}, map[string]any{"terms": "accepted"}, true},
+		{"fail_nil", map[string]any{"terms": nil}, map[string]any{"terms": "accepted"}, true},
+		{"fail_string_random", map[string]any{"terms": "maybe"}, map[string]any{"terms": "accepted"}, true},
+		{"fail_int_2", map[string]any{"terms": 2}, map[string]any{"terms": "accepted"}, true},
+		{"fail_empty_string", map[string]any{"terms": ""}, map[string]any{"terms": "accepted"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAcceptedIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met_and_accepted", map[string]any{"type": "a", "terms": true}, map[string]any{"terms": "accepted_if:type,a"}, false},
+		{"pass_condition_not_met", map[string]any{"type": "b", "terms": false}, map[string]any{"terms": "accepted_if:type,a"}, false},
+		{"fail_condition_met_and_not_accepted", map[string]any{"type": "a", "terms": false}, map[string]any{"terms": "accepted_if:type,a"}, true},
+		{"fail_condition_met_and_missing", map[string]any{"type": "a"}, map[string]any{"terms": "accepted_if:type,a"}, true},
+		{"pass_condition_met_string_yes", map[string]any{"type": "a", "terms": "yes"}, map[string]any{"terms": "accepted_if:type,a"}, false},
+		{"pass_multiple_condition_values", map[string]any{"type": "b", "terms": "on"}, map[string]any{"terms": "accepted_if:type,a,b"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDeclined() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_bool_false", map[string]any{"opt": false}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_no", map[string]any{"opt": "no"}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_off", map[string]any{"opt": "off"}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_0", map[string]any{"opt": "0"}, map[string]any{"opt": "declined"}, false},
+		{"pass_int_0", map[string]any{"opt": 0}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_false", map[string]any{"opt": "false"}, map[string]any{"opt": "declined"}, false},
+		{"pass_float_0", map[string]any{"opt": float64(0)}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_NO_case", map[string]any{"opt": "NO"}, map[string]any{"opt": "declined"}, false},
+		{"pass_string_False_case", map[string]any{"opt": "False"}, map[string]any{"opt": "declined"}, false},
+		{"fail_bool_true", map[string]any{"opt": true}, map[string]any{"opt": "declined"}, true},
+		{"fail_string_yes", map[string]any{"opt": "yes"}, map[string]any{"opt": "declined"}, true},
+		{"fail_nil", map[string]any{"opt": nil}, map[string]any{"opt": "declined"}, true},
+		{"fail_string_random", map[string]any{"opt": "maybe"}, map[string]any{"opt": "declined"}, true},
+		{"fail_int_1", map[string]any{"opt": 1}, map[string]any{"opt": "declined"}, true},
+		{"fail_empty_string", map[string]any{"opt": ""}, map[string]any{"opt": "declined"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDeclinedIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met_and_declined", map[string]any{"type": "a", "opt": false}, map[string]any{"opt": "declined_if:type,a"}, false},
+		{"pass_condition_not_met", map[string]any{"type": "b", "opt": true}, map[string]any{"opt": "declined_if:type,a"}, false},
+		{"fail_condition_met_and_not_declined", map[string]any{"type": "a", "opt": true}, map[string]any{"opt": "declined_if:type,a"}, true},
+		{"fail_condition_met_and_missing", map[string]any{"type": "a"}, map[string]any{"opt": "declined_if:type,a"}, true},
+		{"pass_condition_met_string_no", map[string]any{"type": "a", "opt": "no"}, map[string]any{"opt": "declined_if:type,a"}, false},
+		{"pass_multiple_values", map[string]any{"type": "b", "opt": "off"}, map[string]any{"opt": "declined_if:type,a,b"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 3. Prohibition Rules =====
+
+func (s *RulesTestSuite) TestProhibited() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_empty", map[string]any{"x": ""}, map[string]any{"x": "prohibited"}, false},
+		{"pass_nil", map[string]any{"x": nil}, map[string]any{"x": "prohibited"}, false},
+		{"pass_empty_slice", map[string]any{"x": []any{}}, map[string]any{"x": "prohibited"}, false},
+		{"pass_empty_map", map[string]any{"x": map[string]any{}}, map[string]any{"x": "prohibited"}, false},
+		{"fail_with_value", map[string]any{"x": "hello"}, map[string]any{"x": "prohibited"}, true},
+		{"fail_with_int", map[string]any{"x": 1}, map[string]any{"x": "prohibited"}, true},
+		{"fail_with_bool", map[string]any{"x": true}, map[string]any{"x": "prohibited"}, true},
+		{"fail_with_slice", map[string]any{"x": []any{1}}, map[string]any{"x": "prohibited"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestProhibitedIf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met_and_empty", map[string]any{"type": "a", "x": ""}, map[string]any{"x": "prohibited_if:type,a"}, false},
+		{"pass_condition_not_met", map[string]any{"type": "b", "x": "val"}, map[string]any{"x": "prohibited_if:type,a"}, false},
+		{"fail_condition_met_and_has_value", map[string]any{"type": "a", "x": "val"}, map[string]any{"x": "prohibited_if:type,a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestProhibitedUnless() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_condition_met", map[string]any{"role": "admin", "x": "val"}, map[string]any{"x": "prohibited_unless:role,admin"}, false},
+		{"pass_condition_not_met_and_empty", map[string]any{"role": "user", "x": ""}, map[string]any{"x": "prohibited_unless:role,admin"}, false},
+		{"fail_condition_not_met_and_has_value", map[string]any{"role": "user", "x": "val"}, map[string]any{"x": "prohibited_unless:role,admin"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestProhibitedIfAccepted() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_accepted_and_empty", map[string]any{"terms": true, "x": ""}, map[string]any{"x": "prohibited_if_accepted:terms"}, false},
+		{"pass_not_accepted", map[string]any{"terms": false, "x": "val"}, map[string]any{"x": "prohibited_if_accepted:terms"}, false},
+		{"fail_accepted_and_has_value", map[string]any{"terms": true, "x": "val"}, map[string]any{"x": "prohibited_if_accepted:terms"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestProhibitedIfDeclined() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_declined_and_empty", map[string]any{"auto": false, "x": ""}, map[string]any{"x": "prohibited_if_declined:auto"}, false},
+		{"pass_not_declined", map[string]any{"auto": true, "x": "val"}, map[string]any{"x": "prohibited_if_declined:auto"}, false},
+		{"fail_declined_and_has_value", map[string]any{"auto": false, "x": "val"}, map[string]any{"x": "prohibited_if_declined:auto"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestProhibits() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_self_empty", map[string]any{"x": "", "y": "val"}, map[string]any{"x": "prohibits:y"}, false},
+		{"pass_self_has_value_other_empty", map[string]any{"x": "val", "y": ""}, map[string]any{"x": "prohibits:y"}, false},
+		{"pass_self_has_value_other_missing", map[string]any{"x": "val"}, map[string]any{"x": "prohibits:y"}, false},
+		{"pass_self_nil", map[string]any{"x": nil, "y": "val"}, map[string]any{"x": "prohibits:y"}, false},
+		{"fail_both_have_values", map[string]any{"x": "val", "y": "val2"}, map[string]any{"x": "prohibits:y"}, true},
+		{"fail_multiple_one_present", map[string]any{"x": "val", "y": "", "z": "val2"}, map[string]any{"x": "prohibits:y,z"}, true},
+		{"pass_multiple_all_empty", map[string]any{"x": "val", "y": "", "z": ""}, map[string]any{"x": "prohibits:y,z"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 4. Type Rules =====
+
+func (s *RulesTestSuite) TestStringRule() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_string", map[string]any{"x": "hello"}, map[string]any{"x": "string"}, false},
+		{"pass_string_with_spaces", map[string]any{"x": "hello world"}, map[string]any{"x": "string"}, false},
+		{"pass_string_unicode", map[string]any{"x": "你好世界"}, map[string]any{"x": "string"}, false},
+		{"pass_string_numeric_str", map[string]any{"x": "12345"}, map[string]any{"x": "string"}, false},
+		{"fail_int", map[string]any{"x": 123}, map[string]any{"x": "string"}, true},
+		{"fail_bool", map[string]any{"x": true}, map[string]any{"x": "string"}, true},
+		{"fail_float", map[string]any{"x": 3.14}, map[string]any{"x": "string"}, true},
+		{"fail_slice", map[string]any{"x": []any{1}}, map[string]any{"x": "string"}, true},
+		{"fail_map", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "string"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestInteger() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_int", map[string]any{"x": 42}, map[string]any{"x": "integer"}, false},
+		{"pass_int64", map[string]any{"x": int64(42)}, map[string]any{"x": "integer"}, false},
+		{"pass_int32", map[string]any{"x": int32(42)}, map[string]any{"x": "integer"}, false},
+		{"pass_int8", map[string]any{"x": int8(42)}, map[string]any{"x": "integer"}, false},
+		{"pass_uint", map[string]any{"x": uint(42)}, map[string]any{"x": "integer"}, false},
+		{"pass_string_int", map[string]any{"x": "42"}, map[string]any{"x": "integer"}, false},
+		{"pass_string_negative", map[string]any{"x": "-10"}, map[string]any{"x": "integer"}, false},
+		{"pass_float_whole", map[string]any{"x": 42.0}, map[string]any{"x": "integer"}, false},
+		{"pass_zero", map[string]any{"x": 0}, map[string]any{"x": "integer"}, false},
+		{"fail_float_decimal", map[string]any{"x": 42.5}, map[string]any{"x": "integer"}, true},
+		{"fail_string_alpha", map[string]any{"x": "abc"}, map[string]any{"x": "integer"}, true},
+		{"fail_string_float", map[string]any{"x": "42.5"}, map[string]any{"x": "integer"}, true},
+		{"fail_bool", map[string]any{"x": true}, map[string]any{"x": "integer"}, true},
+		{"pass_int_alias", map[string]any{"x": 1}, map[string]any{"x": "int"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestNumeric() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_int", map[string]any{"x": 42}, map[string]any{"x": "numeric"}, false},
+		{"pass_float", map[string]any{"x": 3.14}, map[string]any{"x": "numeric"}, false},
+		{"pass_numeric_string", map[string]any{"x": "3.14"}, map[string]any{"x": "numeric"}, false},
+		{"pass_negative_string", map[string]any{"x": "-5"}, map[string]any{"x": "numeric"}, false},
+		{"pass_zero", map[string]any{"x": 0}, map[string]any{"x": "numeric"}, false},
+		{"pass_int64", map[string]any{"x": int64(100)}, map[string]any{"x": "numeric"}, false},
+		{"pass_uint", map[string]any{"x": uint(50)}, map[string]any{"x": "numeric"}, false},
+		{"pass_string_int", map[string]any{"x": "42"}, map[string]any{"x": "numeric"}, false},
+		{"pass_bool_converts", map[string]any{"x": true}, map[string]any{"x": "numeric"}, false},
+		{"fail_alpha_string", map[string]any{"x": "abc"}, map[string]any{"x": "numeric"}, true},
+		{"fail_mixed_string", map[string]any{"x": "12abc"}, map[string]any{"x": "numeric"}, true},
+		{"fail_slice", map[string]any{"x": []any{1}}, map[string]any{"x": "numeric"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestBooleanRule() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_true", map[string]any{"x": true}, map[string]any{"x": "boolean"}, false},
+		{"pass_false", map[string]any{"x": false}, map[string]any{"x": "boolean"}, false},
+		{"pass_int_0", map[string]any{"x": 0}, map[string]any{"x": "boolean"}, false},
+		{"pass_int_1", map[string]any{"x": 1}, map[string]any{"x": "boolean"}, false},
+		{"pass_int64_0", map[string]any{"x": int64(0)}, map[string]any{"x": "boolean"}, false},
+		{"pass_int64_1", map[string]any{"x": int64(1)}, map[string]any{"x": "boolean"}, false},
+		{"pass_float64_0", map[string]any{"x": float64(0)}, map[string]any{"x": "boolean"}, false},
+		{"pass_float64_1", map[string]any{"x": float64(1)}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_true", map[string]any{"x": "true"}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_false", map[string]any{"x": "false"}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_0", map[string]any{"x": "0"}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_1", map[string]any{"x": "1"}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_yes", map[string]any{"x": "yes"}, map[string]any{"x": "boolean"}, false},
+		{"pass_string_on", map[string]any{"x": "on"}, map[string]any{"x": "boolean"}, false},
+		{"fail_int_2", map[string]any{"x": 2}, map[string]any{"x": "boolean"}, true},
+		{"fail_int_neg1", map[string]any{"x": -1}, map[string]any{"x": "boolean"}, true},
+		{"fail_string_2", map[string]any{"x": "2"}, map[string]any{"x": "boolean"}, true},
+		{"fail_slice", map[string]any{"x": []any{true}}, map[string]any{"x": "boolean"}, true},
+		{"pass_bool_alias", map[string]any{"x": true}, map[string]any{"x": "bool"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestFloat() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_float64", map[string]any{"x": 3.14}, map[string]any{"x": "float"}, false},
+		{"pass_float32", map[string]any{"x": float32(3.14)}, map[string]any{"x": "float"}, false},
+		{"pass_string_float", map[string]any{"x": "3.14"}, map[string]any{"x": "float"}, false},
+		{"pass_string_negative_float", map[string]any{"x": "-3.14"}, map[string]any{"x": "float"}, false},
+		{"pass_string_whole_number", map[string]any{"x": "42"}, map[string]any{"x": "float"}, false},
+		{"pass_float64_zero", map[string]any{"x": 0.0}, map[string]any{"x": "float"}, false},
+		{"fail_int", map[string]any{"x": 42}, map[string]any{"x": "float"}, true},
+		{"fail_string", map[string]any{"x": "abc"}, map[string]any{"x": "float"}, true},
+		{"fail_bool", map[string]any{"x": true}, map[string]any{"x": "float"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestArray() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_slice", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array"}, false},
+		{"pass_map", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "array"}, false},
+		{"pass_string_slice", map[string]any{"x": []string{"a"}}, map[string]any{"x": "array"}, false},
+		{"pass_empty_slice", map[string]any{"x": []any{}}, map[string]any{"x": "array"}, false},
+		{"pass_empty_map", map[string]any{"x": map[string]any{}}, map[string]any{"x": "array"}, false},
+		{"pass_int_slice", map[string]any{"x": []int{1, 2}}, map[string]any{"x": "array"}, false},
+		{"fail_string", map[string]any{"x": "hello"}, map[string]any{"x": "array"}, true},
+		{"fail_int", map[string]any{"x": 42}, map[string]any{"x": "array"}, true},
+		{"fail_nil", map[string]any{"x": nil}, map[string]any{"x": "array"}, true},
+		{"fail_bool", map[string]any{"x": true}, map[string]any{"x": "array"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestList() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_slice", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "list"}, false},
+		{"pass_empty_slice", map[string]any{"x": []any{}}, map[string]any{"x": "list"}, false},
+		{"pass_string_slice", map[string]any{"x": []string{"a"}}, map[string]any{"x": "list"}, false},
+		{"fail_map", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "list"}, true},
+		{"fail_string", map[string]any{"x": "hello"}, map[string]any{"x": "list"}, true},
+		{"fail_nil", map[string]any{"x": nil}, map[string]any{"x": "list"}, true},
+		{"pass_slice_alias", map[string]any{"x": []any{1}}, map[string]any{"x": "slice"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMap() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_map", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "map"}, false},
+		{"pass_empty_map", map[string]any{"x": map[string]any{}}, map[string]any{"x": "map"}, false},
+		{"fail_slice", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "map"}, true},
+		{"fail_string", map[string]any{"x": "hello"}, map[string]any{"x": "map"}, true},
+		{"fail_nil", map[string]any{"x": nil}, map[string]any{"x": "map"}, true},
+		{"fail_int", map[string]any{"x": 42}, map[string]any{"x": "map"}, true},
+		{"fail_bool", map[string]any{"x": true}, map[string]any{"x": "map"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 5. Size Rules =====
+
+func (s *RulesTestSuite) TestSize() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String type: size = character count
+		{"pass_string_exact", map[string]any{"x": "abc"}, map[string]any{"x": "string|size:3"}, false},
+		{"fail_string_too_short", map[string]any{"x": "ab"}, map[string]any{"x": "string|size:3"}, true},
+		{"fail_string_too_long", map[string]any{"x": "abcd"}, map[string]any{"x": "string|size:3"}, true},
+		{"pass_string_empty_size_zero", map[string]any{"x": ""}, map[string]any{"x": "string|size:0"}, false},
+		{"pass_string_unicode", map[string]any{"x": "你好世"}, map[string]any{"x": "string|size:3"}, false},
+		{"pass_string_single_char", map[string]any{"x": "a"}, map[string]any{"x": "string|size:1"}, false},
+
+		// Numeric type: size = numeric value
+		{"pass_numeric_exact_int", map[string]any{"x": 10}, map[string]any{"x": "numeric|size:10"}, false},
+		{"fail_numeric_wrong", map[string]any{"x": 5}, map[string]any{"x": "numeric|size:10"}, true},
+		{"pass_numeric_exact_float", map[string]any{"x": 3.14}, map[string]any{"x": "numeric|size:3.14"}, false},
+		{"pass_numeric_zero", map[string]any{"x": 0}, map[string]any{"x": "numeric|size:0"}, false},
+		{"pass_numeric_negative", map[string]any{"x": -5}, map[string]any{"x": "numeric|size:-5"}, false},
+		{"fail_numeric_negative_mismatch", map[string]any{"x": -3}, map[string]any{"x": "numeric|size:-5"}, true},
+		{"pass_numeric_string_value", map[string]any{"x": "42"}, map[string]any{"x": "numeric|size:42"}, false},
+		{"pass_numeric_float64", map[string]any{"x": float64(100)}, map[string]any{"x": "numeric|size:100"}, false},
+
+		// Array type: size = element count
+		{"pass_array_exact", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|size:3"}, false},
+		{"fail_array_too_few", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|size:3"}, true},
+		{"fail_array_too_many", map[string]any{"x": []any{1, 2, 3, 4}}, map[string]any{"x": "array|size:3"}, true},
+		{"pass_array_empty_size_zero", map[string]any{"x": []any{}}, map[string]any{"x": "array|size:0"}, false},
+		{"pass_array_single", map[string]any{"x": []any{"a"}}, map[string]any{"x": "array|size:1"}, false},
+
+		// Map type with size
+		{"pass_map_exact", map[string]any{"x": map[string]any{"a": 1, "b": 2}}, map[string]any{"x": "map|size:2"}, false},
+		{"fail_map_wrong", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "map|size:2"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMin() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String: min character count
+		{"pass_string_above", map[string]any{"x": "abcde"}, map[string]any{"x": "string|min:3"}, false},
+		{"pass_string_exact", map[string]any{"x": "abc"}, map[string]any{"x": "string|min:3"}, false},
+		{"fail_string_below", map[string]any{"x": "ab"}, map[string]any{"x": "string|min:3"}, true},
+		{"pass_string_unicode_above", map[string]any{"x": "你好世界"}, map[string]any{"x": "string|min:3"}, false},
+		{"fail_string_unicode_below", map[string]any{"x": "你好"}, map[string]any{"x": "string|min:3"}, true},
+		{"pass_string_min_zero", map[string]any{"x": ""}, map[string]any{"x": "string|min:0"}, false},
+		{"pass_string_min_one", map[string]any{"x": "a"}, map[string]any{"x": "string|min:1"}, false},
+
+		// Numeric: min numeric value
+		{"pass_numeric_above", map[string]any{"x": 15}, map[string]any{"x": "numeric|min:10"}, false},
+		{"pass_numeric_exact", map[string]any{"x": 10}, map[string]any{"x": "numeric|min:10"}, false},
+		{"fail_numeric_below", map[string]any{"x": 5}, map[string]any{"x": "numeric|min:10"}, true},
+		{"pass_numeric_float", map[string]any{"x": 3.5}, map[string]any{"x": "numeric|min:3.5"}, false},
+		{"fail_numeric_float_below", map[string]any{"x": 3.4}, map[string]any{"x": "numeric|min:3.5"}, true},
+		{"pass_numeric_negative", map[string]any{"x": -1}, map[string]any{"x": "numeric|min:-5"}, false},
+		{"fail_numeric_negative_below", map[string]any{"x": -10}, map[string]any{"x": "numeric|min:-5"}, true},
+		{"pass_numeric_zero", map[string]any{"x": 0}, map[string]any{"x": "numeric|min:0"}, false},
+		{"pass_numeric_string", map[string]any{"x": "100"}, map[string]any{"x": "numeric|min:50"}, false},
+
+		// Array: min element count
+		{"pass_array_above", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|min:2"}, false},
+		{"pass_array_exact", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|min:2"}, false},
+		{"fail_array_below", map[string]any{"x": []any{1}}, map[string]any{"x": "array|min:2"}, true},
+		{"pass_array_min_zero", map[string]any{"x": []any{}}, map[string]any{"x": "array|min:0"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMax() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String
+		{"pass_string_below", map[string]any{"x": "ab"}, map[string]any{"x": "string|max:3"}, false},
+		{"pass_string_exact", map[string]any{"x": "abc"}, map[string]any{"x": "string|max:3"}, false},
+		{"fail_string_above", map[string]any{"x": "abcd"}, map[string]any{"x": "string|max:3"}, true},
+		{"pass_string_empty", map[string]any{"x": ""}, map[string]any{"x": "string|max:3"}, false},
+		{"pass_string_unicode_within", map[string]any{"x": "你好"}, map[string]any{"x": "string|max:3"}, false},
+		{"fail_string_unicode_over", map[string]any{"x": "你好世界"}, map[string]any{"x": "string|max:3"}, true},
+
+		// Numeric
+		{"pass_numeric_below", map[string]any{"x": 5}, map[string]any{"x": "numeric|max:10"}, false},
+		{"pass_numeric_exact", map[string]any{"x": 10}, map[string]any{"x": "numeric|max:10"}, false},
+		{"fail_numeric_above", map[string]any{"x": 15}, map[string]any{"x": "numeric|max:10"}, true},
+		{"pass_numeric_zero", map[string]any{"x": 0}, map[string]any{"x": "numeric|max:10"}, false},
+		{"pass_numeric_negative", map[string]any{"x": -5}, map[string]any{"x": "numeric|max:0"}, false},
+		{"fail_numeric_negative_threshold", map[string]any{"x": -3}, map[string]any{"x": "numeric|max:-5"}, true},
+		{"pass_numeric_float", map[string]any{"x": 3.14}, map[string]any{"x": "numeric|max:3.14"}, false},
+		{"fail_numeric_float_over", map[string]any{"x": 3.15}, map[string]any{"x": "numeric|max:3.14"}, true},
+
+		// Array
+		{"pass_array_below", map[string]any{"x": []any{1}}, map[string]any{"x": "array|max:2"}, false},
+		{"pass_array_exact", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|max:2"}, false},
+		{"fail_array_above", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|max:2"}, true},
+		{"pass_array_empty", map[string]any{"x": []any{}}, map[string]any{"x": "array|max:2"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestBetween() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String
+		{"pass_string_in_range", map[string]any{"x": "abcd"}, map[string]any{"x": "string|between:3,5"}, false},
+		{"pass_string_at_min", map[string]any{"x": "abc"}, map[string]any{"x": "string|between:3,5"}, false},
+		{"pass_string_at_max", map[string]any{"x": "abcde"}, map[string]any{"x": "string|between:3,5"}, false},
+		{"fail_string_below", map[string]any{"x": "ab"}, map[string]any{"x": "string|between:3,5"}, true},
+		{"fail_string_above", map[string]any{"x": "abcdef"}, map[string]any{"x": "string|between:3,5"}, true},
+
+		// Numeric
+		{"pass_numeric_in_range", map[string]any{"x": 25}, map[string]any{"x": "numeric|between:18,65"}, false},
+		{"pass_numeric_at_min", map[string]any{"x": 18}, map[string]any{"x": "numeric|between:18,65"}, false},
+		{"pass_numeric_at_max", map[string]any{"x": 65}, map[string]any{"x": "numeric|between:18,65"}, false},
+		{"fail_numeric_below", map[string]any{"x": 10}, map[string]any{"x": "numeric|between:18,65"}, true},
+		{"fail_numeric_above", map[string]any{"x": 100}, map[string]any{"x": "numeric|between:18,65"}, true},
+		{"pass_numeric_float_range", map[string]any{"x": 1.5}, map[string]any{"x": "numeric|between:1.0,2.0"}, false},
+		{"pass_numeric_negative_range", map[string]any{"x": -3}, map[string]any{"x": "numeric|between:-5,-1"}, false},
+
+		// Array
+		{"pass_array_in_range", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|between:2,4"}, false},
+		{"pass_array_at_min", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|between:2,4"}, false},
+		{"pass_array_at_max", map[string]any{"x": []any{1, 2, 3, 4}}, map[string]any{"x": "array|between:2,4"}, false},
+		{"fail_array_below", map[string]any{"x": []any{1}}, map[string]any{"x": "array|between:2,4"}, true},
+		{"fail_array_above", map[string]any{"x": []any{1, 2, 3, 4, 5}}, map[string]any{"x": "array|between:2,4"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestGt() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String: character count > threshold
+		{"pass_string_greater", map[string]any{"x": "abcde"}, map[string]any{"x": "string|gt:3"}, false},
+		{"fail_string_equal", map[string]any{"x": "abc"}, map[string]any{"x": "string|gt:3"}, true},
+		{"fail_string_less", map[string]any{"x": "ab"}, map[string]any{"x": "string|gt:3"}, true},
+
+		// Numeric: value > threshold
+		{"pass_numeric_greater", map[string]any{"x": 15}, map[string]any{"x": "numeric|gt:10"}, false},
+		{"fail_numeric_equal", map[string]any{"x": 10}, map[string]any{"x": "numeric|gt:10"}, true},
+		{"fail_numeric_less", map[string]any{"x": 5}, map[string]any{"x": "numeric|gt:10"}, true},
+		{"pass_numeric_float_greater", map[string]any{"x": 3.15}, map[string]any{"x": "numeric|gt:3.14"}, false},
+		{"fail_numeric_float_equal", map[string]any{"x": 3.14}, map[string]any{"x": "numeric|gt:3.14"}, true},
+
+		// Array: count > threshold
+		{"pass_array_greater", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|gt:2"}, false},
+		{"fail_array_equal", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|gt:2"}, true},
+
+		// Field reference: compare against another field
+		{"pass_gt_field_ref_string", map[string]any{"x": "abcd", "y": "ab"}, map[string]any{"x": "string|gt:y", "y": "string"}, false},
+		{"fail_gt_field_ref_string", map[string]any{"x": "ab", "y": "abcd"}, map[string]any{"x": "string|gt:y", "y": "string"}, true},
+		{"pass_gt_field_ref_numeric", map[string]any{"x": 20, "y": 10}, map[string]any{"x": "numeric|gt:y", "y": "numeric"}, false},
+		{"fail_gt_field_ref_numeric", map[string]any{"x": 10, "y": 10}, map[string]any{"x": "numeric|gt:y", "y": "numeric"}, true},
+		{"pass_gt_field_ref_array", map[string]any{"x": []any{1, 2, 3}, "y": []any{1}}, map[string]any{"x": "array|gt:y", "y": "array"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestGte() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String
+		{"pass_string_greater", map[string]any{"x": "abcde"}, map[string]any{"x": "string|gte:3"}, false},
+		{"pass_string_equal", map[string]any{"x": "abc"}, map[string]any{"x": "string|gte:3"}, false},
+		{"fail_string_less", map[string]any{"x": "ab"}, map[string]any{"x": "string|gte:3"}, true},
+
+		// Numeric
+		{"pass_numeric_greater", map[string]any{"x": 15}, map[string]any{"x": "numeric|gte:10"}, false},
+		{"pass_numeric_equal", map[string]any{"x": 10}, map[string]any{"x": "numeric|gte:10"}, false},
+		{"fail_numeric_less", map[string]any{"x": 5}, map[string]any{"x": "numeric|gte:10"}, true},
+		{"pass_numeric_float_equal", map[string]any{"x": 3.14}, map[string]any{"x": "numeric|gte:3.14"}, false},
+		{"pass_numeric_negative", map[string]any{"x": -3}, map[string]any{"x": "numeric|gte:-5"}, false},
+
+		// Array
+		{"pass_array_greater", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|gte:2"}, false},
+		{"pass_array_equal", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|gte:2"}, false},
+		{"fail_array_less", map[string]any{"x": []any{1}}, map[string]any{"x": "array|gte:2"}, true},
+
+		// Field reference
+		{"pass_gte_field_ref_numeric", map[string]any{"x": 10, "y": 10}, map[string]any{"x": "numeric|gte:y", "y": "numeric"}, false},
+		{"pass_gte_field_ref_numeric_greater", map[string]any{"x": 15, "y": 10}, map[string]any{"x": "numeric|gte:y", "y": "numeric"}, false},
+		{"fail_gte_field_ref_numeric", map[string]any{"x": 5, "y": 10}, map[string]any{"x": "numeric|gte:y", "y": "numeric"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestLt() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String
+		{"pass_string_less", map[string]any{"x": "ab"}, map[string]any{"x": "string|lt:3"}, false},
+		{"fail_string_equal", map[string]any{"x": "abc"}, map[string]any{"x": "string|lt:3"}, true},
+		{"fail_string_greater", map[string]any{"x": "abcd"}, map[string]any{"x": "string|lt:3"}, true},
+
+		// Numeric
+		{"pass_numeric_less", map[string]any{"x": 5}, map[string]any{"x": "numeric|lt:10"}, false},
+		{"fail_numeric_equal", map[string]any{"x": 10}, map[string]any{"x": "numeric|lt:10"}, true},
+		{"fail_numeric_greater", map[string]any{"x": 15}, map[string]any{"x": "numeric|lt:10"}, true},
+		{"pass_numeric_negative", map[string]any{"x": -10}, map[string]any{"x": "numeric|lt:-5"}, false},
+		{"fail_numeric_negative_equal", map[string]any{"x": -5}, map[string]any{"x": "numeric|lt:-5"}, true},
+
+		// Array
+		{"pass_array_less", map[string]any{"x": []any{1}}, map[string]any{"x": "array|lt:2"}, false},
+		{"fail_array_equal", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|lt:2"}, true},
+
+		// Field reference
+		{"pass_lt_field_ref_numeric", map[string]any{"x": 5, "y": 10}, map[string]any{"x": "numeric|lt:y", "y": "numeric"}, false},
+		{"fail_lt_field_ref_numeric", map[string]any{"x": 10, "y": 10}, map[string]any{"x": "numeric|lt:y", "y": "numeric"}, true},
+		{"pass_lt_field_ref_string", map[string]any{"x": "ab", "y": "abcde"}, map[string]any{"x": "string|lt:y", "y": "string"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestLte() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// String
+		{"pass_string_less", map[string]any{"x": "ab"}, map[string]any{"x": "string|lte:3"}, false},
+		{"pass_string_equal", map[string]any{"x": "abc"}, map[string]any{"x": "string|lte:3"}, false},
+		{"fail_string_greater", map[string]any{"x": "abcd"}, map[string]any{"x": "string|lte:3"}, true},
+
+		// Numeric
+		{"pass_numeric_less", map[string]any{"x": 5}, map[string]any{"x": "numeric|lte:10"}, false},
+		{"pass_numeric_equal", map[string]any{"x": 10}, map[string]any{"x": "numeric|lte:10"}, false},
+		{"fail_numeric_greater", map[string]any{"x": 15}, map[string]any{"x": "numeric|lte:10"}, true},
+		{"pass_numeric_zero", map[string]any{"x": 0}, map[string]any{"x": "numeric|lte:0"}, false},
+		{"pass_numeric_negative", map[string]any{"x": -10}, map[string]any{"x": "numeric|lte:-5"}, false},
+		{"pass_numeric_negative_equal", map[string]any{"x": -5}, map[string]any{"x": "numeric|lte:-5"}, false},
+
+		// Array
+		{"pass_array_less", map[string]any{"x": []any{1}}, map[string]any{"x": "array|lte:2"}, false},
+		{"pass_array_equal", map[string]any{"x": []any{1, 2}}, map[string]any{"x": "array|lte:2"}, false},
+		{"fail_array_greater", map[string]any{"x": []any{1, 2, 3}}, map[string]any{"x": "array|lte:2"}, true},
+
+		// Field reference
+		{"pass_lte_field_ref_numeric_equal", map[string]any{"x": 10, "y": 10}, map[string]any{"x": "numeric|lte:y", "y": "numeric"}, false},
+		{"pass_lte_field_ref_numeric_less", map[string]any{"x": 5, "y": 10}, map[string]any{"x": "numeric|lte:y", "y": "numeric"}, false},
+		{"fail_lte_field_ref_numeric", map[string]any{"x": 15, "y": 10}, map[string]any{"x": "numeric|lte:y", "y": "numeric"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 6. Numeric Rules =====
+
+func (s *RulesTestSuite) TestDigits() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_exact_digits_3", map[string]any{"x": "123"}, map[string]any{"x": "digits:3"}, false},
+		{"pass_exact_digits_1", map[string]any{"x": "5"}, map[string]any{"x": "digits:1"}, false},
+		{"pass_exact_digits_6", map[string]any{"x": "000000"}, map[string]any{"x": "digits:6"}, false},
+		{"fail_wrong_count_less", map[string]any{"x": "12"}, map[string]any{"x": "digits:3"}, true},
+		{"fail_wrong_count_more", map[string]any{"x": "1234"}, map[string]any{"x": "digits:3"}, true},
+		{"fail_non_digit_letter", map[string]any{"x": "12a"}, map[string]any{"x": "digits:3"}, true},
+		{"fail_non_digit_symbol", map[string]any{"x": "12."}, map[string]any{"x": "digits:3"}, true},
+		{"fail_negative_sign", map[string]any{"x": "-12"}, map[string]any{"x": "digits:3"}, true},
+		{"pass_int_value", map[string]any{"x": 1234}, map[string]any{"x": "digits:4"}, false},
+		{"pass_int_single_digit", map[string]any{"x": 0}, map[string]any{"x": "digits:1"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDigitsBetween() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_in_range", map[string]any{"x": "123"}, map[string]any{"x": "digits_between:2,4"}, false},
+		{"pass_at_min", map[string]any{"x": "12"}, map[string]any{"x": "digits_between:2,4"}, false},
+		{"pass_at_max", map[string]any{"x": "1234"}, map[string]any{"x": "digits_between:2,4"}, false},
+		{"fail_below_min", map[string]any{"x": "1"}, map[string]any{"x": "digits_between:2,4"}, true},
+		{"fail_above_max", map[string]any{"x": "12345"}, map[string]any{"x": "digits_between:2,4"}, true},
+		{"fail_non_digit", map[string]any{"x": "12a"}, map[string]any{"x": "digits_between:2,4"}, true},
+		{"pass_int_value", map[string]any{"x": 123}, map[string]any{"x": "digits_between:2,4"}, false},
+		{"pass_all_zeros", map[string]any{"x": "000"}, map[string]any{"x": "digits_between:2,4"}, false},
+		{"pass_range_1_10", map[string]any{"x": "12345"}, map[string]any{"x": "digits_between:1,10"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDecimal() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_exact_2_places", map[string]any{"x": "3.14"}, map[string]any{"x": "decimal:2"}, false},
+		{"fail_1_place_for_2", map[string]any{"x": "3.1"}, map[string]any{"x": "decimal:2"}, true},
+		{"fail_3_places_for_2", map[string]any{"x": "3.142"}, map[string]any{"x": "decimal:2"}, true},
+		{"pass_range_1_3", map[string]any{"x": "3.14"}, map[string]any{"x": "decimal:1,3"}, false},
+		{"pass_range_min", map[string]any{"x": "3.1"}, map[string]any{"x": "decimal:1,3"}, false},
+		{"pass_range_max", map[string]any{"x": "3.142"}, map[string]any{"x": "decimal:1,3"}, false},
+		{"fail_range_below", map[string]any{"x": "3"}, map[string]any{"x": "decimal:1,3"}, true},
+		{"fail_range_above", map[string]any{"x": "3.1415"}, map[string]any{"x": "decimal:1,3"}, true},
+		{"pass_zero_decimal_places", map[string]any{"x": "3"}, map[string]any{"x": "decimal:0"}, false},
+		{"fail_has_decimal_for_0", map[string]any{"x": "3.1"}, map[string]any{"x": "decimal:0"}, true},
+		{"fail_not_numeric", map[string]any{"x": "abc"}, map[string]any{"x": "decimal:2"}, true},
+		{"pass_negative_decimal", map[string]any{"x": "-3.14"}, map[string]any{"x": "decimal:2"}, false},
+		{"pass_zero_value", map[string]any{"x": "0.00"}, map[string]any{"x": "decimal:2"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMultipleOf() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_15_of_5", map[string]any{"x": 15}, map[string]any{"x": "multiple_of:5"}, false},
+		{"pass_10_of_5", map[string]any{"x": 10}, map[string]any{"x": "multiple_of:5"}, false},
+		{"fail_13_of_5", map[string]any{"x": 13}, map[string]any{"x": "multiple_of:5"}, true},
+		{"pass_zero_of_5", map[string]any{"x": 0}, map[string]any{"x": "multiple_of:5"}, false},
+		{"pass_100_of_25", map[string]any{"x": 100}, map[string]any{"x": "multiple_of:25"}, false},
+		{"fail_99_of_25", map[string]any{"x": 99}, map[string]any{"x": "multiple_of:25"}, true},
+		{"pass_negative_of_3", map[string]any{"x": -9}, map[string]any{"x": "multiple_of:3"}, false},
+		{"fail_negative_of_4", map[string]any{"x": -9}, map[string]any{"x": "multiple_of:4"}, true},
+		{"pass_float_of_half", map[string]any{"x": 1.5}, map[string]any{"x": "multiple_of:0.5"}, false},
+		{"pass_string_number", map[string]any{"x": "12"}, map[string]any{"x": "multiple_of:4"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMinDigits() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_exact_digits", map[string]any{"x": "123"}, map[string]any{"x": "min_digits:3"}, false},
+		{"pass_more_digits", map[string]any{"x": "12345"}, map[string]any{"x": "min_digits:3"}, false},
+		{"fail_too_few", map[string]any{"x": "12"}, map[string]any{"x": "min_digits:3"}, true},
+		{"pass_int_value", map[string]any{"x": 12345}, map[string]any{"x": "min_digits:3"}, false},
+		{"fail_single_digit", map[string]any{"x": "5"}, map[string]any{"x": "min_digits:3"}, true},
+		{"pass_min_1", map[string]any{"x": "0"}, map[string]any{"x": "min_digits:1"}, false},
+		{"pass_with_leading_zeros", map[string]any{"x": "001"}, map[string]any{"x": "min_digits:3"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMaxDigits() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_within_limit", map[string]any{"x": "12"}, map[string]any{"x": "max_digits:3"}, false},
+		{"pass_at_limit", map[string]any{"x": "123"}, map[string]any{"x": "max_digits:3"}, false},
+		{"fail_over_limit", map[string]any{"x": "1234"}, map[string]any{"x": "max_digits:3"}, true},
+		{"pass_single_digit", map[string]any{"x": "5"}, map[string]any{"x": "max_digits:3"}, false},
+		{"pass_int_value", map[string]any{"x": 99}, map[string]any{"x": "max_digits:3"}, false},
+		{"fail_int_over", map[string]any{"x": 10000}, map[string]any{"x": "max_digits:3"}, true},
+		{"pass_max_1", map[string]any{"x": "0"}, map[string]any{"x": "max_digits:1"}, false},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 7. String Format Rules =====
+
+func (s *RulesTestSuite) TestAlpha() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_letters", map[string]any{"x": "Hello"}, map[string]any{"x": "alpha"}, false},
+		{"pass_unicode_letters", map[string]any{"x": "Héllo"}, map[string]any{"x": "alpha"}, false},
+		{"pass_chinese", map[string]any{"x": "你好"}, map[string]any{"x": "alpha"}, false},
+		{"pass_single_letter", map[string]any{"x": "a"}, map[string]any{"x": "alpha"}, false},
+		{"fail_with_numbers", map[string]any{"x": "abc123"}, map[string]any{"x": "alpha"}, true},
+		{"fail_with_spaces", map[string]any{"x": "abc def"}, map[string]any{"x": "alpha"}, true},
+		{"fail_with_special", map[string]any{"x": "abc!"}, map[string]any{"x": "alpha"}, true},
+		{"fail_with_dash", map[string]any{"x": "abc-def"}, map[string]any{"x": "alpha"}, true},
+		{"fail_with_underscore", map[string]any{"x": "abc_def"}, map[string]any{"x": "alpha"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAlphaNum() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_letters_and_numbers", map[string]any{"x": "abc123"}, map[string]any{"x": "alpha_num"}, false},
+		{"pass_letters_only", map[string]any{"x": "abc"}, map[string]any{"x": "alpha_num"}, false},
+		{"pass_numbers_only", map[string]any{"x": "123"}, map[string]any{"x": "alpha_num"}, false},
+		{"pass_unicode_letters_nums", map[string]any{"x": "Héllo123"}, map[string]any{"x": "alpha_num"}, false},
+		{"fail_with_spaces", map[string]any{"x": "abc 123"}, map[string]any{"x": "alpha_num"}, true},
+		{"fail_with_special", map[string]any{"x": "abc@123"}, map[string]any{"x": "alpha_num"}, true},
+		{"fail_with_dash", map[string]any{"x": "abc-123"}, map[string]any{"x": "alpha_num"}, true},
+		{"fail_with_underscore", map[string]any{"x": "abc_123"}, map[string]any{"x": "alpha_num"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAlphaDash() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_with_dash_underscore", map[string]any{"x": "abc-123_def"}, map[string]any{"x": "alpha_dash"}, false},
+		{"pass_letters_only", map[string]any{"x": "abc"}, map[string]any{"x": "alpha_dash"}, false},
+		{"pass_numbers_only", map[string]any{"x": "123"}, map[string]any{"x": "alpha_dash"}, false},
+		{"pass_underscore_only", map[string]any{"x": "___"}, map[string]any{"x": "alpha_dash"}, false},
+		{"pass_dash_only", map[string]any{"x": "---"}, map[string]any{"x": "alpha_dash"}, false},
+		{"pass_slug", map[string]any{"x": "my-blog-post"}, map[string]any{"x": "alpha_dash"}, false},
+		{"fail_with_spaces", map[string]any{"x": "abc def"}, map[string]any{"x": "alpha_dash"}, true},
+		{"fail_with_special", map[string]any{"x": "abc@def"}, map[string]any{"x": "alpha_dash"}, true},
+		{"fail_with_dot", map[string]any{"x": "abc.def"}, map[string]any{"x": "alpha_dash"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAscii() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_ascii_text", map[string]any{"x": "hello world"}, map[string]any{"x": "ascii"}, false},
+		{"pass_ascii_with_symbols", map[string]any{"x": "hello@world.com!#$%"}, map[string]any{"x": "ascii"}, false},
+		{"pass_ascii_numbers", map[string]any{"x": "12345"}, map[string]any{"x": "ascii"}, false},
+		{"pass_ascii_newline_tab", map[string]any{"x": "hello\nworld\t!"}, map[string]any{"x": "ascii"}, false},
+		{"fail_unicode_accent", map[string]any{"x": "héllo"}, map[string]any{"x": "ascii"}, true},
+		{"fail_emoji", map[string]any{"x": "hello 🎉"}, map[string]any{"x": "ascii"}, true},
+		{"fail_chinese", map[string]any{"x": "你好"}, map[string]any{"x": "ascii"}, true},
+		{"fail_japanese", map[string]any{"x": "こんにちは"}, map[string]any{"x": "ascii"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestEmail() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_simple", map[string]any{"x": "user@example.com"}, map[string]any{"x": "email"}, false},
+		{"pass_with_plus", map[string]any{"x": "user+tag@example.com"}, map[string]any{"x": "email"}, false},
+		{"pass_with_dot", map[string]any{"x": "first.last@example.com"}, map[string]any{"x": "email"}, false},
+		{"pass_subdomain", map[string]any{"x": "user@mail.example.com"}, map[string]any{"x": "email"}, false},
+		{"pass_numbers", map[string]any{"x": "user123@example.com"}, map[string]any{"x": "email"}, false},
+		{"pass_dash_domain", map[string]any{"x": "user@my-domain.com"}, map[string]any{"x": "email"}, false},
+		{"fail_no_at", map[string]any{"x": "userexample.com"}, map[string]any{"x": "email"}, true},
+		{"fail_no_domain", map[string]any{"x": "user@"}, map[string]any{"x": "email"}, true},
+		{"fail_no_user", map[string]any{"x": "@example.com"}, map[string]any{"x": "email"}, true},
+		{"fail_plain_string", map[string]any{"x": "notanemail"}, map[string]any{"x": "email"}, true},
+		{"fail_double_at", map[string]any{"x": "user@@example.com"}, map[string]any{"x": "email"}, true},
+		{"fail_spaces", map[string]any{"x": "user @example.com"}, map[string]any{"x": "email"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUrl() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_https", map[string]any{"x": "https://goravel.dev"}, map[string]any{"x": "url"}, false},
+		{"pass_http", map[string]any{"x": "https://example.com/path"}, map[string]any{"x": "url"}, false},
+		{"pass_with_port", map[string]any{"x": "https://localhost:8080"}, map[string]any{"x": "url"}, false},
+		{"pass_with_query", map[string]any{"x": "https://example.com/path?q=test&a=1"}, map[string]any{"x": "url"}, false},
+		{"pass_with_fragment", map[string]any{"x": "https://example.com/page#section"}, map[string]any{"x": "url"}, false},
+		{"pass_ftp", map[string]any{"x": "ftp://files.example.com"}, map[string]any{"x": "url"}, false},
+		{"fail_no_scheme", map[string]any{"x": "goravel.dev"}, map[string]any{"x": "url"}, true},
+		{"fail_plain_string", map[string]any{"x": "not a url"}, map[string]any{"x": "url"}, true},
+		{"fail_just_path", map[string]any{"x": "/path/to/file"}, map[string]any{"x": "url"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestIp() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_ipv4", map[string]any{"x": "192.168.1.1"}, map[string]any{"x": "ip"}, false},
+		{"pass_ipv4_loopback", map[string]any{"x": "127.0.0.1"}, map[string]any{"x": "ip"}, false},
+		{"pass_ipv4_all_zeros", map[string]any{"x": "0.0.0.0"}, map[string]any{"x": "ip"}, false},
+		{"pass_ipv6_full", map[string]any{"x": "2001:0db8:85a3:0000:0000:8a2e:0370:7334"}, map[string]any{"x": "ip"}, false},
+		{"pass_ipv6_loopback", map[string]any{"x": "::1"}, map[string]any{"x": "ip"}, false},
+		{"fail_invalid", map[string]any{"x": "not-an-ip"}, map[string]any{"x": "ip"}, true},
+		{"fail_out_of_range", map[string]any{"x": "999.999.999.999"}, map[string]any{"x": "ip"}, true},
+		{"fail_incomplete", map[string]any{"x": "192.168.1"}, map[string]any{"x": "ip"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestIpv4() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_valid", map[string]any{"x": "192.168.1.1"}, map[string]any{"x": "ipv4"}, false},
+		{"pass_loopback", map[string]any{"x": "127.0.0.1"}, map[string]any{"x": "ipv4"}, false},
+		{"pass_broadcast", map[string]any{"x": "255.255.255.255"}, map[string]any{"x": "ipv4"}, false},
+		{"pass_all_zeros", map[string]any{"x": "0.0.0.0"}, map[string]any{"x": "ipv4"}, false},
+		{"fail_ipv6", map[string]any{"x": "::1"}, map[string]any{"x": "ipv4"}, true},
+		{"fail_invalid", map[string]any{"x": "abc"}, map[string]any{"x": "ipv4"}, true},
+		{"fail_three_octets", map[string]any{"x": "192.168.1"}, map[string]any{"x": "ipv4"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestIpv6() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_full", map[string]any{"x": "2001:0db8:85a3:0000:0000:8a2e:0370:7334"}, map[string]any{"x": "ipv6"}, false},
+		{"pass_loopback", map[string]any{"x": "::1"}, map[string]any{"x": "ipv6"}, false},
+		{"pass_abbreviated", map[string]any{"x": "fe80::1"}, map[string]any{"x": "ipv6"}, false},
+		{"pass_all_zeros", map[string]any{"x": "::"}, map[string]any{"x": "ipv6"}, false},
+		{"fail_ipv4", map[string]any{"x": "192.168.1.1"}, map[string]any{"x": "ipv6"}, true},
+		{"fail_invalid", map[string]any{"x": "not-ipv6"}, map[string]any{"x": "ipv6"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMacAddress() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_colon", map[string]any{"x": "00:1B:44:11:3A:B7"}, map[string]any{"x": "mac_address"}, false},
+		{"pass_dash", map[string]any{"x": "00-1B-44-11-3A-B7"}, map[string]any{"x": "mac_address"}, false},
+		{"pass_lowercase_mac", map[string]any{"x": "00:1b:44:11:3a:b7"}, map[string]any{"x": "mac_address"}, false},
+		{"pass_alias_mac", map[string]any{"x": "00:1B:44:11:3A:B7"}, map[string]any{"x": "mac"}, false},
+		{"fail_invalid", map[string]any{"x": "not-a-mac"}, map[string]any{"x": "mac_address"}, true},
+		{"fail_too_short", map[string]any{"x": "00:1B:44"}, map[string]any{"x": "mac_address"}, true},
+		{"fail_invalid_hex", map[string]any{"x": "GG:HH:II:JJ:KK:LL"}, map[string]any{"x": "mac_address"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestJson() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_object", map[string]any{"x": `{"key":"val"}`}, map[string]any{"x": "json"}, false},
+		{"pass_array", map[string]any{"x": `[1,2,3]`}, map[string]any{"x": "json"}, false},
+		{"pass_string", map[string]any{"x": `"hello"`}, map[string]any{"x": "json"}, false},
+		{"pass_number", map[string]any{"x": `42`}, map[string]any{"x": "json"}, false},
+		{"pass_boolean", map[string]any{"x": `true`}, map[string]any{"x": "json"}, false},
+		{"pass_null", map[string]any{"x": `null`}, map[string]any{"x": "json"}, false},
+		{"pass_nested", map[string]any{"x": `{"a":{"b":[1,2]}}`}, map[string]any{"x": "json"}, false},
+		{"pass_empty_object", map[string]any{"x": `{}`}, map[string]any{"x": "json"}, false},
+		{"pass_empty_array", map[string]any{"x": `[]`}, map[string]any{"x": "json"}, false},
+		{"fail_invalid_braces", map[string]any{"x": `{invalid}`}, map[string]any{"x": "json"}, true},
+		{"fail_plain", map[string]any{"x": "hello"}, map[string]any{"x": "json"}, true},
+		{"fail_trailing_comma", map[string]any{"x": `{"a":1,}`}, map[string]any{"x": "json"}, true},
+		{"fail_single_quotes", map[string]any{"x": `{'a': 1}`}, map[string]any{"x": "json"}, true},
+		{"fail_non_string_type", map[string]any{"x": 123}, map[string]any{"x": "json"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUuid() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_v4", map[string]any{"x": "550e8400-e29b-41d4-a716-446655440000"}, map[string]any{"x": "uuid"}, false},
+		{"pass_lowercase", map[string]any{"x": "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"}, map[string]any{"x": "uuid"}, false},
+		{"pass_uppercase", map[string]any{"x": "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"}, map[string]any{"x": "uuid"}, false},
+		{"pass_nil_uuid", map[string]any{"x": "00000000-0000-0000-0000-000000000000"}, map[string]any{"x": "uuid"}, false},
+		{"fail_invalid", map[string]any{"x": "not-a-uuid"}, map[string]any{"x": "uuid"}, true},
+		{"fail_missing_dashes", map[string]any{"x": "550e8400e29b41d4a716446655440000"}, map[string]any{"x": "uuid"}, true},
+		{"fail_too_short", map[string]any{"x": "550e8400-e29b"}, map[string]any{"x": "uuid"}, true},
+		{"fail_invalid_chars", map[string]any{"x": "gggggggg-gggg-gggg-gggg-gggggggggggg"}, map[string]any{"x": "uuid"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUlid() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_valid", map[string]any{"x": "01ARZ3NDEKTSV4RRFFQ69G5FAV"}, map[string]any{"x": "ulid"}, false},
+		{"pass_lowercase_ulid", map[string]any{"x": "01arz3ndektsv4rrffq69g5fav"}, map[string]any{"x": "ulid"}, false},
+		{"fail_invalid", map[string]any{"x": "not-a-ulid"}, map[string]any{"x": "ulid"}, true},
+		{"fail_too_short", map[string]any{"x": "01ARZ3NDEK"}, map[string]any{"x": "ulid"}, true},
+		{"fail_too_long", map[string]any{"x": "01ARZ3NDEKTSV4RRFFQ69G5FAVX"}, map[string]any{"x": "ulid"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestHexColor() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_6_digit", map[string]any{"x": "#FF5733"}, map[string]any{"x": "hex_color"}, false},
+		{"pass_3_digit", map[string]any{"x": "#FFF"}, map[string]any{"x": "hex_color"}, false},
+		{"pass_8_digit_alpha", map[string]any{"x": "#FF5733AA"}, map[string]any{"x": "hex_color"}, false},
+		{"pass_lowercase_hex", map[string]any{"x": "#ff5733"}, map[string]any{"x": "hex_color"}, false},
+		{"fail_no_hash", map[string]any{"x": "FF5733"}, map[string]any{"x": "hex_color"}, true},
+		{"fail_invalid_chars", map[string]any{"x": "#GGGGGG"}, map[string]any{"x": "hex_color"}, true},
+		{"fail_empty_hash", map[string]any{"x": "#"}, map[string]any{"x": "hex_color"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestRegex() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_match", map[string]any{"x": "abc123"}, map[string]any{"x": `regex:^[a-z]+\d+$`}, false},
+		{"pass_simple_digits", map[string]any{"x": "12345"}, map[string]any{"x": `regex:^\d+$`}, false},
+		{"pass_email_pattern", map[string]any{"x": "a@b.c"}, map[string]any{"x": `regex:^.+@.+\..+$`}, false},
+		{"fail_no_match", map[string]any{"x": "ABC"}, map[string]any{"x": `regex:^[a-z]+\d+$`}, true},
+		{"fail_partial_match", map[string]any{"x": "abc"}, map[string]any{"x": `regex:^[a-z]+\d+$`}, true},
+		// Array syntax for regex with pipe
+		{"pass_regex_with_pipe_array", map[string]any{"x": "foo"}, map[string]any{"x": []string{"required", `regex:^(foo|bar)$`}}, false},
+		{"fail_regex_with_pipe_array", map[string]any{"x": "baz"}, map[string]any{"x": []string{"required", `regex:^(foo|bar)$`}}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestNotRegex() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_no_match", map[string]any{"x": "ABC"}, map[string]any{"x": `not_regex:^[a-z]+$`}, false},
+		{"pass_numbers", map[string]any{"x": "123"}, map[string]any{"x": `not_regex:^[a-z]+$`}, false},
+		{"fail_match", map[string]any{"x": "abc"}, map[string]any{"x": `not_regex:^[a-z]+$`}, true},
+		{"fail_full_match", map[string]any{"x": "hello"}, map[string]any{"x": `not_regex:^hello$`}, true},
+		// Array syntax for not_regex with pipe
+		{"pass_not_regex_pipe_array", map[string]any{"x": "baz"}, map[string]any{"x": []string{"required", `not_regex:^(foo|bar)$`}}, false},
+		{"fail_not_regex_pipe_array", map[string]any{"x": "foo"}, map[string]any{"x": []string{"required", `not_regex:^(foo|bar)$`}}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestLowercase() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_lowercase", map[string]any{"x": "hello"}, map[string]any{"x": "lowercase"}, false},
+		{"pass_lowercase_with_numbers", map[string]any{"x": "hello123"}, map[string]any{"x": "lowercase"}, false},
+		{"pass_lowercase_with_spaces", map[string]any{"x": "hello world"}, map[string]any{"x": "lowercase"}, false},
+		{"pass_lowercase_with_symbols", map[string]any{"x": "hello@world!"}, map[string]any{"x": "lowercase"}, false},
+		{"fail_uppercase_first", map[string]any{"x": "Hello"}, map[string]any{"x": "lowercase"}, true},
+		{"fail_all_uppercase", map[string]any{"x": "HELLO"}, map[string]any{"x": "lowercase"}, true},
+		{"fail_mixed", map[string]any{"x": "hELLO"}, map[string]any{"x": "lowercase"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUppercase() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_uppercase", map[string]any{"x": "HELLO"}, map[string]any{"x": "uppercase"}, false},
+		{"pass_uppercase_with_numbers", map[string]any{"x": "HELLO123"}, map[string]any{"x": "uppercase"}, false},
+		{"pass_uppercase_with_spaces", map[string]any{"x": "HELLO WORLD"}, map[string]any{"x": "uppercase"}, false},
+		{"pass_uppercase_with_symbols", map[string]any{"x": "HELLO@WORLD!"}, map[string]any{"x": "uppercase"}, false},
+		{"fail_lowercase_first", map[string]any{"x": "hELLO"}, map[string]any{"x": "uppercase"}, true},
+		{"fail_all_lowercase", map[string]any{"x": "hello"}, map[string]any{"x": "uppercase"}, true},
+		{"fail_mixed", map[string]any{"x": "Hello"}, map[string]any{"x": "uppercase"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 8. String Content Rules =====
+
+func (s *RulesTestSuite) TestStartsWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_single", map[string]any{"x": "hello world"}, map[string]any{"x": "starts_with:hello"}, false},
+		{"pass_one_of", map[string]any{"x": "world hello"}, map[string]any{"x": "starts_with:hello,world"}, false},
+		{"pass_exact", map[string]any{"x": "hello"}, map[string]any{"x": "starts_with:hello"}, false},
+		{"fail_empty_prefix_no_params", map[string]any{"x": "anything"}, map[string]any{"x": "starts_with:"}, true},
+		{"fail_none", map[string]any{"x": "goodbye"}, map[string]any{"x": "starts_with:hello,world"}, true},
+		{"fail_case_sensitive", map[string]any{"x": "Hello"}, map[string]any{"x": "starts_with:hello"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDoesntStartWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_no_match", map[string]any{"x": "goodbye"}, map[string]any{"x": "doesnt_start_with:hello,world"}, false},
+		{"pass_different_case", map[string]any{"x": "Hello"}, map[string]any{"x": "doesnt_start_with:hello"}, false},
+		{"fail_match_first", map[string]any{"x": "hello world"}, map[string]any{"x": "doesnt_start_with:hello,world"}, true},
+		{"fail_match_second", map[string]any{"x": "world hello"}, map[string]any{"x": "doesnt_start_with:hello,world"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestEndsWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_single", map[string]any{"x": "hello world"}, map[string]any{"x": "ends_with:world"}, false},
+		{"pass_one_of", map[string]any{"x": "test.jpg"}, map[string]any{"x": "ends_with:.jpg,.png"}, false},
+		{"pass_exact", map[string]any{"x": "world"}, map[string]any{"x": "ends_with:world"}, false},
+		{"fail_none", map[string]any{"x": "test.gif"}, map[string]any{"x": "ends_with:.jpg,.png"}, true},
+		{"fail_case_sensitive", map[string]any{"x": "test.JPG"}, map[string]any{"x": "ends_with:.jpg"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDoesntEndWith() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_no_match", map[string]any{"x": "test.gif"}, map[string]any{"x": "doesnt_end_with:.jpg,.png"}, false},
+		{"pass_different_case", map[string]any{"x": "test.JPG"}, map[string]any{"x": "doesnt_end_with:.jpg"}, false},
+		{"fail_match_first", map[string]any{"x": "test.jpg"}, map[string]any{"x": "doesnt_end_with:.jpg,.png"}, true},
+		{"fail_match_second", map[string]any{"x": "test.png"}, map[string]any{"x": "doesnt_end_with:.jpg,.png"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestContains() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_contains", map[string]any{"x": "hello world"}, map[string]any{"x": "contains:world"}, false},
+		{"pass_contains_all", map[string]any{"x": "hello world foo"}, map[string]any{"x": "contains:hello,world"}, false},
+		{"pass_contains_single", map[string]any{"x": "abcdef"}, map[string]any{"x": "contains:cd"}, false},
+		{"fail_missing_one", map[string]any{"x": "hello foo"}, map[string]any{"x": "contains:hello,world"}, true},
+		{"fail_missing_all", map[string]any{"x": "goodbye"}, map[string]any{"x": "contains:hello,world"}, true},
+		{"fail_case_sensitive", map[string]any{"x": "Hello"}, map[string]any{"x": "contains:hello"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDoesntContain() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_no_match", map[string]any{"x": "hello world"}, map[string]any{"x": "doesnt_contain:foo,bar"}, false},
+		{"pass_case_different", map[string]any{"x": "Hello World"}, map[string]any{"x": "doesnt_contain:hello"}, false},
+		{"fail_match_one", map[string]any{"x": "hello world"}, map[string]any{"x": "doesnt_contain:hello,bar"}, true},
+		{"fail_match_multiple", map[string]any{"x": "hello world"}, map[string]any{"x": "doesnt_contain:hello,world"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestConfirmed() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_matching", map[string]any{"pw": "secret", "pw_confirmation": "secret"}, map[string]any{"pw": "confirmed"}, false},
+		{"pass_matching_number", map[string]any{"code": 123, "code_confirmation": 123}, map[string]any{"code": "confirmed"}, false},
+		{"fail_mismatch", map[string]any{"pw": "secret", "pw_confirmation": "diff"}, map[string]any{"pw": "confirmed"}, true},
+		{"fail_missing_confirmation", map[string]any{"pw": "secret"}, map[string]any{"pw": "confirmed"}, true},
+		{"fail_empty_confirmation", map[string]any{"pw": "secret", "pw_confirmation": ""}, map[string]any{"pw": "confirmed"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 9. Comparison Rules =====
+
+func (s *RulesTestSuite) TestSame() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_same_string", map[string]any{"a": "x", "b": "x"}, map[string]any{"a": "same:b"}, false},
+		{"pass_same_int", map[string]any{"a": 42, "b": 42}, map[string]any{"a": "same:b"}, false},
+		{"pass_same_bool", map[string]any{"a": true, "b": true}, map[string]any{"a": "same:b"}, false},
+		{"pass_string_int_same_via_sprintf", map[string]any{"a": "1", "b": 1}, map[string]any{"a": "same:b"}, false},
+		{"fail_different_value", map[string]any{"a": "x", "b": "y"}, map[string]any{"a": "same:b"}, true},
+		{"fail_missing_other", map[string]any{"a": "x"}, map[string]any{"a": "same:b"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDifferent() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_different_value", map[string]any{"a": "x", "b": "y"}, map[string]any{"a": "different:b"}, false},
+		{"pass_missing_other", map[string]any{"a": "x"}, map[string]any{"a": "different:b"}, false},
+		{"fail_string_int_same_via_sprintf", map[string]any{"a": "1", "b": 1}, map[string]any{"a": "different:b"}, true},
+		{"fail_same_string", map[string]any{"a": "x", "b": "x"}, map[string]any{"a": "different:b"}, true},
+		{"fail_same_int", map[string]any{"a": 42, "b": 42}, map[string]any{"a": "different:b"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestIn() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_in_list", map[string]any{"x": "a"}, map[string]any{"x": "in:a,b,c"}, false},
+		{"pass_last_in_list", map[string]any{"x": "c"}, map[string]any{"x": "in:a,b,c"}, false},
+		{"pass_int_as_string", map[string]any{"x": 1}, map[string]any{"x": "in:1,2,3"}, false},
+		{"pass_single_value", map[string]any{"x": "yes"}, map[string]any{"x": "in:yes"}, false},
+		{"pass_empty_skipped", map[string]any{"x": ""}, map[string]any{"x": "in:a,b,c"}, false},
+		{"pass_numeric_string_in_list", map[string]any{"status": "1"}, map[string]any{"status": "in:1,2,3"}, false},
+		{"pass_integer_in_string_list", map[string]any{"status": 1}, map[string]any{"status": "in:1,2,3"}, false},
+		{"pass_single_only", map[string]any{"x": "only"}, map[string]any{"x": "in:only"}, false},
+		{"fail_not_in_list", map[string]any{"x": "d"}, map[string]any{"x": "in:a,b,c"}, true},
+		{"fail_case_sensitive", map[string]any{"x": "A"}, map[string]any{"x": "in:a,b,c"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestNotIn() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_not_in_list", map[string]any{"x": "d"}, map[string]any{"x": "not_in:a,b,c"}, false},
+		{"pass_case_different", map[string]any{"x": "A"}, map[string]any{"x": "not_in:a,b,c"}, false},
+		{"pass_empty", map[string]any{"x": ""}, map[string]any{"x": "not_in:a,b,c"}, false},
+		{"fail_in_list", map[string]any{"x": "a"}, map[string]any{"x": "not_in:a,b,c"}, true},
+		{"fail_last_in_list", map[string]any{"x": "c"}, map[string]any{"x": "not_in:a,b,c"}, true},
+		{"pass_pending_not_banned", map[string]any{"status": "pending"}, map[string]any{"status": "not_in:banned,deleted"}, false},
+		{"fail_integer_match", map[string]any{"id": 0}, map[string]any{"id": "not_in:0,999"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestInArray() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_in_array", map[string]any{"x": "a", "arr": []any{"a", "b", "c"}}, map[string]any{"x": "in_array:arr"}, false},
+		{"fail_not_in_array", map[string]any{"x": "d", "arr": []any{"a", "b", "c"}}, map[string]any{"x": "in_array:arr"}, true},
+		{"fail_array_missing", map[string]any{"x": "a"}, map[string]any{"x": "in_array:arr"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestInArrayKeys() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_has_key", map[string]any{"x": map[string]any{"a": 1, "b": 2}}, map[string]any{"x": "in_array_keys:a,c"}, false},
+		{"fail_no_key", map[string]any{"x": map[string]any{"d": 1}}, map[string]any{"x": "in_array_keys:a,b"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 10. Date Rules =====
+
+func (s *RulesTestSuite) TestDate() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_date_only", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "date"}, false},
+		{"pass_datetime_space", map[string]any{"x": "2024-01-15 10:30:00"}, map[string]any{"x": "date"}, false},
+		{"pass_rfc3339", map[string]any{"x": "2024-01-15T10:30:00Z"}, map[string]any{"x": "date"}, false},
+		{"pass_rfc3339_offset", map[string]any{"x": "2024-01-15T10:30:00+08:00"}, map[string]any{"x": "date"}, false},
+		{"pass_datetime_t", map[string]any{"x": "2024-01-15T10:30:00"}, map[string]any{"x": "date"}, false},
+		{"pass_empty_skipped", map[string]any{"x": ""}, map[string]any{"x": "date"}, false},
+		{"fail_invalid", map[string]any{"x": "not-a-date"}, map[string]any{"x": "date"}, true},
+		{"fail_numbers_only", map[string]any{"x": "20240115"}, map[string]any{"x": "date"}, true},
+		{"fail_partial_date", map[string]any{"x": "2024-01"}, map[string]any{"x": "date"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDateFormat() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_date_format", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "date_format:2006-01-02"}, false},
+		{"pass_datetime_format", map[string]any{"x": "2024-01-15 10:30:00"}, map[string]any{"x": "date_format:2006-01-02 15:04:05"}, false},
+		{"pass_custom_format", map[string]any{"x": "15/01/2024"}, map[string]any{"x": "date_format:02/01/2006"}, false},
+		{"pass_time_only", map[string]any{"x": "10:30:00"}, map[string]any{"x": "date_format:15:04:05"}, false},
+		{"fail_wrong_format", map[string]any{"x": "15/01/2024"}, map[string]any{"x": "date_format:2006-01-02"}, true},
+		{"fail_invalid_date", map[string]any{"x": "not-a-date"}, map[string]any{"x": "date_format:2006-01-02"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDateEquals() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_equal", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "date_equals:2024-01-15"}, false},
+		{"pass_equal_datetime", map[string]any{"x": "2024-01-15T10:30:00Z"}, map[string]any{"x": "date_equals:2024-01-15T10:30:00Z"}, false},
+		{"fail_not_equal", map[string]any{"x": "2024-01-16"}, map[string]any{"x": "date_equals:2024-01-15"}, true},
+		{"fail_invalid_date", map[string]any{"x": "not-a-date"}, map[string]any{"x": "date_equals:2024-01-15"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestBefore() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_before", map[string]any{"x": "2024-01-14"}, map[string]any{"x": "before:2024-01-15"}, false},
+		{"fail_after", map[string]any{"x": "2024-01-16"}, map[string]any{"x": "before:2024-01-15"}, true},
+		{"fail_equal", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "before:2024-01-15"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestBeforeOrEqual() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_before", map[string]any{"x": "2024-01-14"}, map[string]any{"x": "before_or_equal:2024-01-15"}, false},
+		{"pass_equal", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "before_or_equal:2024-01-15"}, false},
+		{"fail_after", map[string]any{"x": "2024-01-16"}, map[string]any{"x": "before_or_equal:2024-01-15"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAfter() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_after", map[string]any{"x": "2024-01-16"}, map[string]any{"x": "after:2024-01-15"}, false},
+		{"fail_before", map[string]any{"x": "2024-01-14"}, map[string]any{"x": "after:2024-01-15"}, true},
+		{"fail_equal", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "after:2024-01-15"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestAfterOrEqual() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_after", map[string]any{"x": "2024-01-16"}, map[string]any{"x": "after_or_equal:2024-01-15"}, false},
+		{"pass_equal", map[string]any{"x": "2024-01-15"}, map[string]any{"x": "after_or_equal:2024-01-15"}, false},
+		{"fail_before", map[string]any{"x": "2024-01-14"}, map[string]any{"x": "after_or_equal:2024-01-15"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestTimezone() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_utc", map[string]any{"x": "UTC"}, map[string]any{"x": "timezone"}, false},
+		{"pass_named", map[string]any{"x": "America/New_York"}, map[string]any{"x": "timezone"}, false},
+		{"pass_asia", map[string]any{"x": "Asia/Shanghai"}, map[string]any{"x": "timezone"}, false},
+		{"pass_europe", map[string]any{"x": "Europe/London"}, map[string]any{"x": "timezone"}, false},
+		{"pass_local", map[string]any{"x": "Local"}, map[string]any{"x": "timezone"}, false},
+		{"pass_empty_skipped", map[string]any{"x": ""}, map[string]any{"x": "timezone"}, false},
+		{"pass_abbreviation_est", map[string]any{"x": "EST"}, map[string]any{"x": "timezone"}, false},
+		{"fail_invalid", map[string]any{"x": "Not/A/Timezone"}, map[string]any{"x": "timezone"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestDateWithFieldReference() {
+	s.Run("before_field_reference", func() {
+		v := s.makeValidator(
+			map[string]any{"start": "2024-01-10", "end": "2024-01-15"},
+			map[string]any{"start": "before:end"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("after_field_reference", func() {
+		v := s.makeValidator(
+			map[string]any{"start": "2024-01-10", "end": "2024-01-15"},
+			map[string]any{"end": "after:start"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+// ===== 11. Exclude Rules =====
+
+func (s *RulesTestSuite) TestExclude() {
+	s.Run("excluded_from_validated", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go", "secret": "hidden"},
+			map[string]any{"name": "required", "secret": "exclude"},
+		)
+		s.False(v.Fails())
+		_, exists := v.Validated()["secret"]
+		s.False(exists)
+		s.Equal("go", v.Validated()["name"])
+	})
+}
+
+func (s *RulesTestSuite) TestExcludeIf() {
+	s.Run("excluded_when_condition_met", func() {
+		v := s.makeValidator(
+			map[string]any{"type": "free", "cc": "1234"},
+			map[string]any{"type": "required", "cc": "exclude_if:type,free"},
+		)
+		s.False(v.Fails())
+		_, exists := v.Validated()["cc"]
+		s.False(exists)
+	})
+
+	s.Run("not_excluded_when_condition_not_met", func() {
+		v := s.makeValidator(
+			map[string]any{"type": "paid", "cc": "1234"},
+			map[string]any{"type": "required", "cc": "exclude_if:type,free"},
+		)
+		s.False(v.Fails())
+		s.Equal("1234", v.Validated()["cc"])
+	})
+}
+
+func (s *RulesTestSuite) TestExcludeUnless() {
+	s.Run("excluded_when_condition_not_met", func() {
+		v := s.makeValidator(
+			map[string]any{"role": "user", "admin_note": "note"},
+			map[string]any{"role": "required", "admin_note": "exclude_unless:role,admin"},
+		)
+		s.False(v.Fails())
+		_, exists := v.Validated()["admin_note"]
+		s.False(exists)
+	})
+
+	s.Run("not_excluded_when_condition_met", func() {
+		v := s.makeValidator(
+			map[string]any{"role": "admin", "admin_note": "note"},
+			map[string]any{"role": "required", "admin_note": "exclude_unless:role,admin"},
+		)
+		s.False(v.Fails())
+		s.Equal("note", v.Validated()["admin_note"])
+	})
+}
+
+func (s *RulesTestSuite) TestExcludeWith() {
+	s.Run("excluded_when_other_present", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "a@b.com", "phone": "123"},
+			map[string]any{"email": "required", "phone": "exclude_with:email"},
+		)
+		s.False(v.Fails())
+		_, exists := v.Validated()["phone"]
+		s.False(exists)
+	})
+}
+
+func (s *RulesTestSuite) TestExcludeWithout() {
+	s.Run("excluded_when_other_absent", func() {
+		v := s.makeValidator(
+			map[string]any{"phone": "123"},
+			map[string]any{"phone": "required", "note": "exclude_without:email"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+// ===== 12. File Rules =====
+
+func (s *RulesTestSuite) TestFile() {
+	fh := &multipart.FileHeader{Filename: "test.txt", Size: 100}
+	fh2 := &multipart.FileHeader{Filename: "test2.txt", Size: 200}
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_file", map[string]any{"x": fh}, map[string]any{"x": "file"}, false},
+		{"pass_multiple_files", map[string]any{"x": []*multipart.FileHeader{fh, fh2}}, map[string]any{"x": "file"}, false},
+		{"fail_string", map[string]any{"x": "not-a-file"}, map[string]any{"x": "file"}, true},
+		{"fail_empty_slice", map[string]any{"x": []*multipart.FileHeader{}}, map[string]any{"x": "file"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestImage() {
+	// JPEG: minimal valid JFIF
+	jpegData := []byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00}
+	// PNG: minimal valid PNG header
+	pngData := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
+	// PDF: minimal PDF header
+	pdfData := []byte{0x25, 0x50, 0x44, 0x46, 0x2D}
+
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_jpeg", map[string]any{"x": makeFileHeader(s.T(), "img.jpg", jpegData)}, map[string]any{"x": "image"}, false},
+		{"pass_png", map[string]any{"x": makeFileHeader(s.T(), "img.png", pngData)}, map[string]any{"x": "image"}, false},
+		{"pass_multiple_images", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.jpg", jpegData),
+			makeFileHeader(s.T(), "b.png", pngData),
+		}}, map[string]any{"x": "image"}, false},
+		{"fail_pdf", map[string]any{"x": makeFileHeader(s.T(), "doc.pdf", pdfData)}, map[string]any{"x": "image"}, true},
+		{"fail_multiple_one_not_image", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.jpg", jpegData),
+			makeFileHeader(s.T(), "doc.pdf", pdfData),
+		}}, map[string]any{"x": "image"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMimes() {
+	pngData := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
+	gifData := []byte{0x47, 0x49, 0x46, 0x38, 0x39, 0x61}
+	jpegData := []byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00}
+
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_png", map[string]any{"x": makeFileHeader(s.T(), "photo.png", pngData)}, map[string]any{"x": "mimes:png,jpg"}, false},
+		{"pass_multiple_pngs", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.png", pngData),
+			makeFileHeader(s.T(), "b.png", pngData),
+		}}, map[string]any{"x": "mimes:png"}, false},
+		{"fail_gif", map[string]any{"x": makeFileHeader(s.T(), "photo.gif", gifData)}, map[string]any{"x": "mimes:jpg,png"}, true},
+		{"fail_multiple_one_mismatch", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.png", pngData),
+			makeFileHeader(s.T(), "b.jpg", jpegData),
+		}}, map[string]any{"x": "mimes:png"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMimetypes() {
+	pngData := []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A}
+	pdfData := []byte{0x25, 0x50, 0x44, 0x46, 0x2D}
+	jpegData := []byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00}
+
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_match", map[string]any{"x": makeFileHeader(s.T(), "img.png", pngData)}, map[string]any{"x": "mimetypes:image/png,image/jpeg"}, false},
+		{"pass_multiple_match", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.png", pngData),
+			makeFileHeader(s.T(), "b.jpg", jpegData),
+		}}, map[string]any{"x": "mimetypes:image/png,image/jpeg"}, false},
+		{"fail_no_match", map[string]any{"x": makeFileHeader(s.T(), "doc.pdf", pdfData)}, map[string]any{"x": "mimetypes:image/png,image/jpeg"}, true},
+		{"fail_multiple_one_mismatch", map[string]any{"x": []*multipart.FileHeader{
+			makeFileHeader(s.T(), "a.png", pngData),
+			makeFileHeader(s.T(), "doc.pdf", pdfData),
+		}}, map[string]any{"x": "mimetypes:image/png,image/jpeg"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestExtensions() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_match", map[string]any{"x": &multipart.FileHeader{Filename: "doc.pdf"}}, map[string]any{"x": "extensions:pdf,docx"}, false},
+		{"pass_multiple_match", map[string]any{"x": []*multipart.FileHeader{
+			{Filename: "a.pdf"},
+			{Filename: "b.docx"},
+		}}, map[string]any{"x": "extensions:pdf,docx"}, false},
+		{"fail_no_match", map[string]any{"x": &multipart.FileHeader{Filename: "doc.txt"}}, map[string]any{"x": "extensions:pdf,docx"}, true},
+		{"fail_multiple_one_mismatch", map[string]any{"x": []*multipart.FileHeader{
+			{Filename: "a.pdf"},
+			{Filename: "b.txt"},
+		}}, map[string]any{"x": "extensions:pdf,docx"}, true},
+		{"fail_empty_slice", map[string]any{"x": []*multipart.FileHeader{}}, map[string]any{"x": "extensions:pdf"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 13. Control Rules =====
+
+func (s *RulesTestSuite) TestBail() {
+	s.Run("stops_on_first_error", func() {
+		v := s.makeValidator(
+			map[string]any{"email": ""},
+			map[string]any{"email": "bail|required|email"},
+		)
+		s.True(v.Fails())
+		errs := v.Errors().Get("email")
+		s.Len(errs, 1)
+	})
+
+	s.Run("reports_all_errors_without_bail", func() {
+		v := s.makeValidator(
+			map[string]any{"x": ""},
+			map[string]any{"x": "required|email"},
+		)
+		s.True(v.Fails())
+		// Without bail, required is an implicit rule failure that triggers
+		errs := v.Errors().Get("x")
+		s.GreaterOrEqual(len(errs), 1)
+	})
+
+	s.Run("passes_when_valid_with_bail", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "user@example.com"},
+			map[string]any{"email": "bail|required|email"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+func (s *RulesTestSuite) TestNullable() {
+	s.Run("allows_nil", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go"},
+			map[string]any{"name": "required", "email": "nullable|email"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("validates_when_present", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "bad"},
+			map[string]any{"email": "nullable|email"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("allows_nil_value", func() {
+		v := s.makeValidator(
+			map[string]any{"name": nil},
+			map[string]any{"name": "nullable|string"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("passes_with_valid_value", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "hello"},
+			map[string]any{"name": "nullable|string|min:3"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+func (s *RulesTestSuite) TestSometimes() {
+	s.Run("skips_when_absent", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go"},
+			map[string]any{"name": "required", "email": "sometimes|required|email"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("validates_when_present", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go", "email": "bad"},
+			map[string]any{"name": "required", "email": "sometimes|required|email"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("passes_when_present_and_valid", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go", "email": "user@example.com"},
+			map[string]any{"name": "required", "email": "sometimes|required|email"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+// ===== 14. Other Rules =====
+
+func (s *RulesTestSuite) TestRequiredArrayKeys() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_all_keys", map[string]any{"x": map[string]any{"a": 1, "b": 2}}, map[string]any{"x": "required_array_keys:a,b"}, false},
+		{"fail_missing_key", map[string]any{"x": map[string]any{"a": 1}}, map[string]any{"x": "required_array_keys:a,b"}, true},
+		{"fail_not_map", map[string]any{"x": "hello"}, map[string]any{"x": "required_array_keys:a"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestEncoding() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_utf8", map[string]any{"x": "hello"}, map[string]any{"x": "encoding:utf-8"}, false},
+		{"pass_ascii_encoding", map[string]any{"x": "hello"}, map[string]any{"x": "encoding:ascii"}, false},
+		{"fail_non_ascii", map[string]any{"x": "héllo"}, map[string]any{"x": "encoding:ascii"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== 15. Engine Feature Tests =====
+
+func (s *RulesTestSuite) TestWildcardExpansion() {
+	s.Run("validates_all_items", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{
+				map[string]any{"name": "a"},
+				map[string]any{"name": ""},
+			}},
+			map[string]any{"items.*.name": "required"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("all_valid", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{
+				map[string]any{"name": "a"},
+				map[string]any{"name": "b"},
+			}},
+			map[string]any{"items.*.name": "required|string"},
+		)
+		s.False(v.Fails())
+	})
+}
+
+func (s *RulesTestSuite) TestNestedDotNotation() {
+	s.Run("nested_access", func() {
+		v := s.makeValidator(
+			map[string]any{"user": map[string]any{"profile": map[string]any{"name": "Go"}}},
+			map[string]any{"user.profile.name": "required|string|min:2"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("nested_missing", func() {
+		v := s.makeValidator(
+			map[string]any{"user": map[string]any{"profile": map[string]any{}}},
+			map[string]any{"user.profile.name": "required"},
+		)
+		s.True(v.Fails())
+	})
+}
+
+func (s *RulesTestSuite) TestCustomMessages() {
+	s.Run("field_rule_message", func() {
+		v := s.makeValidator(
+			map[string]any{"name": ""},
+			map[string]any{"name": "required"},
+			Messages(map[string]string{"name.required": "Name is mandatory."}),
+		)
+		s.True(v.Fails())
+		s.Equal("Name is mandatory.", v.Errors().One("name"))
+	})
+}
+
+func (s *RulesTestSuite) TestCustomAttributes() {
+	s.Run("attribute_replacement", func() {
+		v := s.makeValidator(
+			map[string]any{"email_address": ""},
+			map[string]any{"email_address": "required"},
+			Attributes(map[string]string{"email_address": "Email"}),
+		)
+		s.True(v.Fails())
+		s.Equal("The Email field is required.", v.Errors().One("email_address"))
+	})
+}
+
+func (s *RulesTestSuite) TestValidatedOnlyReturnsRuledFields() {
+	s.Run("excludes_extra_fields", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go", "email": "a@b.com", "extra": "x"},
+			map[string]any{"name": "required", "email": "required|email"},
+		)
+		s.False(v.Fails())
+		validated := v.Validated()
+		s.Equal("go", validated["name"])
+		s.Equal("a@b.com", validated["email"])
+		_, exists := validated["extra"]
+		s.False(exists)
+	})
+}
+
+func (s *RulesTestSuite) TestMultiRuleCombination() {
+	s.Run("all_pass", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "goravel"},
+			map[string]any{"name": "required|string|min:3|max:50"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("min_fails", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go"},
+			map[string]any{"name": "required|string|min:3|max:50"},
+		)
+		s.True(v.Fails())
+		errs := v.Errors().Get("name")
+		s.Contains(errs, "min")
+	})
+
+	s.Run("required_string_email_min", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "a@b.com"},
+			map[string]any{"email": "required|string|email|min:5"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("required_string_email_min_fail_too_short", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "a@b"},
+			map[string]any{"email": "required|string|email|min:5"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("required_integer_between", func() {
+		v := s.makeValidator(
+			map[string]any{"age": 25},
+			map[string]any{"age": "required|integer|between:18,100"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("required_integer_between_fail_too_young", func() {
+		v := s.makeValidator(
+			map[string]any{"age": 10},
+			map[string]any{"age": "required|integer|between:18,100"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("nullable_string_email", func() {
+		v := s.makeValidator(
+			map[string]any{"email": nil},
+			map[string]any{"email": "nullable|string|email"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("sometimes_required_string", func() {
+		v := s.makeValidator(
+			map[string]any{},
+			map[string]any{"nickname": "sometimes|required|string"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("sometimes_required_string_present_empty", func() {
+		v := s.makeValidator(
+			map[string]any{"nickname": ""},
+			map[string]any{"nickname": "sometimes|required|string"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("array_min_max_combination", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{1, 2, 3}},
+			map[string]any{"items": "required|array|min:1|max:5"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("string_alpha_dash_max", func() {
+		v := s.makeValidator(
+			map[string]any{"slug": "my-post_123"},
+			map[string]any{"slug": "required|string|alpha_dash|max:50"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("numeric_multiple_of_between", func() {
+		v := s.makeValidator(
+			map[string]any{"qty": 15},
+			map[string]any{"qty": "required|numeric|multiple_of:5|between:5,50"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("multiple_fields_all_pass", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"name":  "goravel",
+				"email": "go@example.com",
+				"age":   25,
+				"role":  "admin",
+			},
+			map[string]any{
+				"name":  "required|string|min:3|max:50",
+				"email": "required|email",
+				"age":   "required|integer|between:18,100",
+				"role":  "required|in:admin,user,guest",
+			},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("multiple_fields_some_fail", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"name":  "go",
+				"email": "bad",
+				"age":   200,
+				"role":  "superadmin",
+			},
+			map[string]any{
+				"name":  "required|string|min:3|max:50",
+				"email": "required|email",
+				"age":   "required|integer|between:18,100",
+				"role":  "required|in:admin,user,guest",
+			},
+		)
+		s.True(v.Fails())
+		errs := v.Errors().All()
+		s.Contains(errs, "name")
+		s.Contains(errs, "email")
+		s.Contains(errs, "age")
+		s.Contains(errs, "role")
+	})
+}
+
+func (s *RulesTestSuite) TestDistinct() {
+	s.Run("pass_distinct_values", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{"a", "b", "c"}},
+			map[string]any{"items.*": "distinct"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("fail_duplicate_values", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{"a", "b", "a"}},
+			map[string]any{"items.*": "distinct"},
+		)
+		s.True(v.Fails())
+	})
+}
+
+// ===== Error Message Tests =====
+
+func (s *RulesTestSuite) TestErrorMessages() {
+	s.Run("required_message", func() {
+		v := s.makeValidator(
+			map[string]any{"name": ""},
+			map[string]any{"name": "required"},
+		)
+		s.True(v.Fails())
+		s.Equal("The name field is required.", v.Errors().One("name"))
+	})
+
+	s.Run("min_string_message", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "ab"},
+			map[string]any{"name": "string|min:3"},
+		)
+		s.True(v.Fails())
+		s.Equal("The name field must be at least 3 characters.", v.Errors().One("name"))
+	})
+
+	s.Run("max_numeric_message", func() {
+		v := s.makeValidator(
+			map[string]any{"age": 200},
+			map[string]any{"age": "numeric|max:150"},
+		)
+		s.True(v.Fails())
+		s.Equal("The age field must not be greater than 150.", v.Errors().One("age"))
+	})
+
+	s.Run("between_string_message", func() {
+		v := s.makeValidator(
+			map[string]any{"x": "ab"},
+			map[string]any{"x": "string|between:3,5"},
+		)
+		s.True(v.Fails())
+		s.Equal("The x field must be between 3 and 5 characters.", v.Errors().One("x"))
+	})
+
+	s.Run("in_message", func() {
+		v := s.makeValidator(
+			map[string]any{"status": "bad"},
+			map[string]any{"status": "in:active,inactive"},
+		)
+		s.True(v.Fails())
+		s.Equal("The selected status is invalid.", v.Errors().One("status"))
+	})
+
+	s.Run("email_message", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "bad"},
+			map[string]any{"email": "email"},
+		)
+		s.True(v.Fails())
+		s.Equal("The email field must be a valid email address.", v.Errors().One("email"))
+	})
+
+	s.Run("confirmed_message", func() {
+		v := s.makeValidator(
+			map[string]any{"pw": "a", "pw_confirmation": "b"},
+			map[string]any{"pw": "confirmed"},
+		)
+		s.True(v.Fails())
+		s.Equal("The pw field confirmation does not match.", v.Errors().One("pw"))
+	})
+
+	s.Run("same_message", func() {
+		v := s.makeValidator(
+			map[string]any{"a": "x", "b": "y"},
+			map[string]any{"a": "same:b"},
+		)
+		s.True(v.Fails())
+		s.Equal("The a field must match b.", v.Errors().One("a"))
+	})
+
+	s.Run("size_array_message", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{1, 2}},
+			map[string]any{"items": "array|size:3"},
+		)
+		s.True(v.Fails())
+		s.Equal("The items field must contain 3 items.", v.Errors().One("items"))
+	})
+
+	s.Run("uuid_message", func() {
+		v := s.makeValidator(
+			map[string]any{"id": "bad"},
+			map[string]any{"id": "uuid"},
+		)
+		s.True(v.Fails())
+		s.Equal("The id field must be a valid UUID.", v.Errors().One("id"))
+	})
+
+	s.Run("underscore_to_space_in_attribute", func() {
+		v := s.makeValidator(
+			map[string]any{"first_name": ""},
+			map[string]any{"first_name": "required"},
+		)
+		s.True(v.Fails())
+		s.Equal("The first name field is required.", v.Errors().One("first_name"))
+	})
+
+	s.Run("custom_message_for_specific_field_rule", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "bad"},
+			map[string]any{"email": "email"},
+			Messages(map[string]string{"email.email": "Please enter a valid email"}),
+		)
+		s.True(v.Fails())
+		s.Equal("Please enter a valid email", v.Errors().One("email"))
+	})
+
+	s.Run("custom_message_for_rule_only", func() {
+		v := s.makeValidator(
+			map[string]any{"email": "bad"},
+			map[string]any{"email": "email"},
+			Messages(map[string]string{"email": "Invalid email format"}),
+		)
+		s.True(v.Fails())
+		s.Equal("Invalid email format", v.Errors().One("email"))
+	})
+
+	s.Run("custom_attribute_name", func() {
+		v := s.makeValidator(
+			map[string]any{"email_addr": ""},
+			map[string]any{"email_addr": "required"},
+			Attributes(map[string]string{"email_addr": "email address"}),
+		)
+		s.True(v.Fails())
+		s.Equal("The email address field is required.", v.Errors().One("email_addr"))
+	})
+
+	s.Run("custom_message_with_attribute_placeholder", func() {
+		v := s.makeValidator(
+			map[string]any{"user_name": ""},
+			map[string]any{"user_name": "required"},
+			Messages(map[string]string{"user_name.required": ":attribute is mandatory"}),
+			Attributes(map[string]string{"user_name": "Username"}),
+		)
+		s.True(v.Fails())
+		s.Equal("Username is mandatory", v.Errors().One("user_name"))
+	})
+
+	s.Run("min_numeric_message", func() {
+		v := s.makeValidator(
+			map[string]any{"price": 5},
+			map[string]any{"price": "numeric|min:10"},
+		)
+		s.True(v.Fails())
+		s.Equal("The price field must be at least 10.", v.Errors().One("price"))
+	})
+
+	s.Run("max_array_message", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{1, 2, 3, 4, 5}},
+			map[string]any{"items": "array|max:3"},
+		)
+		s.True(v.Fails())
+		s.Equal("The items field must not have more than 3 items.", v.Errors().One("items"))
+	})
+
+	s.Run("between_numeric_message", func() {
+		v := s.makeValidator(
+			map[string]any{"score": 100},
+			map[string]any{"score": "numeric|between:1,10"},
+		)
+		s.True(v.Fails())
+		s.Equal("The score field must be between 1 and 10.", v.Errors().One("score"))
+	})
+
+	s.Run("digits_message", func() {
+		v := s.makeValidator(
+			map[string]any{"pin": "12"},
+			map[string]any{"pin": "digits:4"},
+		)
+		s.True(v.Fails())
+		s.Equal("The pin field must be 4 digits.", v.Errors().One("pin"))
+	})
+
+	s.Run("required_if_message", func() {
+		v := s.makeValidator(
+			map[string]any{"type": "admin"},
+			map[string]any{"role": "required_if:type,admin"},
+		)
+		s.True(v.Fails())
+		s.Equal("The role field is required when type is admin.", v.Errors().One("role"))
+	})
+
+	s.Run("prohibited_if_message", func() {
+		v := s.makeValidator(
+			map[string]any{"role": "guest", "token": "abc"},
+			map[string]any{"token": "prohibited_if:role,guest"},
+		)
+		s.True(v.Fails())
+		s.Equal("The token field is prohibited when role is guest.", v.Errors().One("token"))
+	})
+
+	s.Run("starts_with_message", func() {
+		v := s.makeValidator(
+			map[string]any{"code": "xyz_bad"},
+			map[string]any{"code": "starts_with:abc_,def_"},
+		)
+		s.True(v.Fails())
+		s.Contains(v.Errors().One("code"), "must start with one of the following")
+	})
+
+	s.Run("date_before_message", func() {
+		v := s.makeValidator(
+			map[string]any{"d": "2030-01-01"},
+			map[string]any{"d": "before:2025-01-01"},
+		)
+		s.True(v.Fails())
+		s.Equal("The d field must be a date before 2025-01-01.", v.Errors().One("d"))
+	})
+
+	s.Run("min_array_message", func() {
+		v := s.makeValidator(
+			map[string]any{"items": []any{1}},
+			map[string]any{"items": "array|min:3"},
+		)
+		s.True(v.Fails())
+		s.Equal("The items field must have at least 3 items.", v.Errors().One("items"))
+	})
+
+	s.Run("size_numeric_message", func() {
+		v := s.makeValidator(
+			map[string]any{"qty": 5},
+			map[string]any{"qty": "numeric|size:10"},
+		)
+		s.True(v.Fails())
+		s.Equal("The qty field must be 10.", v.Errors().One("qty"))
+	})
+
+	s.Run("multiple_of_message", func() {
+		v := s.makeValidator(
+			map[string]any{"n": 7},
+			map[string]any{"n": "multiple_of:3"},
+		)
+		s.True(v.Fails())
+		s.Equal("The n field must be a multiple of 3.", v.Errors().One("n"))
+	})
+}
+
+// ===== Rule Alias Tests =====
+
+func (s *RulesTestSuite) TestIntAlias() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_int_alias", map[string]any{"n": 42}, map[string]any{"n": "int"}, false},
+		{"pass_string_int_alias", map[string]any{"n": "42"}, map[string]any{"n": "int"}, false},
+		{"fail_float_int_alias", map[string]any{"n": 3.14}, map[string]any{"n": "int"}, true},
+		{"fail_string_int_alias", map[string]any{"n": "abc"}, map[string]any{"n": "int"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestBoolAlias() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_bool_alias_true", map[string]any{"ok": true}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_false", map[string]any{"ok": false}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_1", map[string]any{"ok": 1}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_0", map[string]any{"ok": 0}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_true", map[string]any{"ok": "true"}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_false", map[string]any{"ok": "false"}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_on", map[string]any{"ok": "on"}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_off", map[string]any{"ok": "off"}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_yes", map[string]any{"ok": "yes"}, map[string]any{"ok": "bool"}, false},
+		{"pass_bool_alias_string_no", map[string]any{"ok": "no"}, map[string]any{"ok": "bool"}, false},
+		{"fail_bool_alias_string", map[string]any{"ok": "abc"}, map[string]any{"ok": "bool"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestSliceAlias() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_slice_alias", map[string]any{"items": []any{1, 2}}, map[string]any{"items": "slice"}, false},
+		{"fail_slice_alias_map", map[string]any{"items": map[string]any{"a": 1}}, map[string]any{"items": "slice"}, true},
+		{"fail_slice_alias_string", map[string]any{"items": "abc"}, map[string]any{"items": "slice"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestMacAlias() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_mac_alias", map[string]any{"mac": "00:1A:2B:3C:4D:5E"}, map[string]any{"mac": "mac"}, false},
+		{"fail_mac_alias", map[string]any{"mac": "invalid"}, map[string]any{"mac": "mac"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== Active URL Tests =====
+
+func (s *RulesTestSuite) TestActiveUrl() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_google", map[string]any{"u": "https://google.com"}, map[string]any{"u": "active_url"}, false},
+		{"fail_non_string", map[string]any{"u": 123}, map[string]any{"u": "active_url"}, true},
+		{"fail_no_host", map[string]any{"u": "not-a-url"}, map[string]any{"u": "active_url"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+// ===== Array Syntax ([]string) Tests =====
+
+func (s *RulesTestSuite) TestArraySyntaxBasic() {
+	s.Run("string_and_array_syntax_equivalent", func() {
+		data := map[string]any{"name": "goravel", "age": 18}
+		v1 := s.makeValidator(data, map[string]any{
+			"name": "required|string|min:3",
+			"age":  "required|integer",
+		})
+		v2 := s.makeValidator(data, map[string]any{
+			"name": []string{"required", "string", "min:3"},
+			"age":  []string{"required", "integer"},
+		})
+		s.Equal(v1.Fails(), v2.Fails())
+	})
+
+	s.Run("array_syntax_regex_with_pipe", func() {
+		v := s.makeValidator(
+			map[string]any{"code": "foo"},
+			map[string]any{"code": []string{"required", "regex:^(foo|bar)$"}},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("array_syntax_regex_with_pipe_fail", func() {
+		v := s.makeValidator(
+			map[string]any{"code": "baz"},
+			map[string]any{"code": []string{"required", "regex:^(foo|bar)$"}},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("array_syntax_regex_followed_by_more_rules", func() {
+		v := s.makeValidator(
+			map[string]any{"code": "foo"},
+			map[string]any{"code": []string{"required", "regex:^(foo|bar)$", "string", "min:2"}},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("array_syntax_not_regex_with_pipe", func() {
+		v := s.makeValidator(
+			map[string]any{"code": "baz"},
+			map[string]any{"code": []string{"required", "not_regex:^(foo|bar)$"}},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("array_syntax_mixed_string_and_array", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "goravel", "code": "foo"},
+			map[string]any{
+				"name": "required|string",
+				"code": []string{"required", "regex:^(foo|bar)$"},
+			},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("array_syntax_multiple_rules_fail", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "ab"},
+			map[string]any{"name": []string{"required", "string", "min:5", "max:10"}},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("array_syntax_with_bail", func() {
+		v := s.makeValidator(
+			map[string]any{"email": ""},
+			map[string]any{"email": []string{"bail", "required", "email"}},
+		)
+		s.True(v.Fails())
+		// With bail, should only have the required error
+		errs := v.Errors().Get("email")
+		s.Equal(1, len(errs))
+	})
+
+	s.Run("array_syntax_empty_strings_ignored", func() {
+		v := s.makeValidator(
+			map[string]any{"x": "hello"},
+			map[string]any{"x": []string{"", "required", "", "string"}},
+		)
+		s.False(v.Fails())
+	})
+}
+
+// ===== Validated Data Tests =====
+
+func (s *RulesTestSuite) TestValidatedDataExcludesUnruledFields() {
+	v := s.makeValidator(
+		map[string]any{"name": "go", "age": 25, "extra": "ignored"},
+		map[string]any{"name": "required", "age": "required|integer"},
+	)
+	s.False(v.Fails())
+	data := v.Validated()
+	s.Equal(map[string]any{"name": "go", "age": 25}, data)
+	_, hasExtra := data["extra"]
+	s.False(hasExtra)
+}
+
+func (s *RulesTestSuite) TestValidatedDataWithExclusion() {
+	s.Run("exclude_removes_field", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go", "secret": "hidden"},
+			map[string]any{"name": "required", "secret": "exclude"},
+		)
+		s.False(v.Fails())
+		data := v.Validated()
+		_, hasSecret := data["secret"]
+		s.False(hasSecret)
+		s.Equal("go", data["name"])
+	})
+
+	s.Run("exclude_if_conditional", func() {
+		v := s.makeValidator(
+			map[string]any{"role": "admin", "token": "abc"},
+			map[string]any{"role": "required", "token": "exclude_if:role,admin"},
+		)
+		s.False(v.Fails())
+		data := v.Validated()
+		_, hasToken := data["token"]
+		s.False(hasToken)
+	})
+
+	s.Run("exclude_if_not_triggered", func() {
+		v := s.makeValidator(
+			map[string]any{"role": "user", "token": "abc"},
+			map[string]any{"role": "required", "token": "exclude_if:role,admin"},
+		)
+		s.False(v.Fails())
+		data := v.Validated()
+		s.Equal("abc", data["token"])
+	})
+}
+
+func (s *RulesTestSuite) TestValidatedDataNestedDot() {
+	v := s.makeValidator(
+		map[string]any{"user": map[string]any{"name": "go", "email": "a@b.com"}},
+		map[string]any{"user.name": "required|string", "user.email": "required|email"},
+	)
+	s.False(v.Fails())
+	data := v.Validated()
+	user, ok := data["user"].(map[string]any)
+	s.True(ok)
+	s.Equal("go", user["name"])
+	s.Equal("a@b.com", user["email"])
+}
+
+func (s *RulesTestSuite) TestValidatedDataWithWildcard() {
+	v := s.makeValidator(
+		map[string]any{"tags": []any{"go", "rust", "zig"}},
+		map[string]any{"tags.*": "required|string"},
+	)
+	s.False(v.Fails())
+	data := v.Validated()
+	tags, ok := data["tags"].(map[string]any)
+	s.True(ok)
+	s.Equal("go", tags["0"])
+}
+
+// ===== Error Bag Methods Tests =====
+
+func (s *RulesTestSuite) TestErrorBagMethods() {
+	s.Run("has_returns_false_when_no_errors", func() {
+		v := s.makeValidator(
+			map[string]any{"name": "go"},
+			map[string]any{"name": "required"},
+		)
+		s.False(v.Fails())
+		s.Nil(v.Errors())
+	})
+
+	s.Run("get_returns_all_errors_for_field", func() {
+		v := s.makeValidator(
+			map[string]any{"name": ""},
+			map[string]any{"name": "required"},
+		)
+		s.True(v.Fails())
+		errs := v.Errors().Get("name")
+		s.NotNil(errs)
+		s.Contains(errs, "required")
+	})
+
+	s.Run("all_returns_errors_for_all_fields", func() {
+		v := s.makeValidator(
+			map[string]any{},
+			map[string]any{"a": "required", "b": "required"},
+		)
+		s.True(v.Fails())
+		all := v.Errors().All()
+		s.Contains(all, "a")
+		s.Contains(all, "b")
+	})
+
+	s.Run("one_returns_first_error", func() {
+		v := s.makeValidator(
+			map[string]any{"name": ""},
+			map[string]any{"name": "required"},
+		)
+		s.True(v.Fails())
+		s.NotEmpty(v.Errors().One())
+	})
+
+	s.Run("one_with_field_returns_specific", func() {
+		v := s.makeValidator(
+			map[string]any{},
+			map[string]any{"a": "required", "b": "required"},
+		)
+		s.True(v.Fails())
+		s.NotEmpty(v.Errors().One("a"))
+		s.NotEmpty(v.Errors().One("b"))
+	})
+
+	s.Run("has_returns_true_for_failed_field", func() {
+		v := s.makeValidator(
+			map[string]any{},
+			map[string]any{"x": "required", "y": "required"},
+		)
+		s.True(v.Fails())
+		s.True(v.Errors().Has("x"))
+		s.True(v.Errors().Has("y"))
+		s.False(v.Errors().Has("z"))
+	})
+}
+
+func (s *RulesTestSuite) TestWildcardWithMultipleRules() {
+	s.Run("wildcard_required_and_string", func() {
+		v := s.makeValidator(
+			map[string]any{"tags": []any{"go", "rust"}},
+			map[string]any{"tags.*": "required|string"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("wildcard_fail_one_element", func() {
+		v := s.makeValidator(
+			map[string]any{"tags": []any{"go", ""}},
+			map[string]any{"tags.*": "required"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("wildcard_with_min", func() {
+		v := s.makeValidator(
+			map[string]any{"names": []any{"ab", "cdef"}},
+			map[string]any{"names.*": "string|min:3"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("wildcard_nested_objects", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"users": []any{
+					map[string]any{"name": "alice"},
+					map[string]any{"name": "bob"},
+				},
+			},
+			map[string]any{"users.*.name": "required|string"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("wildcard_nested_fail", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"users": []any{
+					map[string]any{"name": "alice"},
+					map[string]any{"name": ""},
+				},
+			},
+			map[string]any{"users.*.name": "required"},
+		)
+		s.True(v.Fails())
+	})
+}
+
+func (s *RulesTestSuite) TestDeepNestedDotNotation() {
+	s.Run("three_level_deep", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"config": map[string]any{
+					"db": map[string]any{
+						"host": "localhost",
+					},
+				},
+			},
+			map[string]any{"config.db.host": "required|string"},
+		)
+		s.False(v.Fails())
+	})
+
+	s.Run("three_level_deep_fail", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"config": map[string]any{
+					"db": map[string]any{
+						"host": "",
+					},
+				},
+			},
+			map[string]any{"config.db.host": "required"},
+		)
+		s.True(v.Fails())
+	})
+
+	s.Run("nested_with_multiple_fields", func() {
+		v := s.makeValidator(
+			map[string]any{
+				"server": map[string]any{
+					"host": "localhost",
+					"port": 8080,
+				},
+			},
+			map[string]any{
+				"server.host": "required|string",
+				"server.port": "required|integer",
+			},
+		)
+		s.False(v.Fails())
+	})
+}
+
+// makeFileHeader creates a real multipart.FileHeader from file content so that
+// detectMIME (which calls fh.Open()) works correctly in tests.
+func makeFileHeader(t *testing.T, filename string, content []byte) *multipart.FileHeader {
+	t.Helper()
+	var buf bytes.Buffer
+	w := multipart.NewWriter(&buf)
+	part, err := w.CreateFormFile("file", filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err = part.Write(content); err != nil {
+		t.Fatal(err)
+	}
+	if err = w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	r := multipart.NewReader(&buf, w.Boundary())
+	form, err := r.ReadForm(32 << 20)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return form.File["file"][0]
+}
diff --git a/validation/service_provider.go b/validation/service_provider.go
index 2d19e50d0..4f438505e 100644
--- a/validation/service_provider.go
+++ b/validation/service_provider.go
@@ -3,10 +3,13 @@ package validation
 import (
 	"github.com/goravel/framework/contracts/binding"
 	consolecontract "github.com/goravel/framework/contracts/console"
+	"github.com/goravel/framework/contracts/database/orm"
 	"github.com/goravel/framework/contracts/foundation"
 	"github.com/goravel/framework/validation/console"
 )
 
+var ormFacade orm.Orm
+
 type ServiceProvider struct {
 }
 
@@ -27,6 +30,8 @@ func (r *ServiceProvider) Register(app foundation.Application) {
 }
 
 func (r *ServiceProvider) Boot(app foundation.Application) {
+	ormFacade = app.MakeOrm()
+
 	app.Commands([]consolecontract.Command{
 		&console.RuleMakeCommand{},
 		&console.FilterMakeCommand{},
diff --git a/validation/utils.go b/validation/utils.go
index 0abaaffd8..b78871b3c 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -1,6 +1,7 @@
 package validation
 
 import (
+	"encoding/json"
 	"fmt"
 	"mime/multipart"
 	"net/url"
@@ -8,6 +9,12 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/gabriel-vasile/mimetype"
+	"github.com/goravel/framework/contracts/database/orm"
 )
 
 // isValueEmpty checks if a value is considered "empty" for validation purposes.
@@ -338,3 +345,352 @@ func normalizeValue(rv reflect.Value) any {
 		return rv.Interface()
 	}
 }
+
+// isValuePresent checks if a value is "present" (not nil/empty).
+func isValuePresent(val any) bool {
+	if val == nil {
+		return false
+	}
+	switch v := val.(type) {
+	case string:
+		return strings.TrimSpace(v) != ""
+	default:
+		rv := reflect.ValueOf(v)
+		switch rv.Kind() {
+		case reflect.Slice, reflect.Array, reflect.Map:
+			return rv.Len() > 0
+		default:
+			return true
+		}
+	}
+}
+
+// toFloat64 attempts to convert a value to float64.
+func toFloat64(val any) (float64, bool) {
+	switch v := val.(type) {
+	case int:
+		return float64(v), true
+	case int8:
+		return float64(v), true
+	case int16:
+		return float64(v), true
+	case int32:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	case uint:
+		return float64(v), true
+	case uint8:
+		return float64(v), true
+	case uint16:
+		return float64(v), true
+	case uint32:
+		return float64(v), true
+	case uint64:
+		return float64(v), true
+	case float32:
+		return float64(v), true
+	case float64:
+		return v, true
+	case string:
+		f, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
+		if err != nil {
+			return 0, false
+		}
+		return f, true
+	case json.Number:
+		f, err := v.Float64()
+		if err != nil {
+			return 0, false
+		}
+		return f, true
+	case bool:
+		if v {
+			return 1, true
+		}
+		return 0, true
+	}
+	return 0, false
+}
+
+// getSize returns the "size" of a value based on its attribute type.
+func getSize(val any, attrType string) (float64, bool) {
+	switch attrType {
+	case "numeric":
+		return toFloat64(val)
+	case "array":
+		if val == nil {
+			return 0, false
+		}
+		rv := reflect.ValueOf(val)
+		kind := rv.Kind()
+		if kind == reflect.Slice || kind == reflect.Array || kind == reflect.Map {
+			return float64(rv.Len()), true
+		}
+		return 0, false
+	case "file":
+		if fh, ok := val.(*multipart.FileHeader); ok {
+			return float64(fh.Size) / 1024, true // kilobytes
+		}
+		if fhs, ok := val.([]*multipart.FileHeader); ok {
+			var total int64
+			for _, fh := range fhs {
+				total += fh.Size
+			}
+			return float64(total) / 1024, true
+		}
+		return 0, false
+	default: // string
+		s := fmt.Sprintf("%v", val)
+		return float64(utf8.RuneCountInString(s)), true
+	}
+}
+
+// parseDateValue attempts to parse a date from a value or field reference.
+func parseDateValue(val string, data *DataBag) (time.Time, bool) {
+	// Try as a field reference first
+	if fieldVal, ok := data.Get(val); ok {
+		val = fmt.Sprintf("%v", fieldVal)
+	}
+
+	// Try common date formats
+	formats := []string{
+		time.RFC3339,
+		"2006-01-02T15:04:05",
+		"2006-01-02 15:04:05",
+		"2006-01-02",
+		time.RFC1123,
+		time.RFC822,
+	}
+	for _, f := range formats {
+		if t, err := time.Parse(f, val); err == nil {
+			return t, true
+		}
+	}
+	return time.Time{}, false
+}
+
+// parseDate attempts to parse a value as a date.
+func parseDate(val any) (time.Time, bool) {
+	switch v := val.(type) {
+	case time.Time:
+		return v, true
+	case string:
+		formats := []string{
+			time.RFC3339,
+			"2006-01-02T15:04:05",
+			"2006-01-02 15:04:05",
+			"2006-01-02",
+			time.RFC1123,
+			time.RFC822,
+		}
+		for _, f := range formats {
+			if t, err := time.Parse(f, v); err == nil {
+				return t, true
+			}
+		}
+	}
+	return time.Time{}, false
+}
+
+// isAcceptedValue checks if a value is one of the "accepted" values.
+func isAcceptedValue(val any) bool {
+	switch v := val.(type) {
+	case string:
+		v = strings.ToLower(strings.TrimSpace(v))
+		return v == "yes" || v == "on" || v == "1" || v == "true"
+	case bool:
+		return v
+	case int:
+		return v == 1
+	case int64:
+		return v == 1
+	case float64:
+		return v == 1
+	}
+	return false
+}
+
+// isDeclinedValue checks if a value is one of the "declined" values.
+func isDeclinedValue(val any) bool {
+	switch v := val.(type) {
+	case string:
+		v = strings.ToLower(strings.TrimSpace(v))
+		return v == "no" || v == "off" || v == "0" || v == "false"
+	case bool:
+		return !v
+	case int:
+		return v == 0
+	case int64:
+		return v == 0
+	case float64:
+		return v == 0
+	}
+	return false
+}
+
+// parseDependentValues extracts the other field's value and comparison values from parameters.
+// params[0] is the other field name, params[1:] are comparison values.
+func parseDependentValues(ctx *RuleContext) (otherValue any, comparisonValues []string, otherField string) {
+	if len(ctx.Parameters) == 0 {
+		return nil, nil, ""
+	}
+	otherField = ctx.Parameters[0]
+	otherValue, _ = ctx.Data.Get(otherField)
+	comparisonValues = ctx.Parameters[1:]
+	return
+}
+
+// parseExistsParams extracts table, columns, and connection from exists rule parameters.
+// Supports "connection.table" format for specifying database connection.
+// All parameters after the table name are treated as column names.
+func parseExistsParams(ctx *RuleContext) (table string, columns []string, connection string) {
+	if len(ctx.Parameters) == 0 {
+		return "", []string{ctx.Attribute}, ""
+	}
+
+	table = ctx.Parameters[0]
+
+	// Parse connection.table format
+	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
+		connection = table[:dotIdx]
+		table = table[dotIdx+1:]
+	}
+
+	// Collect all columns from parameters (starting at index 1)
+	for i := 1; i < len(ctx.Parameters); i++ {
+		if ctx.Parameters[i] != "" {
+			columns = append(columns, ctx.Parameters[i])
+		}
+	}
+
+	// Default column to field name if none specified
+	if len(columns) == 0 {
+		columns = []string{ctx.Attribute}
+	}
+
+	return table, columns, connection
+}
+
+// parseUniqueParams extracts table, column, and connection from unique rule parameters.
+// Supports "connection.table" format for specifying database connection.
+func parseUniqueParams(ctx *RuleContext) (table, column, connection string) {
+	if len(ctx.Parameters) == 0 {
+		return "", ctx.Attribute, ""
+	}
+
+	table = ctx.Parameters[0]
+
+	// Parse connection.table format
+	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
+		connection = table[:dotIdx]
+		table = table[dotIdx+1:]
+	}
+
+	// Column defaults to field name
+	column = ctx.Attribute
+	if len(ctx.Parameters) >= 2 && ctx.Parameters[1] != "" {
+		column = ctx.Parameters[1]
+	}
+
+	return table, column, connection
+}
+
+// getOrmQuery returns an ORM query, optionally with a specific connection.
+func getOrmQuery(ctx *RuleContext, connection string) orm.Query {
+	o := ormFacade.WithContext(ctx.Ctx)
+	if connection != "" {
+		o = o.Connection(connection)
+	}
+	return o.Query()
+}
+
+// toCamelCase converts a string to camelCase.
+func toCamelCase(s string) string {
+	words := splitWords(s)
+	if len(words) == 0 {
+		return ""
+	}
+
+	result := strings.ToLower(words[0])
+	for _, w := range words[1:] {
+		if len(w) > 0 {
+			runes := []rune(strings.ToLower(w))
+			runes[0] = unicode.ToUpper(runes[0])
+			result += string(runes)
+		}
+	}
+
+	return result
+}
+
+// toSnakeCase converts a string to snake_case.
+func toSnakeCase(s string) string {
+	words := splitWords(s)
+	for i, w := range words {
+		words[i] = strings.ToLower(w)
+	}
+	return strings.Join(words, "_")
+}
+
+// splitWords splits a string into words based on separators and case changes.
+func splitWords(s string) []string {
+	// Replace common separators with spaces
+	s = strings.NewReplacer("-", " ", "_", " ").Replace(s)
+
+	// Split on camelCase boundaries
+	var words []string
+	current := strings.Builder{}
+
+	runes := []rune(s)
+	for i, r := range runes {
+		if r == ' ' {
+			if current.Len() > 0 {
+				words = append(words, current.String())
+				current.Reset()
+			}
+			continue
+		}
+
+		if i > 0 && unicode.IsUpper(r) && !unicode.IsUpper(runes[i-1]) {
+			if current.Len() > 0 {
+				words = append(words, current.String())
+				current.Reset()
+			}
+		}
+
+		current.WriteRune(r)
+	}
+
+	if current.Len() > 0 {
+		words = append(words, current.String())
+	}
+
+	return words
+}
+
+var htmlTagRegex = regexp.MustCompile(`<[^>]*>`)
+
+// stripHTMLTags removes HTML tags from a string.
+func stripHTMLTags(s string) string {
+	return htmlTagRegex.ReplaceAllString(s, "")
+}
+
+// detectMIME detects the real MIME type of a multipart file by reading its content.
+func detectMIME(fh *multipart.FileHeader) (*mimetype.MIME, error) {
+	f, err := fh.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer func(f multipart.File) { _ = f.Close() }(f)
+
+	return mimetype.DetectReader(f)
+}
+
+func getFileExtension(filename string) string {
+	idx := strings.LastIndex(filename, ".")
+	if idx == -1 {
+		return ""
+	}
+	return filename[idx+1:]
+}
diff --git a/validation/utils_test.go b/validation/utils_test.go
index cb5d9c07a..d7a8c878a 100644
--- a/validation/utils_test.go
+++ b/validation/utils_test.go
@@ -436,3 +436,60 @@ func TestNormalizeValue(t *testing.T) {
 		assert.Equal(t, "Alice", result["name"])
 	})
 }
+
+func TestToCamelCase(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"hello_world", "helloWorld"},
+		{"hello-world", "helloWorld"},
+		{"hello world", "helloWorld"},
+		{"HelloWorld", "helloWorld"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			assert.Equal(t, tt.expected, toCamelCase(tt.input))
+		})
+	}
+}
+
+func TestToSnakeCase(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"helloWorld", "hello_world"},
+		{"hello-world", "hello_world"},
+		{"hello world", "hello_world"},
+		{"HelloWorld", "hello_world"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			assert.Equal(t, tt.expected, toSnakeCase(tt.input))
+		})
+	}
+}
+
+func TestStripHTMLTags(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"<p>Hello</p>", "Hello"},
+		{"<b>Bold</b> and <i>italic</i>", "Bold and italic"},
+		{"No tags here", "No tags here"},
+		{"<script>alert('xss')</script>", "alert('xss')"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			assert.Equal(t, tt.expected, stripHTMLTags(tt.input))
+		})
+	}
+}
diff --git a/validation/validation_test.go b/validation/validation_test.go
index acb4bdcc2..6423a8488 100644
--- a/validation/validation_test.go
+++ b/validation/validation_test.go
@@ -1,8 +1,22 @@
 package validation
 
-/*func TestMake(t *testing.T) {
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cast"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	httpvalidate "github.com/goravel/framework/contracts/validation"
+	"github.com/goravel/framework/errors"
+	"github.com/goravel/framework/http"
+)
+
+func TestMake(t *testing.T) {
 	type Data struct {
-		A string
+		A string `form:"a"`
 	}
 
 	ctx := http.NewContext()
@@ -12,7 +26,7 @@ package validation
 	tests := []struct {
 		description        string
 		data               any
-		rules              map[string]string
+		rules              map[string]any
 		options            []httpvalidate.Option
 		expectValidator    bool
 		expectErr          error
@@ -23,9 +37,9 @@ package validation
 		{
 			description: "success when data is map[string]any",
 			data:        map[string]any{"a": " b "},
-			rules:       map[string]string{"a": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 			},
 			expectValidator: true,
 			expectData:      Data{A: "b"},
@@ -33,43 +47,42 @@ package validation
 		{
 			description: "success when data is struct",
 			data:        &Data{A: "  b"},
-			rules:       map[string]string{"A": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"A": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 			},
 			expectValidator: true,
 			expectData:      Data{A: "b"},
 		},
+		{
+			description:        "error when data is empty map",
+			data:               map[string]any{},
+			rules:              map[string]any{"a": "required"},
+			expectValidator:    true,
+			expectErrors:       true,
+			expectErrorMessage: "The a field is required.",
+		},
 		{
 			description: "error when data isn't map[string]any or map[string][]string or struct",
 			data:        "1   ",
-			rules:       map[string]string{"a": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 			},
 			expectErr: errors.ValidationDataInvalidType,
 		},
-		{
-			description: "error when data is empty map",
-			data:        map[string]any{},
-			rules:       map[string]string{"a": "required"},
-			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
-			},
-			expectErr: errors.ValidationEmptyData,
-		},
 		{
 			description: "error when rule is empty map",
 			data:        map[string]any{"a": "b"},
-			rules:       map[string]string{},
+			rules:       map[string]any{},
 			expectErr:   errors.ValidationEmptyRules,
 		},
 		{
 			description: "error when PrepareForValidation returns error",
 			data:        map[string]any{"a": "   b   "},
-			rules:       map[string]string{"a": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 				PrepareForValidation(func(ctx context.Context, data httpvalidate.Data) error {
 					return assert.AnError
 				}),
@@ -79,14 +92,13 @@ package validation
 		{
 			description: "success when data is map[string]any and with PrepareForValidation",
 			data:        map[string]any{"a": "   b  "},
-			rules:       map[string]string{"a": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 				PrepareForValidation(func(ctx context.Context, data httpvalidate.Data) error {
 					if _, exist := data.Get("a"); exist {
 						return data.Set("a", "c")
 					}
-
 					return nil
 				}),
 			},
@@ -96,9 +108,9 @@ package validation
 		{
 			description: "success when calling PrepareForValidation with ctx",
 			data:        map[string]any{"a": "   b  "},
-			rules:       map[string]string{"a": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 				PrepareForValidation(func(ctx context.Context, data httpvalidate.Data) error {
 					if _, exist := data.Get("a"); exist {
 						return data.Set("a", ctx.Value("test"))
@@ -113,9 +125,9 @@ package validation
 		{
 			description: "contain errors when data is map[string]any and with Messages, Attributes, PrepareForValidation",
 			data:        map[string]any{"a": "aa   "},
-			rules:       map[string]string{"a": "required", "b": "required"},
+			rules:       map[string]any{"a": "required", "b": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"a": "trim", "b": "trim"}),
+				Filters(map[string]any{"a": "trim", "b": "trim"}),
 				Messages(map[string]string{
 					"b.required": ":attribute can't be empty",
 				}),
@@ -126,7 +138,6 @@ package validation
 					if _, exist := data.Get("a"); exist {
 						return data.Set("a", "c")
 					}
-
 					return nil
 				}),
 			},
@@ -138,14 +149,13 @@ package validation
 		{
 			description: "success when data is struct and with PrepareForValidation",
 			data:        &Data{A: "b"},
-			rules:       map[string]string{"A": "required"},
+			rules:       map[string]any{"a": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"A": "trim"}),
+				Filters(map[string]any{"a": "trim"}),
 				PrepareForValidation(func(ctx context.Context, data httpvalidate.Data) error {
-					if _, exist := data.Get("A"); exist {
-						return data.Set("A", "c")
+					if _, exist := data.Get("a"); exist {
+						return data.Set("a", "c")
 					}
-
 					return nil
 				}),
 			},
@@ -155,20 +165,19 @@ package validation
 		{
 			description: "contain errors when data is struct and with Messages, Attributes, PrepareForValidation",
 			data:        &Data{A: "b"},
-			rules:       map[string]string{"A": "required", "B": "required"},
+			rules:       map[string]any{"a": "required", "b": "required"},
 			options: []httpvalidate.Option{
-				Filters(map[string]string{"A": "trim", "B": "trim"}),
+				Filters(map[string]any{"a": "trim", "b": "trim"}),
 				Messages(map[string]string{
-					"B.required": ":attribute can't be empty",
+					"b.required": ":attribute can't be empty",
 				}),
 				Attributes(map[string]string{
-					"B": "b",
+					"b": "b",
 				}),
 				PrepareForValidation(func(ctx context.Context, data httpvalidate.Data) error {
 					if _, exist := data.Get("a"); exist {
 						return data.Set("a", "c")
 					}
-
 					return nil
 				}),
 			},
@@ -216,7 +225,7 @@ func TestBindWithNestedStruct(t *testing.T) {
 		"b": map[string][]string{
 			"b": {"c", "d"},
 		},
-	}, map[string]string{"a": "required|map", "b": "required|map"})
+	}, map[string]any{"a": "required|map", "b": "required|map"})
 
 	require.NoError(t, err)
 	require.NotNil(t, validator)
@@ -247,8 +256,8 @@ func TestRule_Regex(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"email": "test@example.com",
-				}, map[string]string{
-					"email": "regex:^\\S+@\\S+\\.\\S+$",
+				}, map[string]any{
+					"email": `regex:^\S+@\S+\.\S+$`,
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
@@ -260,13 +269,14 @@ func TestRule_Regex(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"email": "testexample.com",
-				}, map[string]string{
-					"email": "regex:^\\S+@\\S+\\.\\S+$",
+				}, map[string]any{
+					"email": `regex:^\S+@\S+\.\S+$`,
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
+				assert.True(t, validator.Fails(), c.description)
 				assert.Equal(t, map[string]string{
-					"regex": "email value does not pass the regex check",
+					"regex": "The email field format is invalid.",
 				}, validator.Errors().Get("email"))
 			},
 		},
@@ -274,11 +284,11 @@ func TestRule_Regex(t *testing.T) {
 			description: "success with regex and nested structure",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"user": map[string]string{
+					"user": map[string]any{
 						"email": "test@example.com",
 					},
-				}, map[string]string{
-					"user.email": "regex:^\\S+@\\S+\\.\\S+$",
+				}, map[string]any{
+					"user.email": `regex:^\S+@\S+\.\S+$`,
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
@@ -289,58 +299,43 @@ func TestRule_Regex(t *testing.T) {
 			description: "error with regex and nested structure",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"user": map[string]string{
+					"user": map[string]any{
 						"email": "testexample.com",
 					},
-				}, map[string]string{
-					"user.email": "regex:^\\S+@\\S+\\.\\S+$",
+				}, map[string]any{
+					"user.email": `regex:^\S+@\S+\.\S+$`,
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"regex": "user.email value does not pass the regex check",
-				}, validator.Errors().Get("user.email"))
-			},
-		},
-		{
-			description: "panic when regex pattern is missing",
-			setup: func(c Case) {
-				assert.Panics(t, func() {
-					_, err := validation.Make(context.Background(), map[string]any{
-						"email": "test@example.com",
-					}, map[string]string{
-						"email": "regex:",
-					})
-					assert.NotNil(t, err, c.description)
-				}, c.description)
+				assert.True(t, validator.Fails(), c.description)
+				assert.NotEmpty(t, validator.Errors().Get("user.email"))
 			},
 		},
 		{
-			description: "success with valid regexp match",
+			description: "error when regex pattern is empty",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"phone": "+1-800-555-5555",
-				}, map[string]string{
-					"phone": "regexp:^\\+\\d{1,3}-\\d{3}-\\d{3}-\\d{4}$",
+					"email": "test@example.com",
+				}, map[string]any{
+					"email": "regex:",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
+				assert.True(t, validator.Fails(), c.description)
 			},
 		},
 		{
-			description: "error with invalid regexp match",
+			description: "error with invalid regex match",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"phone": "18005555555",
-				}, map[string]string{
-					"phone": "regexp:^\\+\\d{1,3}-\\d{3}-\\d{3}-\\d{4}$",
+				}, map[string]any{
+					"phone": "regex:^\\+\\d{1,3}-\\d{3}-\\d{3}-\\d{4}$",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"regexp": "phone must match pattern ^\\+\\d{1,3}-\\d{3}-\\d{3}-\\d{4}$",
-				}, validator.Errors().Get("phone"))
+				assert.True(t, validator.Fails(), c.description)
+				assert.NotEmpty(t, validator.Errors().Get("phone"))
 			},
 		},
 	}
@@ -360,7 +355,7 @@ func TestRule_Required(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required",
 				})
 				assert.Nil(t, err, c.description)
@@ -372,10 +367,10 @@ func TestRule_Required(t *testing.T) {
 			description: "success with nested",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": map[string]string{
+					"name": map[string]any{
 						"first": "Goravel",
 					},
-				}, map[string]string{
+				}, map[string]any{
 					"name.first": "required",
 				})
 				assert.Nil(t, err, c.description)
@@ -388,14 +383,13 @@ func TestRule_Required(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"required": "name is required to not be empty",
-				}, validator.Errors().Get("name"))
+				assert.True(t, validator.Fails(), c.description)
+				assert.Equal(t, "The name field is required.", validator.Errors().One("name"))
 			},
 		},
 		{
@@ -403,15 +397,14 @@ func TestRule_Required(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "Goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"required": "name1 is required to not be empty",
-				}, validator.Errors().Get("name1"))
+				assert.True(t, validator.Fails(), c.description)
+				assert.Equal(t, "The name1 field is required.", validator.Errors().One("name1"))
 			},
 		},
 		{
@@ -421,13 +414,14 @@ func TestRule_Required(t *testing.T) {
 					"name": map[string]string{
 						"first": "",
 					},
-				}, map[string]string{
+				}, map[string]any{
 					"name.first": "required",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
+				assert.True(t, validator.Fails(), c.description)
 				assert.Equal(t, map[string]string{
-					"required": "name.first is required to not be empty",
+					"required": "The name.first field is required.",
 				}, validator.Errors().Get("name.first"))
 			},
 		},
@@ -449,7 +443,7 @@ func TestRule_RequiredIf(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "goravel1",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_if:name,goravel,goravel1",
 				})
@@ -463,7 +457,7 @@ func TestRule_RequiredIf(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel2",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_if:name,goravel,goravel1",
 				})
@@ -478,15 +472,13 @@ func TestRule_RequiredIf(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_if:name,goravel,goravel1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"required_if": "name1 is required when name is in [goravel,goravel1]",
-				}, validator.Errors().Get("name1"))
+				assert.True(t, validator.Fails(), c.description)
 			},
 		},
 		{
@@ -494,14 +486,15 @@ func TestRule_RequiredIf(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_if:name,goravel,goravel1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
+				assert.True(t, validator.Fails(), c.description)
 				assert.Equal(t, map[string]string{
-					"required_if": "name1 is required when name is in [goravel,goravel1]",
+					"required_if": "The name1 field is required when name is goravel, goravel1.",
 				}, validator.Errors().Get("name1"))
 			},
 		},
@@ -523,7 +516,7 @@ func TestRule_RequiredUnless(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "goravel1",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_unless:name,hello,hello1",
 				})
@@ -537,7 +530,7 @@ func TestRule_RequiredUnless(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_unless:name,goravel,goravel1",
 				})
@@ -552,14 +545,14 @@ func TestRule_RequiredUnless(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_unless:name,hello,hello1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_unless": "name1 field is required unless name is in [hello,hello1]",
+					"required_unless": "The name1 field is required unless name is in hello, hello1.",
 				}, validator.Errors().Get("name1"))
 			},
 		},
@@ -568,14 +561,14 @@ func TestRule_RequiredUnless(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required_unless:name,hello,hello1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_unless": "name1 field is required unless name is in [hello,hello1]",
+					"required_unless": "The name1 field is required unless name is in hello, hello1.",
 				}, validator.Errors().Get("name1"))
 			},
 		},
@@ -597,7 +590,7 @@ func TestRule_RequiredWith(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name2": "goravel2",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name2": "required_with:name,name1",
 				})
@@ -611,7 +604,7 @@ func TestRule_RequiredWith(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required_with:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
@@ -626,7 +619,7 @@ func TestRule_RequiredWith(t *testing.T) {
 					"name":  "goravel",
 					"name1": "goravel1",
 					"name2": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 					"name2": "required_with:name,name1",
@@ -634,7 +627,7 @@ func TestRule_RequiredWith(t *testing.T) {
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_with": "name2 field is required when [name,name1] is present",
+					"required_with": "The name2 field is required when name, name1 is present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
@@ -644,7 +637,7 @@ func TestRule_RequiredWith(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "goravel1",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 					"name2": "required_with:name,name1",
@@ -652,7 +645,7 @@ func TestRule_RequiredWith(t *testing.T) {
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_with": "name2 field is required when [name,name1] is present",
+					"required_with": "The name2 field is required when name, name1 is present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
@@ -675,7 +668,7 @@ func TestRule_RequiredWithAll(t *testing.T) {
 					"name":  "goravel",
 					"name1": "goravel1",
 					"name2": "goravel2",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 					"name2": "required_with_all:name,name1",
@@ -686,13 +679,13 @@ func TestRule_RequiredWithAll(t *testing.T) {
 			},
 		},
 		{
-			description: "success when required_with_all is true",
+			description: "success when not all fields present",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "",
 					"name2": "goravel2",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name2": "required_with_all:name,name1",
 				})
@@ -706,7 +699,7 @@ func TestRule_RequiredWithAll(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required_with_all:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
@@ -721,7 +714,7 @@ func TestRule_RequiredWithAll(t *testing.T) {
 					"name":  "goravel",
 					"name1": "goravel1",
 					"name2": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 					"name2": "required_with_all:name,name1",
@@ -729,17 +722,17 @@ func TestRule_RequiredWithAll(t *testing.T) {
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_with_all": "name2 field is required when [name,name1] is present",
+					"required_with_all": "The name2 field is required when name, name1 are present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
 		{
-			description: "error when required_with is true and key isn't exist",
+			description: "error when required_with_all is true and key isn't exist",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name1": "goravel1",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name1": "required",
 					"name2": "required_with_all:name,name1",
@@ -747,7 +740,7 @@ func TestRule_RequiredWithAll(t *testing.T) {
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_with_all": "name2 field is required when [name,name1] is present",
+					"required_with_all": "The name2 field is required when name, name1 are present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
@@ -769,7 +762,7 @@ func TestRule_RequiredWithout(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name2": "goravel2",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name2": "required_without:name,name1",
 				})
@@ -782,10 +775,10 @@ func TestRule_RequiredWithout(t *testing.T) {
 			description: "success when required_without is false",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "",
-					"name1": "",
-					"name2": "",
-				}, map[string]string{
+					"name":  "goravel",
+					"name1": "goravel1",
+					"name2": "goravel2",
+				}, map[string]any{
 					"name": "required_without:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
@@ -799,14 +792,14 @@ func TestRule_RequiredWithout(t *testing.T) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "goravel",
 					"name2": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name2": "required_without:name,name1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_without": "name2 field is required when [name,name1] is not present",
+					"required_without": "The name2 field is required when name, name1 is not present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
@@ -815,14 +808,14 @@ func TestRule_RequiredWithout(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name":  "required",
 					"name2": "required_without:name,name1",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_without": "name2 field is required when [name,name1] is not present",
+					"required_without": "The name2 field is required when name, name1 is not present.",
 				}, validator.Errors().Get("name2"))
 			},
 		},
@@ -843,7 +836,7 @@ func TestRule_RequiredWithoutAll(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "goravel",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required_without_all:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
@@ -856,9 +849,8 @@ func TestRule_RequiredWithoutAll(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name":  "",
-					"name1": "",
-					"name2": "",
-				}, map[string]string{
+					"name1": "goravel1",
+				}, map[string]any{
 					"name": "required_without_all:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
@@ -871,13 +863,13 @@ func TestRule_RequiredWithoutAll(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name": "",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required_without_all:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_without_all": "name field is required when none of [name1,name2] are present",
+					"required_without_all": "The name field is required when none of name1, name2 are present.",
 				}, validator.Errors().Get("name"))
 			},
 		},
@@ -886,13 +878,13 @@ func TestRule_RequiredWithoutAll(t *testing.T) {
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
 					"name3": "goravel3",
-				}, map[string]string{
+				}, map[string]any{
 					"name": "required_without_all:name1,name2",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
 				assert.Equal(t, map[string]string{
-					"required_without_all": "name field is required when none of [name1,name2] are present",
+					"required_without_all": "The name field is required when none of name1, name2 are present.",
 				}, validator.Errors().Get("name"))
 			},
 		},
@@ -905,142 +897,96 @@ func TestRule_RequiredWithoutAll(t *testing.T) {
 	}
 }
 
-func TestRule_Int(t *testing.T) {
+func TestAddRules(t *testing.T) {
 	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|int",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "success with range",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 3,
-				}, map[string]string{
-					"name": "required|int:2,4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error when type error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "1",
-				}, map[string]string{
-					"name": "required|int",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"int": "name value must be an integer",
-				}, validator.Errors().Get("name"))
-			},
-		},
-		{
-			description: "error when value doesn't in the right range",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|int:2,4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"int": "name value must be an integer and in the range 2 - 4",
-				}, validator.Errors().Get("name"))
-			},
-		},
-	}
 
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
+	t.Run("success", func(t *testing.T) {
+		err := validation.AddRules([]httpvalidate.Rule{&CustomUppercase{}})
+		assert.Nil(t, err)
+	})
+
+	t.Run("duplicate rule", func(t *testing.T) {
+		err := validation.AddRules([]httpvalidate.Rule{&Duplicate{}})
+		assert.EqualError(t, err, "duplicate rule name: required")
+	})
 }
 
-func TestRule_Uint(t *testing.T) {
+func TestCustomFilters(t *testing.T) {
 	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|uint",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error when type error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "s",
-				}, map[string]string{
-					"name": "required|uint",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"uint": "name value must be an unsigned integer(>= 0)",
-				}, validator.Errors().Get("name"))
-			},
-		},
-	}
+	err := validation.AddFilters([]httpvalidate.Filter{&DefaultFilter{}})
+	assert.Nil(t, err)
 
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
+	filters := validation.Filters()
+	defaultFilterFunc := filters[0].Handle(context.Background()).(func(string, ...string) string)
+	assert.Equal(t, "default", defaultFilterFunc("", "default"))
+	assert.Equal(t, "a", defaultFilterFunc("a"))
+}
+
+func TestCustomFiltersIntegration(t *testing.T) {
+	mp := map[string]any{
+		"name":  "krishan ",
+		"age":   " 22 ",
+		"empty": "",
 	}
+
+	validation := NewValidation()
+	err := validation.AddFilters([]httpvalidate.Filter{&DefaultFilter{}})
+	assert.Nil(t, err)
+
+	validator, err := validation.Make(context.Background(), mp, map[string]any{
+		"name":  "required",
+		"age":   "required",
+		"empty": "required",
+	}, Filters(map[string]any{
+		"empty": "default:emptyDefault",
+		"name":  "trim|upper",
+		"age":   "trim|to_int",
+	}))
+
+	assert.Nil(t, err)
+	var newMp map[string]any
+	assert.Nil(t, validator.Bind(&newMp))
+
+	assert.Equal(t, "KRISHAN", newMp["name"])
+	assert.Equal(t, 22, newMp["age"])
+	assert.Equal(t, "emptyDefault", newMp["empty"])
 }
 
-func TestRule_Bool(t *testing.T) {
+func TestCustomRule(t *testing.T) {
 	validation := NewValidation()
+	err := validation.AddRules([]httpvalidate.Rule{&CustomUppercase{}, &CustomLowercase{}})
+	assert.Nil(t, err)
+
 	tests := []Case{
 		{
 			description: "success",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1":  "on",
-					"name2":  "off",
-					"name3":  "yes",
-					"name4":  "no",
-					"name5":  true,
-					"name6":  false,
-					"name7":  "true",
-					"name8":  "false",
-					"name9":  "1",
-					"name10": "0",
-				}, map[string]string{
-					"name1":  "bool",
-					"name2":  "bool",
-					"name3":  "bool",
-					"name4":  "bool",
-					"name5":  "bool",
-					"name6":  "bool",
-					"name7":  "bool",
-					"name8":  "bool",
-					"name9":  "bool",
-					"name10": "bool",
+					"name1":   "on",
+					"name2":   "off",
+					"name3":   "yes",
+					"name4":   "no",
+					"name5":   true,
+					"name6":   false,
+					"name7":   "true",
+					"name8":   "false",
+					"name9":   "1",
+					"name10":  "0",
+					"name":    "ABC",
+					"address": "de",
+				}, map[string]any{
+					"name1":   "bool",
+					"name2":   "bool",
+					"name3":   "bool",
+					"name4":   "bool",
+					"name5":   "bool",
+					"name6":   "bool",
+					"name7":   "bool",
+					"name8":   "bool",
+					"name9":   "bool",
+					"name10":  "bool",
+					"name":    "required|custom_uppercase:3",
+					"address": "required|custom_lowercase:2",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
@@ -1048,22 +994,25 @@ func TestRule_Bool(t *testing.T) {
 			},
 		},
 		{
-			description: "error when type error",
+			description: "error",
 			setup: func(c Case) {
 				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 1,
-					"name2": 0,
-					"name3": "a",
-				}, map[string]string{
-					"name1": "bool",
-					"name2": "bool",
-					"name3": "bool",
+					"name1":   1,
+					"name2":   0,
+					"name3":   "a",
+					"name":    "abc",
+					"address": "DE",
+				}, map[string]any{
+					"name1":   "bool",
+					"name2":   "bool",
+					"name3":   "bool",
+					"name":    "required|custom_uppercase:3",
+					"address": "required|custom_lowercase:2",
 				})
 				assert.Nil(t, err, c.description)
 				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"bool": "name1 value must be a bool"}, validator.Errors().Get("name1"))
-				assert.Nil(t, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"bool": "name3 value must be a bool"}, validator.Errors().Get("name3"))
+				assert.Equal(t, map[string]string{"custom_uppercase": "name must be upper"}, validator.Errors().Get("name"))
+				assert.Equal(t, map[string]string{"custom_lowercase": "address must be lower"}, validator.Errors().Get("address"))
 			},
 		},
 	}
@@ -1075,1867 +1024,129 @@ func TestRule_Bool(t *testing.T) {
 	}
 }
 
-func TestRule_String(t *testing.T) {
+func TestValidated(t *testing.T) {
 	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "1",
-				}, map[string]string{
-					"name": "required|string",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "success with range",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abc",
-				}, map[string]string{
-					"name": "required|string:2,4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error when type error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|string",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"string": "name value must be a string",
-				}, validator.Errors().Get("name"))
-			},
-		},
-		{
-			description: "error when value doesn't in the right range",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|string:2,4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"string": "name value must be a string",
-				}, validator.Errors().Get("name"))
-			},
-		},
-	}
+	validator, err := validation.Make(context.Background(), map[string]any{
+		"name":  "goravel",
+		"email": "test@example.com",
+		"extra": "not in rules",
+	}, map[string]any{
+		"name":  "required",
+		"email": "required|email",
+	})
+	assert.Nil(t, err)
+	assert.False(t, validator.Fails())
 
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
+	validated := validator.Validated()
+	assert.Equal(t, "goravel", validated["name"])
+	assert.Equal(t, "test@example.com", validated["email"])
+	// "extra" should not be in validated data
+	_, exists := validated["extra"]
+	assert.False(t, exists)
 }
 
-func TestRule_Float(t *testing.T) {
+func TestWildcardRules(t *testing.T) {
 	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1.1,
-				}, map[string]string{
-					"name": "required|float",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error when type error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|float",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{
-					"float": "name value must be a float",
-				}, validator.Errors().Get("name"))
-			},
-		},
-	}
 
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
+	t.Run("validates wildcard fields", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"users": []any{
+				map[string]any{"name": "Alice"},
+				map[string]any{"name": ""},
+			},
+		}, map[string]any{
+			"users.*.name": "required",
 		})
-	}
+		assert.Nil(t, err)
+		assert.True(t, validator.Fails())
+	})
+
+	t.Run("success with all valid", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"users": []any{
+				map[string]any{"name": "Alice"},
+				map[string]any{"name": "Bob"},
+			},
+		}, map[string]any{
+			"users.*.name": "required|string",
+		})
+		assert.Nil(t, err)
+		assert.False(t, validator.Fails())
+	})
 }
 
-func TestRule_Slice(t *testing.T) {
+func TestSliceRuleSyntax(t *testing.T) {
 	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": []int{1, 2},
-					"name2": []uint{1, 2},
-					"name3": []string{"a", "b"},
-				}, map[string]string{
-					"name1": "required|slice",
-					"name2": "required|slice",
-					"name3": "required|slice",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error when type error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 1,
-					"name2": "a",
-					"name3": true,
-				}, map[string]string{
-					"name1": "required|slice",
-					"name2": "required|slice",
-					"name3": "required|slice",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"slice": "name1 value must be a slice"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"slice": "name2 value must be a slice"}, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"slice": "name3 value must be a slice"}, validator.Errors().Get("name3"))
-			},
-		},
-	}
 
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
+	t.Run("regex with pipe in pattern using slice syntax", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"code": "foo",
+		}, map[string]any{
+			"code": []string{"required", "regex:^(foo|bar)$", "string"},
 		})
-	}
+		assert.Nil(t, err)
+		assert.NotNil(t, validator)
+		assert.False(t, validator.Fails())
+	})
+
+	t.Run("regex with pipe fails validation using slice syntax", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"code": "baz",
+		}, map[string]any{
+			"code": []string{"required", "regex:^(foo|bar)$"},
+		})
+		assert.Nil(t, err)
+		assert.NotNil(t, validator)
+		assert.True(t, validator.Fails())
+	})
+
+	t.Run("mixed string and slice rules", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"name": "goravel",
+			"code": "foo",
+		}, map[string]any{
+			"name": "required|string",
+			"code": []string{"required", "regex:^(foo|bar)$"},
+		})
+		assert.Nil(t, err)
+		assert.NotNil(t, validator)
+		assert.False(t, validator.Fails())
+	})
+
+	t.Run("invalid rule type returns error", func(t *testing.T) {
+		_, err := validation.Make(context.Background(), map[string]any{
+			"name": "goravel",
+		}, map[string]any{
+			"name": 123,
+		})
+		assert.ErrorIs(t, err, errors.ValidationInvalidRuleType)
+	})
+
+	t.Run("slice syntax with filters", func(t *testing.T) {
+		validator, err := validation.Make(context.Background(), map[string]any{
+			"name": "  Goravel  ",
+		}, map[string]any{
+			"name": []string{"required", "string"},
+		}, Filters(map[string]any{
+			"name": []string{"trim", "lower"},
+		}))
+		assert.Nil(t, err)
+		assert.NotNil(t, validator)
+		assert.False(t, validator.Fails())
+
+		val := validator.Validated()
+		assert.Equal(t, "goravel", val["name"])
+	})
 }
 
-func TestRule_In(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 1,
-					"name2": "a",
-				}, map[string]string{
-					"name1": "required|in:1,2",
-					"name2": "required|in:a,b",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 3,
-					"name2": "c",
-				}, map[string]string{
-					"name1": "required|in:1,2",
-					"name2": "required|in:a,b",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"in": "name1 value must be in the enum [1 2]"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"in": "name2 value must be in the enum [a b]"}, validator.Errors().Get("name2"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_NotIn(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 3,
-					"name2": "c",
-				}, map[string]string{
-					"name1": "required|not_in:1,2",
-					"name2": "required|not_in:a,b",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name1": 1,
-					"name2": "a",
-				}, map[string]string{
-					"name1": "required|not_in:1,2",
-					"name2": "required|not_in:a,b",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"not_in": "name1 value must not be in the given enum list [%!d(string=1) %!d(string=2)]"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"not_in": "name2 value must not be in the given enum list [%!d(string=a) %!d(string=b)]"}, validator.Errors().Get("name2"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_StartsWith(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abc",
-				}, map[string]string{
-					"name": "required|starts_with:ab",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|starts_with:ab",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"starts_with": "name value does not start with ab"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_EndsWith(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "cab",
-				}, map[string]string{
-					"name": "required|ends_with:ab",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|ends_with:ab",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ends_with": "name value does not end with ab"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Between(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 2,
-				}, map[string]string{
-					"name": "required|between:1,3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|between:2,4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"between": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Max(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 2,
-				}, map[string]string{
-					"name": "required|max:3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 4,
-				}, map[string]string{
-					"name": "required|max:3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"max": "name max value is 3"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Min(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 3,
-				}, map[string]string{
-					"name": "required|min:3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 2,
-				}, map[string]string{
-					"name": "required|min:3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"min": "name min value is 3"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Eq(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|eq:a",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "b",
-				}, map[string]string{
-					"name": "required|eq:a",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"eq": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Ne(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "b",
-				}, map[string]string{
-					"name": "required|ne:a",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|ne:a",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ne": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Lt(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|lt:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 2,
-				}, map[string]string{
-					"name": "required|lt:1",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"lt": "name value should be less than 1"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Gt(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 2,
-				}, map[string]string{
-					"name": "required|gt:1",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|gt:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"gt": "name value should be greater than 2"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Len(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|len:3",
-					"name1": "required|len:3",
-					"name2": "required|len:3",
-					"name3": "required|len:3",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|len:2",
-					"name1": "required|len:2",
-					"name2": "required|len:2",
-					"name3": "required|len:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"len": "name field did not pass validation"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"len": "name1 field did not pass validation"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"len": "name2 field did not pass validation"}, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"len": "name3 field did not pass validation"}, validator.Errors().Get("name3"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_MinLen(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|min_len:2",
-					"name1": "required|min_len:2",
-					"name2": "required|min_len:2",
-					"name3": "required|min_len:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|min_len:4",
-					"name1": "required|min_len:4",
-					"name2": "required|min_len:4",
-					"name3": "required|min_len:4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"min_len": "name min length is 4"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"min_len": "name1 min length is 4"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"min_len": "name2 min length is 4"}, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"min_len": "name3 min length is 4"}, validator.Errors().Get("name3"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_MaxLen(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|max_len:4",
-					"name1": "required|max_len:4",
-					"name2": "required|max_len:4",
-					"name3": "required|max_len:4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abc",
-					"name1": [3]string{"a", "b", "c"},
-					"name2": []string{"a", "b", "c"},
-					"name3": map[string]string{
-						"a": "a1",
-						"b": "b1",
-						"c": "c1",
-					},
-				}, map[string]string{
-					"name":  "required|max_len:2",
-					"name1": "required|max_len:2",
-					"name2": "required|max_len:2",
-					"name3": "required|max_len:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"max_len": "name max length is 2"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"max_len": "name1 max length is 2"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"max_len": "name2 max length is 2"}, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"max_len": "name3 max length is 2"}, validator.Errors().Get("name3"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Email(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "hello@goravel.com",
-				}, map[string]string{
-					"name": "required|email",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abc",
-				}, map[string]string{
-					"name": "required|email",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"email": "name value is an invalid email address"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Array(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  [2]string{"a", "b"},
-					"name1": []string{"a", "b"},
-				}, map[string]string{
-					"name":  "required|array",
-					"name1": "required|array",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": 1,
-					"name2": true,
-				}, map[string]string{
-					"name":  "required|array",
-					"name1": "required|array",
-					"name2": "required|array",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"array": "name value must be an array"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"array": "name1 value must be an array"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"array": "name2 value must be an array"}, validator.Errors().Get("name2"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Map(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": map[string]string{"a": "a1"},
-				}, map[string]string{
-					"name": "required|map",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": 1,
-					"name2": true,
-					"name3": []string{"a"},
-				}, map[string]string{
-					"name":  "required|map",
-					"name1": "required|map",
-					"name2": "required|map",
-					"name3": "required|map",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"map": "name value must be a map"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"map": "name1 value must be a map"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"map": "name2 value must be a map"}, validator.Errors().Get("name2"))
-				assert.Equal(t, map[string]string{"map": "name3 value must be a map"}, validator.Errors().Get("name3"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_EqField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "a",
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|eq_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "b",
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|eq_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"eq_field": "name1 value must be equal the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_NeField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "b",
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|ne_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "a",
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|ne_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ne_field": "name1 value cannot be equal to the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_GtField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  1,
-					"name1": 2,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|gt_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  2,
-					"name1": 1,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|gt_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"gt_field": "name1 value must be greater than the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_GteField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  1,
-					"name1": 2,
-					"name2": 1,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|gte_field:name",
-					"name2": "required|gte_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  2,
-					"name1": 1,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|gte_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"gte_field": "name1 value should be greater or equal to the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_LtField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  2,
-					"name1": 1,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|lt_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  1,
-					"name1": 2,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|lt_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"lt_field": "name1 value should be less than the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_LteField(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  2,
-					"name1": 2,
-					"name2": 1,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|lte_field:name",
-					"name2": "required|lte_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  1,
-					"name1": 2,
-				}, map[string]string{
-					"name":  "required",
-					"name1": "required|lte_field:name",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"lte_field": "name1 value should be less than or equal to the field name"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Date(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "2022-12-25",
-					"name1": "2022/12/25",
-					"name2": "",
-				}, map[string]string{
-					"name":  "required|date",
-					"name1": "required|date",
-					"name2": "date",
-					"name3": "date",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "2022.12.25",
-					"name1": "a",
-				}, map[string]string{
-					"name":  "required|date",
-					"name1": "required|date",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"date": "name value should be a date string"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"date": "name1 value should be a date string"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_GtDate(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|gt_date:2022-12-24",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|gt_date:2022-12-26",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"gt_date": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_LtDate(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|lt_date:2022-12-26",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|lt_date:2022-12-24",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"lt_date": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_GteDate(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "2022-12-25",
-					"name1": "2022-12-25",
-				}, map[string]string{
-					"name":  "required|gte_date:2022-12-25",
-					"name1": "required|gte_date:2022-12-24",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|gte_date:2022-12-26",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"gte_date": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_lteDate(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "2022-12-25",
-					"name1": "2022-12-25",
-				}, map[string]string{
-					"name":  "required|lte_date:2022-12-25",
-					"name1": "required|lte_date:2022-12-26",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "2022-12-25",
-				}, map[string]string{
-					"name": "required|lte_date:2022-12-24",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"lte_date": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Alpha(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abcABC",
-				}, map[string]string{
-					"name": "required|alpha",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "abcABC123",
-					"name1": "abc.",
-				}, map[string]string{
-					"name":  "required|alpha",
-					"name1": "required|alpha",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"alpha": "name value contains only alpha char"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"alpha": "name1 value contains only alpha char"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_AlphaNum(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abcABC123",
-				}, map[string]string{
-					"name": "required|alpha_num",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abcABC123.",
-				}, map[string]string{
-					"name": "required|alpha_num",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"alpha_num": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_AlphaDash(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abcABC123-_",
-				}, map[string]string{
-					"name": "required|alpha_dash",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "abcABC123-_.",
-				}, map[string]string{
-					"name": "required|alpha_dash",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"alpha_dash": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Json(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "{\"a\":1}",
-				}, map[string]string{
-					"name": "required|json",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|json",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"json": "name value should be a json string"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Number(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": 1,
-				}, map[string]string{
-					"name": "required|number",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|number",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"number": "name field did not pass validation"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_FullUrl(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "https://www.goravel.dev",
-					"name1": "http://www.goravel.dev",
-				}, map[string]string{
-					"name":  "required|full_url",
-					"name1": "required|full_url",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "a",
-				}, map[string]string{
-					"name": "required|full_url",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"full_url": "name must be a valid full URL address"}, validator.Errors().Get("name"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Ip(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "192.168.1.1",
-					"name1": "FE80:CD00:0000:0CDE:1257:0000:211E:729C",
-				}, map[string]string{
-					"name":  "required|ip",
-					"name1": "required|ip",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "192.168.1.300",
-				}, map[string]string{
-					"name":  "required|ip",
-					"name1": "required|ip",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ip": "name value should be an IP (v4 or v6) string"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"ip": "name1 value should be an IP (v4 or v6) string"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Ipv4(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "192.168.1.1",
-				}, map[string]string{
-					"name": "required|ipv4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "FE80:CD00:0000:0CDE:1257:0000:211E:729C",
-					"name2": "192.168.1.300",
-				}, map[string]string{
-					"name":  "required|ipv4",
-					"name1": "required|ipv4",
-					"name2": "required|ipv4",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ipv4": "name value should be an IPv4 string"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"ipv4": "name1 value should be an IPv4 string"}, validator.Errors().Get("name1"))
-				assert.Equal(t, map[string]string{"ipv4": "name2 value should be an IPv4 string"}, validator.Errors().Get("name2"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestRule_Ipv6(t *testing.T) {
-	validation := NewValidation()
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name": "FE80:CD00:0000:0CDE:1257:0000:211E:729C",
-				}, map[string]string{
-					"name": "required|ipv6",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":  "a",
-					"name1": "192.168.1.300",
-				}, map[string]string{
-					"name":  "required|ipv6",
-					"name1": "required|ipv6",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"ipv6": "name value should be an IPv6 string"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"ipv6": "name1 value should be an IPv6 string"}, validator.Errors().Get("name1"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-func TestAddRule(t *testing.T) {
-	validation := NewValidation()
-	err := validation.AddRules([]httpvalidate.Rule{&Uppercase{}})
-	assert.Nil(t, err)
-
-	err = validation.AddRules([]httpvalidate.Rule{&Duplicate{}})
-	assert.EqualError(t, err, "duplicate rule name: required")
-}
-
-func TestAddFilters(t *testing.T) {
-	validation := NewValidation()
-	err := validation.AddFilters([]httpvalidate.Filter{&DefaultFilter{}, &Arr2Str{}})
-	assert.Nil(t, err)
-
-	filters := validation.Filters()
-	defaultFilterFunc := filters[0].Handle(context.Background()).(func(string, ...string) string)
-	arr2StrFilterFunc := filters[1].Handle(context.Background()).(func(any, string) string)
-	assert.Equal(t, "default", defaultFilterFunc("", "default"))
-	assert.Equal(t, "a", defaultFilterFunc("a"))
-	assert.Equal(t, "a,b", arr2StrFilterFunc([]string{"a", "b"}, ","))
-}
-
-func TestFilters(t *testing.T) {
-	mp := map[string]any{
-		"name":      "krishan ",
-		"age":       " 22 ",
-		"empty":     "",
-		"languages": "cpp, go",
-		"numbers":   []int{1, 2, 3},
-	}
-
-	validation := NewValidation()
-	err := validation.AddFilters([]httpvalidate.Filter{&DefaultFilter{}, &Arr2Str{}})
-	assert.Nil(t, err)
-
-	validator, err := validation.Make(context.Background(), mp, map[string]string{
-		"name, age, empty, languages, numbers": "required",
-	}, Filters(map[string]string{
-		"empty":          "default:emptyDefault",
-		"name":           "trim|upper",
-		"age, not-exist": "trim|int",
-		"languages":      "str2arr:,",
-		"numbers":        "arr2str:,",
-	}))
-
-	assert.Nil(t, err)
-	var newMp map[string]any
-	assert.Nil(t, validator.Bind(&newMp))
-
-	assert.Equal(t, "KRISHAN", newMp["name"])
-	assert.Equal(t, 22, newMp["age"])
-	assert.Equal(t, "emptyDefault", newMp["empty"])
-	assert.Equal(t, []string{"cpp", "go"}, newMp["languages"])
-	assert.Equal(t, "1,2,3", newMp["numbers"])
-}
-
-type DefaultFilter struct {
-}
-
-func (receiver *DefaultFilter) Signature() string {
-	return "default"
-}
-
-func (receiver *DefaultFilter) Handle(ctx context.Context) any {
-	return func(val string, def ...string) string {
-		if val == "" {
-			if len(def) > 0 {
-				return def[0]
-			}
-		}
-
-		return val
-	}
-}
-
-type Arr2Str struct {
+type CustomUppercase struct {
 }
 
-func (receiver *Arr2Str) Signature() string {
-	return "arr2str"
+func (receiver *CustomUppercase) Signature() string {
+	return "custom_uppercase"
 }
 
-func (receiver *Arr2Str) Handle(ctx context.Context) any {
-	return func(val any, sep string) string {
-		return strings.Join(cast.ToStringSlice(val), sep)
-	}
-}
-
-func TestCustomRule(t *testing.T) {
-	validation := NewValidation()
-	err := validation.AddRules([]httpvalidate.Rule{&Uppercase{}, &Lowercase{}})
-	assert.Nil(t, err)
-
-	tests := []Case{
-		{
-			description: "success",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":    "ABC",
-					"address": "de",
-				}, map[string]string{
-					"name":    "required|uppercase:3",
-					"address": "required|lowercase:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.False(t, validator.Fails(), c.description)
-			},
-		},
-		{
-			description: "error",
-			setup: func(c Case) {
-				validator, err := validation.Make(context.Background(), map[string]any{
-					"name":    "abc",
-					"address": "DE",
-				}, map[string]string{
-					"name":    "required|uppercase:3",
-					"address": "required|lowercase:2",
-				})
-				assert.Nil(t, err, c.description)
-				assert.NotNil(t, validator, c.description)
-				assert.Equal(t, map[string]string{"uppercase": "name must be upper"}, validator.Errors().Get("name"))
-				assert.Equal(t, map[string]string{"lowercase": "address must be lower"}, validator.Errors().Get("address"))
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.description, func(t *testing.T) {
-			test.setup(test)
-		})
-	}
-}
-
-type Uppercase struct {
-}
-
-// Signature The name of the rule.
-func (receiver *Uppercase) Signature() string {
-	return "uppercase"
-}
-
-// Passes Determine if the validation rule passes.
-func (receiver *Uppercase) Passes(ctx context.Context, data httpvalidate.Data, val any, options ...any) bool {
+func (receiver *CustomUppercase) Passes(ctx context.Context, data httpvalidate.Data, val any, options ...any) bool {
 	name, exist := data.Get("name")
 
 	if len(options) > 0 {
@@ -2945,21 +1156,18 @@ func (receiver *Uppercase) Passes(ctx context.Context, data httpvalidate.Data, v
 	return false
 }
 
-// Message Get the validation error message.
-func (receiver *Uppercase) Message(ctx context.Context) string {
+func (receiver *CustomUppercase) Message(ctx context.Context) string {
 	return ":attribute must be upper"
 }
 
-type Lowercase struct {
+type CustomLowercase struct {
 }
 
-// Signature The name of the rule.
-func (receiver *Lowercase) Signature() string {
-	return "lowercase"
+func (receiver *CustomLowercase) Signature() string {
+	return "custom_lowercase"
 }
 
-// Passes Determine if the validation rule passes.
-func (receiver *Lowercase) Passes(ctx context.Context, data httpvalidate.Data, val any, options ...any) bool {
+func (receiver *CustomLowercase) Passes(ctx context.Context, data httpvalidate.Data, val any, options ...any) bool {
 	address, exist := data.Get("address")
 
 	if len(options) > 0 {
@@ -2969,25 +1177,40 @@ func (receiver *Lowercase) Passes(ctx context.Context, data httpvalidate.Data, v
 	return false
 }
 
-// Message Get the validation error message.
-func (receiver *Lowercase) Message(ctx context.Context) string {
+func (receiver *CustomLowercase) Message(ctx context.Context) string {
 	return ":attribute must be lower"
 }
 
 type Duplicate struct {
 }
 
-// Signature The name of the rule.
 func (receiver *Duplicate) Signature() string {
 	return "required"
 }
 
-// Passes Determine if the validation rule passes.
 func (receiver *Duplicate) Passes(ctx context.Context, data httpvalidate.Data, val any, options ...any) bool {
 	return true
 }
 
-// Message Get the validation error message.
 func (receiver *Duplicate) Message(ctx context.Context) string {
 	return ""
-}*/
+}
+
+type DefaultFilter struct {
+}
+
+func (receiver *DefaultFilter) Signature() string {
+	return "default"
+}
+
+func (receiver *DefaultFilter) Handle(ctx context.Context) any {
+	return func(val string, def ...string) string {
+		if val == "" {
+			if len(def) > 0 {
+				return def[0]
+			}
+		}
+
+		return val
+	}
+}
diff --git a/validation/validator_test.go b/validation/validator_test.go
index 8ff104195..da16c399f 100644
--- a/validation/validator_test.go
+++ b/validation/validator_test.go
@@ -1,6 +1,27 @@
 package validation
 
-/*func TestBind_Rule(t *testing.T) {
+import (
+	"bytes"
+	"context"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/goravel/framework/errors"
+	"github.com/goravel/framework/foundation/json"
+	"github.com/goravel/framework/support/carbon"
+	"github.com/goravel/framework/support/convert"
+)
+
+func TestBind_Rule(t *testing.T) {
 	type Embed struct {
 		C string `form:"c" json:"c"`
 	}
@@ -30,14 +51,14 @@ package validation
 
 	tests := []struct {
 		name   string
-		data   validate.DataFace
-		rules  map[string]string
+		data   any
+		rules  map[string]any
 		assert func(data Data)
 	}{
 		{
 			name:  "data is map and key is lowercase",
-			data:  validate.FromMap(map[string]any{"a": "aa", "b": "1"}),
-			rules: map[string]string{"a": "required"},
+			data:  map[string]any{"a": "aa", "b": "1"},
+			rules: map[string]any{"a": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "aa", data.A)
 				assert.Equal(t, 1, data.B)
@@ -45,35 +66,30 @@ package validation
 		},
 		{
 			name:  "data is map and cast key",
-			data:  validate.FromMap(map[string]any{"b": "1"}),
-			rules: map[string]string{"b": "required"},
+			data:  map[string]any{"b": "1"},
+			rules: map[string]any{"b": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, 1, data.B)
 			},
 		},
 		{
 			name:  "data is map and key is uppercase",
-			data:  validate.FromMap(map[string]any{"A": "aa"}),
-			rules: map[string]string{"A": "required"},
+			data:  map[string]any{"A": "aa"},
+			rules: map[string]any{"A": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "aa", data.A)
 			},
 		},
 		{
 			name: "data is struct",
-			data: func() validate.DataFace {
-				data, err := validate.FromStruct(&struct {
-					A string
-					B int
-				}{
-					A: "a",
-					B: 1,
-				})
-				assert.Nil(t, err)
-
-				return data
-			}(),
-			rules: map[string]string{"A": "required"},
+			data: &struct {
+				A string
+				B int
+			}{
+				A: "a",
+				B: 1,
+			},
+			rules: map[string]any{"A": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "a", data.A)
 				assert.Equal(t, 1, data.B)
@@ -81,15 +97,12 @@ package validation
 		},
 		{
 			name: "data is get request",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodGet, "/?a=aa&&b=1", nil)
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"a": "required"},
+			rules: map[string]any{"a": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "aa", data.A)
 				assert.Equal(t, 1, data.B)
@@ -97,37 +110,25 @@ package validation
 		},
 		{
 			name: "data is get request with names",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodGet, "/?names=a&names=b", nil)
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"names": "required|array|len:2"},
+			rules: map[string]any{"names": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, []string{"a", "b"}, data.Names)
 			},
 		},
 		{
 			name: "data is post request",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"a":"Goravel", "b": 1, "ages": [1, 2], "names": ["a", "b"]}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				age, exist := data.Get("ages")
-				assert.True(t, exist)
-
-				_, err = data.Set("ages", cast.ToIntSlice(age))
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"a": "required", "ages.*": "int", "names.*": "string"},
+			rules: map[string]any{"a": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "Goravel", data.A)
 				assert.Equal(t, 1, data.B)
@@ -137,456 +138,348 @@ package validation
 		},
 		{
 			name: "data is post request with Carbon",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"carbon": "2024-07-04 10:00:52"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"carbon": "string"},
+			rules: map[string]any{"carbon": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.Carbon.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": "2024-07-04 10:00:52"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "string"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime(string)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": "1720087252"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "required"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": 1720087252}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "required"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime(milli)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": 1720087252000}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "required"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime(micro)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": 1720087252000000}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "required"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTime(nano)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time": 1720087252000000000}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time": "required"},
+			rules: map[string]any{"date_time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.DateTime.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with DateTimeMilli",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time_milli": "2024-07-04 10:00:52.123"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time_milli": "string"},
+			rules: map[string]any{"date_time_milli": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123", data.DateTimeMilli.ToDateTimeMilliString())
 			},
 		},
 		{
 			name: "data is post request with DateTimeMilli(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time_milli": 1720087252123}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time_milli": "required"},
+			rules: map[string]any{"date_time_milli": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123", data.DateTimeMilli.ToDateTimeMilliString())
 			},
 		},
 		{
 			name: "data is post request with DateTimeMicro",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time_micro": "2024-07-04 10:00:52.123456"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time_micro": "string"},
+			rules: map[string]any{"date_time_micro": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123456", data.DateTimeMicro.ToDateTimeMicroString())
 			},
 		},
 		{
 			name: "data is post request with DateTimeNano",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time_nano": "2024-07-04 10:00:52.123456789"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time_nano": "string"},
+			rules: map[string]any{"date_time_nano": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123456789", data.DateTimeNano.ToDateTimeNanoString())
 			},
 		},
 		{
 			name: "data is post request with DateTimeNano(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_time_nano": "1720087252123456789"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_time_nano": "required"},
+			rules: map[string]any{"date_time_nano": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123456789", data.DateTimeNano.ToDateTimeNanoString())
 			},
 		},
 		{
 			name: "data is post request with Date",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date": "2024-07-04"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date": "string"},
+			rules: map[string]any{"date": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04", data.Date.ToDateString())
 			},
 		},
 		{
 			name: "data is post request with Date(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date": 1720087252}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date": "required"},
+			rules: map[string]any{"date": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04", data.Date.ToDateString())
 			},
 		},
 		{
 			name: "data is post request with DateMilli",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_milli": "2024-07-04.123"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_milli": "string"},
+			rules: map[string]any{"date_milli": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123", data.DateMilli.ToDateMilliString())
 			},
 		},
 		{
 			name: "data is post request with DateMilli(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_milli": 1720087252123}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_milli": "required"},
+			rules: map[string]any{"date_milli": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123", data.DateMilli.ToDateMilliString())
 			},
 		},
 		{
 			name: "data is post request with DateMicro",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_micro": "2024-07-04.123456"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_micro": "string"},
+			rules: map[string]any{"date_micro": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123456", data.DateMicro.ToDateMicroString())
 			},
 		},
 		{
 			name: "data is post request with DateMicro(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_micro": 1720087252123456}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_micro": "required"},
+			rules: map[string]any{"date_micro": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123456", data.DateMicro.ToDateMicroString())
 			},
 		},
 		{
 			name: "data is post request with DateNano",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_nano": "2024-07-04.123456789"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_nano": "string"},
+			rules: map[string]any{"date_nano": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123456789", data.DateNano.ToDateNanoString())
 			},
 		},
 		{
 			name: "data is post request with DateNano(int)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"date_nano": "1720087252123456789"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"date_nano": "required"},
+			rules: map[string]any{"date_nano": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04.123456789", data.DateNano.ToDateNanoString())
 			},
 		},
 		{
 			name: "data is post request with Timestamp",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"timestamp": 1720087252}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"timestamp": "required"},
+			rules: map[string]any{"timestamp": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52", data.Timestamp.ToDateTimeString())
 			},
 		},
 		{
 			name: "data is post request with TimestampMilli",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"timestamp_milli": 1720087252123}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"timestamp_milli": "required"},
+			rules: map[string]any{"timestamp_milli": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123", data.TimestampMilli.ToDateTimeMilliString())
 			},
 		},
 		{
 			name: "data is post request with TimestampMicro",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"timestamp_micro": 1720087252123456}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"timestamp_micro": "required"},
+			rules: map[string]any{"timestamp_micro": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123456", data.TimestampMicro.ToDateTimeMicroString())
 			},
 		},
 		{
 			name: "data is post request with TimestampNano",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"timestamp_nano": "1720087252123456789"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"timestamp_nano": "required"},
+			rules: map[string]any{"timestamp_nano": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2024-07-04 10:00:52.123456789", data.TimestampNano.ToDateTimeNanoString())
 			},
 		},
 		{
 			name: "data is post request with Time",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"time": "2025-05-23 22:16:39"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"time": "required"},
+			rules: map[string]any{"time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2025-05-23 22:16:39", data.Time.Format("2006-01-02 15:04:05"))
 			},
 		},
 		{
 			name: "data is post request with Time(date)",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBufferString(`{"time": "2025-05-23"}`))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules: map[string]string{"time": "required"},
+			rules: map[string]any{"time": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "2025-05-23", data.Time.Format("2006-01-02"))
 			},
 		},
 		{
 			name: "data is post request with body",
-			data: func() validate.DataFace {
-				request := buildRequest(t)
-				data, err := validate.FromRequest(request, 1)
-				assert.Nil(t, err)
-
-				return data
+			data: func() *http.Request {
+				return buildRequest(t)
 			}(),
-			rules: map[string]string{"a": "required", "file": "file"},
+			rules: map[string]any{"a": "required", "file": "file"},
 			assert: func(data Data) {
 				request := buildRequest(t)
 				_, file, err := request.FormFile("file")
@@ -599,14 +492,10 @@ package validation
 		},
 		{
 			name: "data is post request with multiple files",
-			data: func() validate.DataFace {
-				request := buildRequestWithMultipleFiles(t)
-				data, err := validate.FromRequest(request, 1)
-				assert.Nil(t, err)
-
-				return data
+			data: func() *http.Request {
+				return buildRequestWithMultipleFiles(t)
 			}(),
-			rules: map[string]string{"a": "required", "files": "file"},
+			rules: map[string]any{"a": "required", "files": "file"},
 			assert: func(data Data) {
 				request := buildRequestWithMultipleFiles(t)
 				_, file, err := request.FormFile("files")
@@ -620,8 +509,8 @@ package validation
 		},
 		{
 			name:  "data has embed struct field",
-			data:  validate.FromMap(map[string]any{"c": "cc"}),
-			rules: map[string]string{"c": "required"},
+			data:  map[string]any{"c": "cc"},
+			rules: map[string]any{"c": "required"},
 			assert: func(data Data) {
 				assert.Equal(t, "cc", data.C)
 			},
@@ -652,61 +541,53 @@ func TestBind_Filter(t *testing.T) {
 
 	tests := []struct {
 		name    string
-		data    validate.DataFace
-		rules   map[string]string
-		filters map[string]string
+		data    any
+		rules   map[string]any
+		filters map[string]any
 		assert  func(data Data)
 	}{
 		{
 			name:    "data is map and key is lowercase",
-			data:    validate.FromMap(map[string]any{"a": " a ", "b": "1"}),
-			rules:   map[string]string{"a": "required", "b": "required"},
-			filters: map[string]string{"a": "trim", "b": "int"},
+			data:    map[string]any{"a": " a ", "b": "1"},
+			rules:   map[string]any{"a": "required", "b": "required"},
+			filters: map[string]any{"a": "trim", "b": "to_int"},
 			assert: func(data Data) {
 				assert.Equal(t, "a", data.A)
 				assert.Equal(t, 1, data.B)
 			},
 		},
 		{
-			name:    "data is map and key is lowercase, a no rule but has filter, a should keep the original value.",
-			data:    validate.FromMap(map[string]any{"a": "a", "b": " 1"}),
-			rules:   map[string]string{"b": "required"},
-			filters: map[string]string{"a": "upper", "b": "trim|int"},
+			name:    "data is map and key is lowercase, has filters",
+			data:    map[string]any{"a": "a", "b": " 1"},
+			rules:   map[string]any{"b": "required"},
+			filters: map[string]any{"a": "upper", "b": "trim|to_int"},
 			assert: func(data Data) {
-				assert.Equal(t, "a", data.A)
+				assert.Equal(t, "A", data.A)
 				assert.Equal(t, 1, data.B)
 			},
 		},
 		{
 			name: "data is struct",
-			data: func() validate.DataFace {
-				data, err := validate.FromStruct(&struct {
-					A string
-				}{
-					A: " a ",
-				})
-				assert.Nil(t, err)
-
-				return data
-			}(),
-			rules:   map[string]string{"A": "required"},
-			filters: map[string]string{"A": "trim"},
+			data: &struct {
+				A string
+			}{
+				A: " a ",
+			},
+			rules:   map[string]any{"A": "required"},
+			filters: map[string]any{"A": "trim"},
 			assert: func(data Data) {
 				assert.Equal(t, "a", data.A)
 			},
 		},
 		{
 			name: "data is get request",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				request, err := http.NewRequest(http.MethodGet, "/?a= a &&b=1", nil)
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules:   map[string]string{"a": "required", "b": "required"},
-			filters: map[string]string{"a": "trim"},
+			rules:   map[string]any{"a": "required", "b": "required"},
+			filters: map[string]any{"a": "trim"},
 			assert: func(data Data) {
 				assert.Equal(t, "a", data.A)
 				assert.Equal(t, 1, data.B)
@@ -714,7 +595,7 @@ func TestBind_Filter(t *testing.T) {
 		},
 		{
 			name: "data is post request with body",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				payload := &bytes.Buffer{}
 				writer := multipart.NewWriter(payload)
 
@@ -726,13 +607,10 @@ func TestBind_Filter(t *testing.T) {
 				assert.Nil(t, err)
 				request.Header.Set("Content-Type", writer.FormDataContentType())
 
-				data, err := validate.FromRequest(request, 1)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
-			rules:   map[string]string{"a": "required", "file": "file"},
-			filters: map[string]string{"a": "trim"},
+			rules:   map[string]any{"a": "required", "file": "file"},
+			filters: map[string]any{"a": "trim"},
 			assert: func(data Data) {
 				assert.Equal(t, "a", data.A)
 			},
@@ -756,36 +634,31 @@ func TestBind_Filter(t *testing.T) {
 }
 
 func TestFails(t *testing.T) {
-	var maker *Validation
 	tests := []struct {
 		describe  string
 		data      any
-		rules     map[string]string
-		filters   map[string]string
+		rules     map[string]any
 		expectRes bool
 	}{
 		{
 			describe: "false",
 			data:     map[string]any{"a": "aa"},
-			rules:    map[string]string{"a": "required"},
-			filters:  map[string]string{},
+			rules:    map[string]any{"a": "required"},
 		},
 		{
 			describe:  "true",
 			data:      map[string]any{"b": "bb"},
-			rules:     map[string]string{"a": "required"},
-			filters:   map[string]string{},
+			rules:     map[string]any{"a": "required"},
 			expectRes: true,
 		},
 	}
 
 	for _, test := range tests {
-		maker = NewValidation()
+		maker := NewValidation()
 		validator, err := maker.Make(
 			context.Background(),
 			test.data,
 			test.rules,
-			Filters(test.filters),
 		)
 		assert.Nil(t, err)
 		assert.Equal(t, test.expectRes, validator.Fails(), test.describe)
@@ -902,12 +775,12 @@ func TestCastValue(t *testing.T) {
 
 	tests := []struct {
 		name    string
-		data    validate.DataFace
+		data    any
 		wantErr error
 	}{
 		{
 			name: "success with struct",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				body := &Data{
 					String:                "1",
 					Int:                   1,
@@ -962,15 +835,12 @@ func TestCastValue(t *testing.T) {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBuffer(jsonBytes))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
 		},
 		{
 			name: "success with map",
-			data: func() validate.DataFace {
+			data: func() *http.Request {
 				body := map[string]any{
 					"String":                "1",
 					"Int":                   "1",
@@ -1025,10 +895,7 @@ func TestCastValue(t *testing.T) {
 				request, err := http.NewRequest(http.MethodPost, "/", bytes.NewBuffer(jsonBytes))
 				request.Header.Set("Content-Type", "application/json")
 				assert.Nil(t, err)
-				data, err := validate.FromRequest(request)
-				assert.Nil(t, err)
-
-				return data
+				return request
 			}(),
 		},
 	}
@@ -1036,7 +903,7 @@ func TestCastValue(t *testing.T) {
 	validation := NewValidation()
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			validator, err := validation.Make(context.Background(), test.data, map[string]string{
+			validator, err := validation.Make(context.Background(), test.data, map[string]any{
 				"String": "required",
 			})
 			assert.Nil(t, err)
@@ -1157,7 +1024,7 @@ func TestCastCarbon(t *testing.T) {
 			},
 		},
 		{
-			name: "Happy path - length 19 int",
+			name: "Happy path - length 19 string",
 			from: reflect.ValueOf("1720087252123456789"),
 			transform: func(c *carbon.Carbon) any {
 				return carbon.NewTimestampNano(c)
@@ -1257,4 +1124,4 @@ func buildRequestWithMultipleFiles(t *testing.T) *http.Request {
 	request.Header.Set("Content-Type", writer.FormDataContentType())
 
 	return request
-}*/
+}

From c128677e3cf51341c3736529f07f06cf8316111e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 04:09:47 +0800
Subject: [PATCH 02/11] feat: optimize code

---
 validation/rules.go      |  30 +++++----
 validation/rules_test.go |   6 +-
 validation/utils.go      | 142 +++++++--------------------------------
 validation/utils_test.go |   8 ---
 validation/validation.go |   3 +-
 5 files changed, 45 insertions(+), 144 deletions(-)

diff --git a/validation/rules.go b/validation/rules.go
index 390f29aa9..d2310a78b 100644
--- a/validation/rules.go
+++ b/validation/rules.go
@@ -21,6 +21,8 @@ import (
 	"time"
 	"unicode"
 	"unicode/utf8"
+
+	"github.com/spf13/cast"
 )
 
 // RuleContext provides context for rule evaluation.
@@ -217,7 +219,7 @@ func ruleRequired(ctx *RuleContext) bool {
 	if ctx.Value == nil {
 		return false
 	}
-	return isValuePresent(ctx.Value)
+	return !isValueEmpty(ctx.Value)
 }
 
 func ruleRequiredIf(ctx *RuleContext) bool {
@@ -238,7 +240,7 @@ func ruleRequiredUnless(ctx *RuleContext) bool {
 
 func ruleRequiredWith(ctx *RuleContext) bool {
 	for _, field := range ctx.Parameters {
-		if val, ok := ctx.Data.Get(field); ok && isValuePresent(val) {
+		if val, ok := ctx.Data.Get(field); ok && !isValueEmpty(val) {
 			return ruleRequired(ctx)
 		}
 	}
@@ -248,7 +250,7 @@ func ruleRequiredWith(ctx *RuleContext) bool {
 func ruleRequiredWithAll(ctx *RuleContext) bool {
 	allPresent := true
 	for _, field := range ctx.Parameters {
-		if val, ok := ctx.Data.Get(field); !ok || !isValuePresent(val) {
+		if val, ok := ctx.Data.Get(field); !ok || isValueEmpty(val) {
 			allPresent = false
 			break
 		}
@@ -261,7 +263,7 @@ func ruleRequiredWithAll(ctx *RuleContext) bool {
 
 func ruleRequiredWithout(ctx *RuleContext) bool {
 	for _, field := range ctx.Parameters {
-		if val, ok := ctx.Data.Get(field); !ok || !isValuePresent(val) {
+		if val, ok := ctx.Data.Get(field); !ok || isValueEmpty(val) {
 			return ruleRequired(ctx)
 		}
 	}
@@ -271,7 +273,7 @@ func ruleRequiredWithout(ctx *RuleContext) bool {
 func ruleRequiredWithoutAll(ctx *RuleContext) bool {
 	nonePresent := true
 	for _, field := range ctx.Parameters {
-		if val, ok := ctx.Data.Get(field); ok && isValuePresent(val) {
+		if val, ok := ctx.Data.Get(field); ok && !isValueEmpty(val) {
 			nonePresent = false
 			break
 		}
@@ -308,7 +310,7 @@ func ruleFilled(ctx *RuleContext) bool {
 	if !ctx.Data.Has(ctx.Attribute) {
 		return true // Not present = ok for filled
 	}
-	return isValuePresent(ctx.Value)
+	return !isValueEmpty(ctx.Value)
 }
 
 func rulePresent(ctx *RuleContext) bool {
@@ -390,25 +392,25 @@ func ruleMissingWithAll(ctx *RuleContext) bool {
 // ---- Accept/Decline Rules ----
 
 func ruleAccepted(ctx *RuleContext) bool {
-	return isValuePresent(ctx.Value) && isAcceptedValue(ctx.Value)
+	return !isValueEmpty(ctx.Value) && isAcceptedValue(ctx.Value)
 }
 
 func ruleAcceptedIf(ctx *RuleContext) bool {
 	otherValue, comparisonValues, _ := parseDependentValues(ctx)
 	if matchesOtherValue(otherValue, comparisonValues) {
-		return isValuePresent(ctx.Value) && isAcceptedValue(ctx.Value)
+		return !isValueEmpty(ctx.Value) && isAcceptedValue(ctx.Value)
 	}
 	return true
 }
 
 func ruleDeclined(ctx *RuleContext) bool {
-	return isValuePresent(ctx.Value) && isDeclinedValue(ctx.Value)
+	return !isValueEmpty(ctx.Value) && isDeclinedValue(ctx.Value)
 }
 
 func ruleDeclinedIf(ctx *RuleContext) bool {
 	otherValue, comparisonValues, _ := parseDependentValues(ctx)
 	if matchesOtherValue(otherValue, comparisonValues) {
-		return isValuePresent(ctx.Value) && isDeclinedValue(ctx.Value)
+		return !isValueEmpty(ctx.Value) && isDeclinedValue(ctx.Value)
 	}
 	return true
 }
@@ -498,8 +500,8 @@ func ruleInteger(ctx *RuleContext) bool {
 }
 
 func ruleNumeric(ctx *RuleContext) bool {
-	_, ok := toFloat64(ctx.Value)
-	return ok
+	_, err := cast.ToFloat64E(ctx.Value)
+	return err == nil
 }
 
 func ruleBoolean(ctx *RuleContext) bool {
@@ -806,8 +808,8 @@ func ruleMultipleOf(ctx *RuleContext) bool {
 	if len(ctx.Parameters) == 0 {
 		return false
 	}
-	val, ok := toFloat64(ctx.Value)
-	if !ok {
+	val, err := cast.ToFloat64E(ctx.Value)
+	if err != nil {
 		return false
 	}
 	divisor, err := strconv.ParseFloat(ctx.Parameters[0], 64)
diff --git a/validation/rules_test.go b/validation/rules_test.go
index 0efe03062..0a235ce0a 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -192,9 +192,9 @@ func (s *RulesTestSuite) TestRequiredWithoutAll() {
 		{"pass_none_present_and_filled", map[string]any{"c": "val"}, map[string]any{"c": "required_without_all:a,b"}, false},
 		{"pass_some_present", map[string]any{"a": "1"}, map[string]any{"c": "required_without_all:a,b"}, false},
 		{"pass_all_present", map[string]any{"a": "1", "b": "2"}, map[string]any{"c": "required_without_all:a,b"}, false},
+		{"pass_one_of_three_present", map[string]any{"b": "2"}, map[string]any{"d": "required_without_all:a,b,c"}, false},
 		{"fail_none_present_and_empty", map[string]any{"other": "x"}, map[string]any{"c": "required_without_all:a,b"}, true},
 		{"fail_none_present_and_missing", map[string]any{}, map[string]any{"c": "required_without_all:a,b"}, true},
-		{"pass_one_of_three_present", map[string]any{"b": "2"}, map[string]any{"d": "required_without_all:a,b,c"}, false},
 	}
 	for _, tt := range tests {
 		s.Run(tt.name, func() {
@@ -214,12 +214,12 @@ func (s *RulesTestSuite) TestRequiredIfAccepted() {
 		{"pass_accepted_and_filled", map[string]any{"terms": true, "sig": "yes"}, map[string]any{"sig": "required_if_accepted:terms"}, false},
 		{"pass_not_accepted_bool", map[string]any{"terms": false}, map[string]any{"sig": "required_if_accepted:terms"}, false},
 		{"pass_not_accepted_string", map[string]any{"terms": "no"}, map[string]any{"sig": "required_if_accepted:terms"}, false},
+		{"pass_other_field_missing", map[string]any{}, map[string]any{"sig": "required_if_accepted:terms"}, false},
 		{"fail_accepted_bool_and_missing", map[string]any{"terms": true}, map[string]any{"sig": "required_if_accepted:terms"}, true},
 		{"fail_accepted_string_yes", map[string]any{"terms": "yes"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
 		{"fail_accepted_string_on", map[string]any{"terms": "on"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
 		{"fail_accepted_string_1", map[string]any{"terms": "1"}, map[string]any{"sig": "required_if_accepted:terms"}, true},
 		{"fail_accepted_int_1", map[string]any{"terms": 1}, map[string]any{"sig": "required_if_accepted:terms"}, true},
-		{"pass_other_field_missing", map[string]any{}, map[string]any{"sig": "required_if_accepted:terms"}, false},
 	}
 	for _, tt := range tests {
 		s.Run(tt.name, func() {
@@ -239,12 +239,12 @@ func (s *RulesTestSuite) TestRequiredIfDeclined() {
 		{"pass_declined_and_filled", map[string]any{"auto": false, "reason": "manual"}, map[string]any{"reason": "required_if_declined:auto"}, false},
 		{"pass_not_declined_bool", map[string]any{"auto": true}, map[string]any{"reason": "required_if_declined:auto"}, false},
 		{"pass_not_declined_string", map[string]any{"auto": "yes"}, map[string]any{"reason": "required_if_declined:auto"}, false},
+		{"pass_other_field_missing", map[string]any{}, map[string]any{"reason": "required_if_declined:auto"}, false},
 		{"fail_declined_bool_and_missing", map[string]any{"auto": false}, map[string]any{"reason": "required_if_declined:auto"}, true},
 		{"fail_declined_string_no", map[string]any{"auto": "no"}, map[string]any{"reason": "required_if_declined:auto"}, true},
 		{"fail_declined_string_off", map[string]any{"auto": "off"}, map[string]any{"reason": "required_if_declined:auto"}, true},
 		{"fail_declined_string_0", map[string]any{"auto": "0"}, map[string]any{"reason": "required_if_declined:auto"}, true},
 		{"fail_declined_int_0", map[string]any{"auto": 0}, map[string]any{"reason": "required_if_declined:auto"}, true},
-		{"pass_other_field_missing", map[string]any{}, map[string]any{"reason": "required_if_declined:auto"}, false},
 	}
 	for _, tt := range tests {
 		s.Run(tt.name, func() {
diff --git a/validation/utils.go b/validation/utils.go
index b78871b3c..0a8584190 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -1,7 +1,6 @@
 package validation
 
 import (
-	"encoding/json"
 	"fmt"
 	"mime/multipart"
 	"net/url"
@@ -15,6 +14,7 @@ import (
 
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/goravel/framework/contracts/database/orm"
+	"github.com/spf13/cast"
 )
 
 // isValueEmpty checks if a value is considered "empty" for validation purposes.
@@ -92,11 +92,6 @@ func matchesOtherValue(otherValue any, comparisonValues []string) bool {
 	return false
 }
 
-// isControlRule returns true for rule names that are control directives (not actual validation rules).
-func isControlRule(name string) bool {
-	return name == "bail" || name == "nullable" || name == "sometimes"
-}
-
 // dotGet navigates nested maps/slices using path segments.
 func dotGet(data any, segments []string) (any, bool) {
 	if len(segments) == 0 {
@@ -346,78 +341,12 @@ func normalizeValue(rv reflect.Value) any {
 	}
 }
 
-// isValuePresent checks if a value is "present" (not nil/empty).
-func isValuePresent(val any) bool {
-	if val == nil {
-		return false
-	}
-	switch v := val.(type) {
-	case string:
-		return strings.TrimSpace(v) != ""
-	default:
-		rv := reflect.ValueOf(v)
-		switch rv.Kind() {
-		case reflect.Slice, reflect.Array, reflect.Map:
-			return rv.Len() > 0
-		default:
-			return true
-		}
-	}
-}
-
-// toFloat64 attempts to convert a value to float64.
-func toFloat64(val any) (float64, bool) {
-	switch v := val.(type) {
-	case int:
-		return float64(v), true
-	case int8:
-		return float64(v), true
-	case int16:
-		return float64(v), true
-	case int32:
-		return float64(v), true
-	case int64:
-		return float64(v), true
-	case uint:
-		return float64(v), true
-	case uint8:
-		return float64(v), true
-	case uint16:
-		return float64(v), true
-	case uint32:
-		return float64(v), true
-	case uint64:
-		return float64(v), true
-	case float32:
-		return float64(v), true
-	case float64:
-		return v, true
-	case string:
-		f, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
-		if err != nil {
-			return 0, false
-		}
-		return f, true
-	case json.Number:
-		f, err := v.Float64()
-		if err != nil {
-			return 0, false
-		}
-		return f, true
-	case bool:
-		if v {
-			return 1, true
-		}
-		return 0, true
-	}
-	return 0, false
-}
-
 // getSize returns the "size" of a value based on its attribute type.
 func getSize(val any, attrType string) (float64, bool) {
 	switch attrType {
 	case "numeric":
-		return toFloat64(val)
+		num, err := cast.ToFloat64E(val)
+		return num, err == nil
 	case "array":
 		if val == nil {
 			return 0, false
@@ -450,24 +379,9 @@ func getSize(val any, attrType string) (float64, bool) {
 func parseDateValue(val string, data *DataBag) (time.Time, bool) {
 	// Try as a field reference first
 	if fieldVal, ok := data.Get(val); ok {
-		val = fmt.Sprintf("%v", fieldVal)
+		return parseDate(fieldVal)
 	}
-
-	// Try common date formats
-	formats := []string{
-		time.RFC3339,
-		"2006-01-02T15:04:05",
-		"2006-01-02 15:04:05",
-		"2006-01-02",
-		time.RFC1123,
-		time.RFC822,
-	}
-	for _, f := range formats {
-		if t, err := time.Parse(f, val); err == nil {
-			return t, true
-		}
-	}
-	return time.Time{}, false
+	return parseDate(val)
 }
 
 // parseDate attempts to parse a value as a date.
@@ -495,38 +409,30 @@ func parseDate(val any) (time.Time, bool) {
 
 // isAcceptedValue checks if a value is one of the "accepted" values.
 func isAcceptedValue(val any) bool {
+	if val == nil {
+		return false
+	}
 	switch v := val.(type) {
 	case string:
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "yes" || v == "on" || v == "1" || v == "true"
-	case bool:
-		return v
-	case int:
-		return v == 1
-	case int64:
-		return v == 1
-	case float64:
-		return v == 1
 	}
-	return false
+	v := cast.ToInt(val)
+	return v == 1
 }
 
 // isDeclinedValue checks if a value is one of the "declined" values.
 func isDeclinedValue(val any) bool {
+	if val == nil {
+		return false
+	}
 	switch v := val.(type) {
 	case string:
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "no" || v == "off" || v == "0" || v == "false"
-	case bool:
-		return !v
-	case int:
-		return v == 0
-	case int64:
-		return v == 0
-	case float64:
-		return v == 0
 	}
-	return false
+	v := cast.ToInt(val)
+	return v == 0
 }
 
 // parseDependentValues extracts the other field's value and comparison values from parameters.
@@ -596,15 +502,6 @@ func parseUniqueParams(ctx *RuleContext) (table, column, connection string) {
 	return table, column, connection
 }
 
-// getOrmQuery returns an ORM query, optionally with a specific connection.
-func getOrmQuery(ctx *RuleContext, connection string) orm.Query {
-	o := ormFacade.WithContext(ctx.Ctx)
-	if connection != "" {
-		o = o.Connection(connection)
-	}
-	return o.Query()
-}
-
 // toCamelCase converts a string to camelCase.
 func toCamelCase(s string) string {
 	words := splitWords(s)
@@ -694,3 +591,12 @@ func getFileExtension(filename string) string {
 	}
 	return filename[idx+1:]
 }
+
+// getOrmQuery returns an ORM query, optionally with a specific connection.
+func getOrmQuery(ctx *RuleContext, connection string) orm.Query {
+	o := ormFacade.WithContext(ctx.Ctx)
+	if connection != "" {
+		o = o.Connection(connection)
+	}
+	return o.Query()
+}
diff --git a/validation/utils_test.go b/validation/utils_test.go
index d7a8c878a..9fd76753d 100644
--- a/validation/utils_test.go
+++ b/validation/utils_test.go
@@ -78,14 +78,6 @@ func TestMatchesOtherValue(t *testing.T) {
 	})
 }
 
-func TestIsControlRule(t *testing.T) {
-	assert.True(t, isControlRule("bail"))
-	assert.True(t, isControlRule("nullable"))
-	assert.True(t, isControlRule("sometimes"))
-	assert.False(t, isControlRule("required"))
-	assert.False(t, isControlRule("string"))
-}
-
 func TestDotGet(t *testing.T) {
 	data := map[string]any{
 		"user": map[string]any{
diff --git a/validation/validation.go b/validation/validation.go
index 13e3c6b7c..95d01e0c3 100644
--- a/validation/validation.go
+++ b/validation/validation.go
@@ -95,7 +95,8 @@ func (r *Validation) Make(ctx context.Context, data any, rules map[string]any, o
 	// Validate that all rule names are known (builtin, custom, or control)
 	for field, fieldRules := range parsedRules {
 		for _, pr := range fieldRules {
-			if isControlRule(pr.Name) {
+			// skip control rules
+			if slices.Contains([]string{"bail", "sometimes", "nullable"}, pr.Name) {
 				continue
 			}
 			if _, ok := builtinRules[pr.Name]; ok {

From 73bddc0e8ec02f28621e71a8998081f6311c3472 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 04:29:41 +0800
Subject: [PATCH 03/11] feat: optimize code

---
 validation/rules.go         | 115 ++++++++++
 validation/rules_db.go      |  82 -------
 validation/rules_db_test.go | 438 ------------------------------------
 validation/rules_test.go    | 305 +++++++++++++++++++++++++
 validation/utils.go         |  65 ------
 validation/utils_test.go    | 244 ++++++++++++++++++++
 6 files changed, 664 insertions(+), 585 deletions(-)
 delete mode 100644 validation/rules_db.go
 delete mode 100644 validation/rules_db_test.go

diff --git a/validation/rules.go b/validation/rules.go
index d2310a78b..583d0a8ff 100644
--- a/validation/rules.go
+++ b/validation/rules.go
@@ -1672,3 +1672,118 @@ func ruleEncoding(ctx *RuleContext) bool {
 		return false
 	}
 }
+
+// ---- Database Rules ----
+
+// ruleExists validates that the given value exists in the specified database table.
+// Syntax: exists:table,column1,column2,...
+//   - table: required, supports "connection.table" format
+//   - columns: optional, defaults to the current field name. Multiple columns are joined with OR.
+func ruleExists(ctx *RuleContext) bool {
+	if ormFacade == nil || len(ctx.Parameters) == 0 {
+		return false
+	}
+
+	table := ctx.Parameters[0]
+	var connection string
+	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
+		connection = table[:dotIdx]
+		table = table[dotIdx+1:]
+	}
+	if table == "" {
+		return false
+	}
+
+	var columns []string
+	for i := 1; i < len(ctx.Parameters); i++ {
+		if ctx.Parameters[i] != "" {
+			columns = append(columns, ctx.Parameters[i])
+		}
+	}
+	if len(columns) == 0 {
+		columns = []string{ctx.Attribute}
+	}
+
+	o := ormFacade.WithContext(ctx.Ctx)
+	if connection != "" {
+		o = o.Connection(connection)
+	}
+	query := o.Query().Table(table)
+
+	if len(columns) == 1 {
+		query = query.Where(columns[0], ctx.Value)
+	} else {
+		for i, col := range columns {
+			if i == 0 {
+				query = query.Where(col, ctx.Value)
+			} else {
+				query = query.OrWhere(col, ctx.Value)
+			}
+		}
+	}
+
+	exists, err := query.Exists()
+	if err != nil {
+		return false
+	}
+	return exists
+}
+
+// ruleUnique validates that the given value is unique in the specified database table.
+// Syntax: unique:table,column,idColumn,except1,except2,...
+//   - table: required, supports "connection.table" format
+//   - column: optional, defaults to the current field name
+//   - idColumn: optional, defaults to "id", the column to use for the except clause
+//   - except values: optional, values to exclude from the unique check (for update scenarios)
+func ruleUnique(ctx *RuleContext) bool {
+	if ormFacade == nil || len(ctx.Parameters) == 0 {
+		return false
+	}
+
+	table := ctx.Parameters[0]
+	var connection string
+	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
+		connection = table[:dotIdx]
+		table = table[dotIdx+1:]
+	}
+	if table == "" {
+		return false
+	}
+
+	column := ctx.Attribute
+	if len(ctx.Parameters) >= 2 && ctx.Parameters[1] != "" {
+		column = ctx.Parameters[1]
+	}
+
+	o := ormFacade.WithContext(ctx.Ctx)
+	if connection != "" {
+		o = o.Connection(connection)
+	}
+	query := o.Query().Table(table).Where(column, ctx.Value)
+
+	// Handle except (ignore specific records for updates)
+	// Parameters: table, column, idColumn, except1, except2, ...
+	if len(ctx.Parameters) >= 4 {
+		idColumn := "id"
+		if ctx.Parameters[2] != "" {
+			idColumn = ctx.Parameters[2]
+		}
+
+		var exceptValues []any
+		for i := 3; i < len(ctx.Parameters); i++ {
+			if ctx.Parameters[i] != "" {
+				exceptValues = append(exceptValues, ctx.Parameters[i])
+			}
+		}
+
+		if len(exceptValues) > 0 {
+			query = query.WhereNotIn(idColumn, exceptValues)
+		}
+	}
+
+	count, err := query.Count()
+	if err != nil {
+		return false
+	}
+	return count == 0
+}
diff --git a/validation/rules_db.go b/validation/rules_db.go
deleted file mode 100644
index d8043fccd..000000000
--- a/validation/rules_db.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package validation
-
-// ruleExists validates that the given value exists in the specified database table.
-// Syntax: exists:table,column1,column2,...
-//   - table: required, supports "connection.table" format
-//   - columns: optional, defaults to the current field name. Multiple columns are joined with OR.
-func ruleExists(ctx *RuleContext) bool {
-	if ormFacade == nil {
-		return false
-	}
-
-	table, columns, connection := parseExistsParams(ctx)
-	if table == "" {
-		return false
-	}
-
-	query := getOrmQuery(ctx, connection).Table(table)
-
-	if len(columns) == 1 {
-		query = query.Where(columns[0], ctx.Value)
-	} else {
-		// Multiple columns: WHERE col1 = value OR col2 = value OR ...
-		for i, col := range columns {
-			if i == 0 {
-				query = query.Where(col, ctx.Value)
-			} else {
-				query = query.OrWhere(col, ctx.Value)
-			}
-		}
-	}
-
-	exists, err := query.Exists()
-	if err != nil {
-		return false
-	}
-	return exists
-}
-
-// ruleUnique validates that the given value is unique in the specified database table.
-// Syntax: unique:table,column,idColumn,except1,except2,...
-//   - table: required, supports "connection.table" format
-//   - column: optional, defaults to the current field name
-//   - idColumn: optional, defaults to "id", the column to use for the except clause
-//   - except values: optional, values to exclude from the unique check (for update scenarios)
-func ruleUnique(ctx *RuleContext) bool {
-	if ormFacade == nil {
-		return false
-	}
-
-	table, column, connection := parseUniqueParams(ctx)
-	if table == "" {
-		return false
-	}
-
-	query := getOrmQuery(ctx, connection).Table(table).Where(column, ctx.Value)
-
-	// Handle except (ignore specific records for updates)
-	// Parameters: table, column, idColumn, except1, except2, ...
-	if len(ctx.Parameters) >= 4 {
-		idColumn := "id"
-		if len(ctx.Parameters) >= 3 && ctx.Parameters[2] != "" {
-			idColumn = ctx.Parameters[2]
-		}
-
-		var exceptValues []any
-		for i := 3; i < len(ctx.Parameters); i++ {
-			if ctx.Parameters[i] != "" {
-				exceptValues = append(exceptValues, ctx.Parameters[i])
-			}
-		}
-
-		if len(exceptValues) > 0 {
-			query = query.WhereNotIn(idColumn, exceptValues)
-		}
-	}
-
-	count, err := query.Count()
-	if err != nil {
-		return false
-	}
-	return count == 0
-}
diff --git a/validation/rules_db_test.go b/validation/rules_db_test.go
deleted file mode 100644
index d3cde75a2..000000000
--- a/validation/rules_db_test.go
+++ /dev/null
@@ -1,438 +0,0 @@
-package validation
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	mocksorm "github.com/goravel/framework/mocks/database/orm"
-)
-
-type DBRulesTestSuite struct {
-	suite.Suite
-	mockOrm   *mocksorm.Orm
-	mockQuery *mocksorm.Query
-}
-
-func TestDBRulesTestSuite(t *testing.T) {
-	suite.Run(t, new(DBRulesTestSuite))
-}
-
-func (s *DBRulesTestSuite) SetupTest() {
-	s.mockOrm = mocksorm.NewOrm(s.T())
-	s.mockQuery = mocksorm.NewQuery(s.T())
-	ormFacade = s.mockOrm
-}
-
-func (s *DBRulesTestSuite) TearDownTest() {
-	ormFacade = nil
-}
-
-// --- exists rule tests ---
-
-func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_Found() {
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.True(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_NotFound() {
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "notfound@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "notfound@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.False(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_DefaultColumn() {
-	// When no column specified, defaults to field name
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users"},
-	}
-	s.True(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_OR() {
-	// exists:users,email,username — WHERE email = value OR username = value
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().OrWhere("username", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email", "username"},
-	}
-	s.True(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_ThreeFields() {
-	// exists:users,email,username,phone
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "value").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().OrWhere("username", "value").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().OrWhere("phone", "value").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "value",
-		Parameters: []string{"users", "email", "username", "phone"},
-	}
-	s.False(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_ConnectionTable() {
-	// exists:mysql.users,email — specify connection
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Connection("mysql").Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"mysql.users", "email"},
-	}
-	s.True(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_OrmNil() {
-	ormFacade = nil
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.False(ruleExists(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleExists_NoParameters() {
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{},
-	}
-	// No table specified, should return false
-	s.False(ruleExists(ctx))
-}
-
-// --- unique rule tests ---
-
-func (s *DBRulesTestSuite) TestRuleUnique_IsUnique() {
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_NotUnique() {
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "taken@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(1), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "taken@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.False(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_DefaultColumn() {
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_WithExcept() {
-	// unique:users,email,id,5 — exclude record where id=5
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email", "id", "5"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_WithCustomIdColumnAndExcept() {
-	// unique:users,email,user_id,5 — exclude record where user_id=5
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().WhereNotIn("user_id", []any{"5"}).Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email", "user_id", "5"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_WithMultipleExcepts() {
-	// unique:users,email,id,1,2,3 — exclude records where id IN (1, 2, 3)
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().WhereNotIn("id", []any{"1", "2", "3"}).Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email", "id", "1", "2", "3"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_WithDefaultIdColumn() {
-	// unique:users,email,,5 — idColumn defaults to "id"
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email", "", "5"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_ConnectionTable() {
-	// unique:pgsql.users,email
-	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Connection("pgsql").Return(s.mockOrm).Once()
-	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
-	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"pgsql.users", "email"},
-	}
-	s.True(ruleUnique(ctx))
-}
-
-func (s *DBRulesTestSuite) TestRuleUnique_OrmNil() {
-	ormFacade = nil
-
-	ctx := &RuleContext{
-		Ctx:        context.Background(),
-		Attribute:  "email",
-		Value:      "test@example.com",
-		Parameters: []string{"users", "email"},
-	}
-	s.False(ruleUnique(ctx))
-}
-
-// --- parseExistsParams tests ---
-
-func (s *DBRulesTestSuite) TestParseExistsParams() {
-	tests := []struct {
-		name          string
-		attribute     string
-		parameters    []string
-		expectedTable string
-		expectedCols  []string
-		expectedConn  string
-	}{
-		{
-			name:          "no parameters",
-			attribute:     "email",
-			parameters:    []string{},
-			expectedTable: "",
-			expectedCols:  []string{"email"},
-			expectedConn:  "",
-		},
-		{
-			name:          "table only",
-			attribute:     "email",
-			parameters:    []string{"users"},
-			expectedTable: "users",
-			expectedCols:  []string{"email"},
-			expectedConn:  "",
-		},
-		{
-			name:          "table and column",
-			attribute:     "email",
-			parameters:    []string{"users", "user_email"},
-			expectedTable: "users",
-			expectedCols:  []string{"user_email"},
-			expectedConn:  "",
-		},
-		{
-			name:          "table and multiple columns",
-			attribute:     "email",
-			parameters:    []string{"users", "email", "username", "phone"},
-			expectedTable: "users",
-			expectedCols:  []string{"email", "username", "phone"},
-			expectedConn:  "",
-		},
-		{
-			name:          "connection.table",
-			attribute:     "email",
-			parameters:    []string{"mysql.users", "email"},
-			expectedTable: "users",
-			expectedCols:  []string{"email"},
-			expectedConn:  "mysql",
-		},
-	}
-
-	for _, tt := range tests {
-		s.Run(tt.name, func() {
-			ctx := &RuleContext{
-				Attribute:  tt.attribute,
-				Parameters: tt.parameters,
-			}
-			table, cols, conn := parseExistsParams(ctx)
-			s.Equal(tt.expectedTable, table)
-			s.Equal(tt.expectedCols, cols)
-			s.Equal(tt.expectedConn, conn)
-		})
-	}
-}
-
-// --- parseUniqueParams tests ---
-
-func (s *DBRulesTestSuite) TestParseUniqueParams() {
-	tests := []struct {
-		name          string
-		attribute     string
-		parameters    []string
-		expectedTable string
-		expectedCol   string
-		expectedConn  string
-	}{
-		{
-			name:          "no parameters",
-			attribute:     "email",
-			parameters:    []string{},
-			expectedTable: "",
-			expectedCol:   "email",
-			expectedConn:  "",
-		},
-		{
-			name:          "table only",
-			attribute:     "email",
-			parameters:    []string{"users"},
-			expectedTable: "users",
-			expectedCol:   "email",
-			expectedConn:  "",
-		},
-		{
-			name:          "table and column",
-			attribute:     "email",
-			parameters:    []string{"users", "user_email"},
-			expectedTable: "users",
-			expectedCol:   "user_email",
-			expectedConn:  "",
-		},
-		{
-			name:          "connection.table",
-			attribute:     "email",
-			parameters:    []string{"pgsql.users", "email"},
-			expectedTable: "users",
-			expectedCol:   "email",
-			expectedConn:  "pgsql",
-		},
-	}
-
-	for _, tt := range tests {
-		s.Run(tt.name, func() {
-			ctx := &RuleContext{
-				Attribute:  tt.attribute,
-				Parameters: tt.parameters,
-			}
-			table, col, conn := parseUniqueParams(ctx)
-			s.Equal(tt.expectedTable, table)
-			s.Equal(tt.expectedCol, col)
-			s.Equal(tt.expectedConn, conn)
-		})
-	}
-}
diff --git a/validation/rules_test.go b/validation/rules_test.go
index 0a235ce0a..15f068864 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -6,9 +6,11 @@ import (
 	"mime/multipart"
 	"testing"
 
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 
 	contractsvalidation "github.com/goravel/framework/contracts/validation"
+	mocksorm "github.com/goravel/framework/mocks/database/orm"
 )
 
 type RulesTestSuite struct {
@@ -3587,3 +3589,306 @@ func makeFileHeader(t *testing.T, filename string, content []byte) *multipart.Fi
 	}
 	return form.File["file"][0]
 }
+
+// ---- Database Rules Tests ----
+
+type DBRulesTestSuite struct {
+	suite.Suite
+	mockOrm   *mocksorm.Orm
+	mockQuery *mocksorm.Query
+}
+
+func TestDBRulesTestSuite(t *testing.T) {
+	suite.Run(t, new(DBRulesTestSuite))
+}
+
+func (s *DBRulesTestSuite) SetupTest() {
+	s.mockOrm = mocksorm.NewOrm(s.T())
+	s.mockQuery = mocksorm.NewQuery(s.T())
+	ormFacade = s.mockOrm
+}
+
+func (s *DBRulesTestSuite) TearDownTest() {
+	ormFacade = nil
+}
+
+// --- exists rule tests ---
+
+func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_Found() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_SingleColumn_NotFound() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "notfound@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "notfound@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_DefaultColumn() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_OR() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("username", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "username"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_MultipleColumns_ThreeFields() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("username", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().OrWhere("phone", "value").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(false, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "value",
+		Parameters: []string{"users", "email", "username", "phone"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_ConnectionTable() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Connection("mysql").Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Exists().Return(true, nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"mysql.users", "email"},
+	}
+	s.True(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_OrmNil() {
+	ormFacade = nil
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleExists(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleExists_NoParameters() {
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{},
+	}
+	s.False(ruleExists(ctx))
+}
+
+// --- unique rule tests ---
+
+func (s *DBRulesTestSuite) TestRuleUnique_IsUnique() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_NotUnique() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "taken@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(1), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "taken@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_DefaultColumn() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithExcept() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "id", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithCustomIdColumnAndExcept() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("user_id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "user_id", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithMultipleExcepts() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"1", "2", "3"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "id", "1", "2", "3"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_WithDefaultIdColumn() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().WhereNotIn("id", []any{"5"}).Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email", "", "5"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_ConnectionTable() {
+	s.mockOrm.EXPECT().WithContext(mock.Anything).Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Connection("pgsql").Return(s.mockOrm).Once()
+	s.mockOrm.EXPECT().Query().Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Table("users").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Where("email", "test@example.com").Return(s.mockQuery).Once()
+	s.mockQuery.EXPECT().Count().Return(int64(0), nil).Once()
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"pgsql.users", "email"},
+	}
+	s.True(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_OrmNil() {
+	ormFacade = nil
+
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{"users", "email"},
+	}
+	s.False(ruleUnique(ctx))
+}
+
+func (s *DBRulesTestSuite) TestRuleUnique_NoParameters() {
+	ctx := &RuleContext{
+		Ctx:        context.Background(),
+		Attribute:  "email",
+		Value:      "test@example.com",
+		Parameters: []string{},
+	}
+	s.False(ruleUnique(ctx))
+}
diff --git a/validation/utils.go b/validation/utils.go
index 0a8584190..12c2ff5da 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -13,7 +13,6 @@ import (
 	"unicode/utf8"
 
 	"github.com/gabriel-vasile/mimetype"
-	"github.com/goravel/framework/contracts/database/orm"
 	"github.com/spf13/cast"
 )
 
@@ -447,61 +446,6 @@ func parseDependentValues(ctx *RuleContext) (otherValue any, comparisonValues []
 	return
 }
 
-// parseExistsParams extracts table, columns, and connection from exists rule parameters.
-// Supports "connection.table" format for specifying database connection.
-// All parameters after the table name are treated as column names.
-func parseExistsParams(ctx *RuleContext) (table string, columns []string, connection string) {
-	if len(ctx.Parameters) == 0 {
-		return "", []string{ctx.Attribute}, ""
-	}
-
-	table = ctx.Parameters[0]
-
-	// Parse connection.table format
-	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
-		connection = table[:dotIdx]
-		table = table[dotIdx+1:]
-	}
-
-	// Collect all columns from parameters (starting at index 1)
-	for i := 1; i < len(ctx.Parameters); i++ {
-		if ctx.Parameters[i] != "" {
-			columns = append(columns, ctx.Parameters[i])
-		}
-	}
-
-	// Default column to field name if none specified
-	if len(columns) == 0 {
-		columns = []string{ctx.Attribute}
-	}
-
-	return table, columns, connection
-}
-
-// parseUniqueParams extracts table, column, and connection from unique rule parameters.
-// Supports "connection.table" format for specifying database connection.
-func parseUniqueParams(ctx *RuleContext) (table, column, connection string) {
-	if len(ctx.Parameters) == 0 {
-		return "", ctx.Attribute, ""
-	}
-
-	table = ctx.Parameters[0]
-
-	// Parse connection.table format
-	if dotIdx := strings.Index(table, "."); dotIdx > 0 {
-		connection = table[:dotIdx]
-		table = table[dotIdx+1:]
-	}
-
-	// Column defaults to field name
-	column = ctx.Attribute
-	if len(ctx.Parameters) >= 2 && ctx.Parameters[1] != "" {
-		column = ctx.Parameters[1]
-	}
-
-	return table, column, connection
-}
-
 // toCamelCase converts a string to camelCase.
 func toCamelCase(s string) string {
 	words := splitWords(s)
@@ -591,12 +535,3 @@ func getFileExtension(filename string) string {
 	}
 	return filename[idx+1:]
 }
-
-// getOrmQuery returns an ORM query, optionally with a specific connection.
-func getOrmQuery(ctx *RuleContext, connection string) orm.Query {
-	o := ormFacade.WithContext(ctx.Ctx)
-	if connection != "" {
-		o = o.Connection(connection)
-	}
-	return o.Query()
-}
diff --git a/validation/utils_test.go b/validation/utils_test.go
index 9fd76753d..82ba9d6d8 100644
--- a/validation/utils_test.go
+++ b/validation/utils_test.go
@@ -1,9 +1,11 @@
 package validation
 
 import (
+	"context"
 	"net/url"
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -429,6 +431,206 @@ func TestNormalizeValue(t *testing.T) {
 	})
 }
 
+func TestGetSize(t *testing.T) {
+	t.Run("numeric", func(t *testing.T) {
+		size, ok := getSize(42, "numeric")
+		assert.True(t, ok)
+		assert.Equal(t, float64(42), size)
+
+		size, ok = getSize(3.14, "numeric")
+		assert.True(t, ok)
+		assert.Equal(t, 3.14, size)
+
+		size, ok = getSize("100", "numeric")
+		assert.True(t, ok)
+		assert.Equal(t, float64(100), size)
+	})
+
+	t.Run("string", func(t *testing.T) {
+		size, ok := getSize("hello", "string")
+		assert.True(t, ok)
+		assert.Equal(t, float64(5), size)
+
+		size, ok = getSize("你好", "string")
+		assert.True(t, ok)
+		assert.Equal(t, float64(2), size)
+	})
+
+	t.Run("array", func(t *testing.T) {
+		size, ok := getSize([]any{1, 2, 3}, "array")
+		assert.True(t, ok)
+		assert.Equal(t, float64(3), size)
+
+		size, ok = getSize(map[string]any{"a": 1, "b": 2}, "array")
+		assert.True(t, ok)
+		assert.Equal(t, float64(2), size)
+
+		_, ok = getSize(nil, "array")
+		assert.False(t, ok)
+
+		_, ok = getSize("not-array", "array")
+		assert.False(t, ok)
+	})
+}
+
+func TestParseDateValue(t *testing.T) {
+	bag, _ := NewDataBag(map[string]any{
+		"start": "2024-01-15",
+	})
+
+	t.Run("field reference", func(t *testing.T) {
+		dt, ok := parseDateValue("start", bag)
+		assert.True(t, ok)
+		assert.Equal(t, 2024, dt.Year())
+		assert.Equal(t, time.January, dt.Month())
+		assert.Equal(t, 15, dt.Day())
+	})
+
+	t.Run("literal date string", func(t *testing.T) {
+		dt, ok := parseDateValue("2023-06-01", bag)
+		assert.True(t, ok)
+		assert.Equal(t, 2023, dt.Year())
+	})
+
+	t.Run("invalid date", func(t *testing.T) {
+		_, ok := parseDateValue("not-a-date", bag)
+		assert.False(t, ok)
+	})
+
+	t.Run("missing field falls back to literal", func(t *testing.T) {
+		_, ok := parseDateValue("missing_field", bag)
+		assert.False(t, ok)
+	})
+}
+
+func TestParseDate(t *testing.T) {
+	t.Run("time.Time value", func(t *testing.T) {
+		now := time.Now()
+		dt, ok := parseDate(now)
+		assert.True(t, ok)
+		assert.Equal(t, now, dt)
+	})
+
+	t.Run("RFC3339 string", func(t *testing.T) {
+		dt, ok := parseDate("2024-01-15T10:30:00Z")
+		assert.True(t, ok)
+		assert.Equal(t, 2024, dt.Year())
+	})
+
+	t.Run("date only string", func(t *testing.T) {
+		dt, ok := parseDate("2024-01-15")
+		assert.True(t, ok)
+		assert.Equal(t, 15, dt.Day())
+	})
+
+	t.Run("datetime string", func(t *testing.T) {
+		dt, ok := parseDate("2024-01-15 10:30:00")
+		assert.True(t, ok)
+		assert.Equal(t, 10, dt.Hour())
+	})
+
+	t.Run("invalid string", func(t *testing.T) {
+		_, ok := parseDate("not-a-date")
+		assert.False(t, ok)
+	})
+
+	t.Run("non-string non-time", func(t *testing.T) {
+		_, ok := parseDate(12345)
+		assert.False(t, ok)
+	})
+}
+
+func TestIsAcceptedValue(t *testing.T) {
+	tests := []struct {
+		name     string
+		val      any
+		expected bool
+	}{
+		{"nil", nil, false},
+		{"string yes", "yes", true},
+		{"string on", "on", true},
+		{"string 1", "1", true},
+		{"string true", "true", true},
+		{"string no", "no", false},
+		{"string false", "false", false},
+		{"bool true", true, true},
+		{"bool false", false, false},
+		{"int 1", 1, true},
+		{"int 0", 0, false},
+		{"int64 1", int64(1), true},
+		{"float64 1", float64(1), true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, isAcceptedValue(tt.val))
+		})
+	}
+}
+
+func TestIsDeclinedValue(t *testing.T) {
+	tests := []struct {
+		name     string
+		val      any
+		expected bool
+	}{
+		{"nil", nil, false},
+		{"string no", "no", true},
+		{"string off", "off", true},
+		{"string 0", "0", true},
+		{"string false", "false", true},
+		{"string yes", "yes", false},
+		{"string true", "true", false},
+		{"bool false", false, true},
+		{"bool true", true, false},
+		{"int 0", 0, true},
+		{"int 1", 1, false},
+		{"int64 0", int64(0), true},
+		{"float64 0", float64(0), true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, isDeclinedValue(tt.val))
+		})
+	}
+}
+
+func TestParseDependentValues(t *testing.T) {
+	bag, _ := NewDataBag(map[string]any{"status": "active"})
+
+	t.Run("no parameters", func(t *testing.T) {
+		ctx := &RuleContext{Ctx: context.Background(), Data: bag, Parameters: []string{}}
+		otherValue, comparisonValues, otherField := parseDependentValues(ctx)
+		assert.Nil(t, otherValue)
+		assert.Nil(t, comparisonValues)
+		assert.Empty(t, otherField)
+	})
+
+	t.Run("with field and values", func(t *testing.T) {
+		ctx := &RuleContext{Ctx: context.Background(), Data: bag, Parameters: []string{"status", "active", "pending"}}
+		otherValue, comparisonValues, otherField := parseDependentValues(ctx)
+		assert.Equal(t, "active", otherValue)
+		assert.Equal(t, []string{"active", "pending"}, comparisonValues)
+		assert.Equal(t, "status", otherField)
+	})
+
+	t.Run("field only no comparison values", func(t *testing.T) {
+		ctx := &RuleContext{Ctx: context.Background(), Data: bag, Parameters: []string{"status"}}
+		otherValue, comparisonValues, otherField := parseDependentValues(ctx)
+		assert.Equal(t, "active", otherValue)
+		assert.Empty(t, comparisonValues)
+		assert.Equal(t, "status", otherField)
+	})
+
+	t.Run("missing field", func(t *testing.T) {
+		ctx := &RuleContext{Ctx: context.Background(), Data: bag, Parameters: []string{"missing", "val"}}
+		otherValue, comparisonValues, _ := parseDependentValues(ctx)
+		assert.Nil(t, otherValue)
+		assert.Equal(t, []string{"val"}, comparisonValues)
+	})
+}
+
 func TestToCamelCase(t *testing.T) {
 	tests := []struct {
 		input    string
@@ -467,6 +669,28 @@ func TestToSnakeCase(t *testing.T) {
 	}
 }
 
+func TestSplitWords(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"underscore", "hello_world", []string{"hello", "world"}},
+		{"dash", "hello-world", []string{"hello", "world"}},
+		{"space", "hello world", []string{"hello", "world"}},
+		{"camelCase", "helloWorld", []string{"hello", "World"}},
+		{"PascalCase", "HelloWorld", []string{"Hello", "World"}},
+		{"empty", "", nil},
+		{"single word", "hello", []string{"hello"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, splitWords(tt.input))
+		})
+	}
+}
+
 func TestStripHTMLTags(t *testing.T) {
 	tests := []struct {
 		input    string
@@ -485,3 +709,23 @@ func TestStripHTMLTags(t *testing.T) {
 		})
 	}
 }
+
+func TestGetFileExtension(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{"normal", "photo.jpg", "jpg"},
+		{"multiple dots", "archive.tar.gz", "gz"},
+		{"no extension", "README", ""},
+		{"dot only", ".", ""},
+		{"hidden file", ".gitignore", "gitignore"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, getFileExtension(tt.input))
+		})
+	}
+}

From e88cb297c26f2a410059182c71f7ed81ca375f22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 04:43:16 +0800
Subject: [PATCH 04/11] feat: add more old validation filters

---
 validation/filters.go      | 134 +++++++++++++++++++++++--------------
 validation/filters_test.go |  58 +++++++++++++++-
 validation/utils.go        |  43 ++++++++++++
 3 files changed, 181 insertions(+), 54 deletions(-)

diff --git a/validation/filters.go b/validation/filters.go
index a38a79f43..3fd6ed556 100644
--- a/validation/filters.go
+++ b/validation/filters.go
@@ -20,26 +20,14 @@ import (
 // builtinFilters contains all built-in filter functions.
 var builtinFilters = map[string]func(val any) any{
 	// String cleaning
-	"trim": func(val any) any {
-		return strings.TrimSpace(cast.ToString(val))
-	},
-	"ltrim": func(val any) any {
-		return strings.TrimLeft(cast.ToString(val), " \t\n\r")
-	},
-	"rtrim": func(val any) any {
-		return strings.TrimRight(cast.ToString(val), " \t\n\r")
-	},
+	"trim":  func(val any) any { return strings.TrimSpace(cast.ToString(val)) },
+	"ltrim": func(val any) any { return strings.TrimLeft(cast.ToString(val), " \t\n\r") },
+	"rtrim": func(val any) any { return strings.TrimRight(cast.ToString(val), " \t\n\r") },
 
 	// Case conversion
-	"lower": func(val any) any {
-		return strings.ToLower(cast.ToString(val))
-	},
-	"upper": func(val any) any {
-		return strings.ToUpper(cast.ToString(val))
-	},
-	"title": func(val any) any {
-		return cases.Title(language.Und).String(cast.ToString(val))
-	},
+	"lower": func(val any) any { return strings.ToLower(cast.ToString(val)) },
+	"upper": func(val any) any { return strings.ToUpper(cast.ToString(val)) },
+	"title": func(val any) any { return cases.Title(language.Und).String(cast.ToString(val)) },
 	"ucfirst": func(val any) any {
 		s := cast.ToString(val)
 		if len(s) == 0 {
@@ -60,40 +48,28 @@ var builtinFilters = map[string]func(val any) any{
 	},
 
 	// Naming style
-	"camel": func(val any) any {
-		return toCamelCase(cast.ToString(val))
-	},
-	"snake": func(val any) any {
-		return toSnakeCase(cast.ToString(val))
-	},
+	"camel": func(val any) any { return toCamelCase(cast.ToString(val)) },
+	"snake": func(val any) any { return toSnakeCase(cast.ToString(val)) },
 
 	// Type conversion
-	"to_int": func(val any) any {
-		return cast.ToInt(val)
-	},
-	"to_uint": func(val any) any {
-		return cast.ToUint(val)
-	},
-	"to_float": func(val any) any {
-		return cast.ToFloat64(val)
-	},
-	"to_bool": func(val any) any {
-		return cast.ToBool(val)
-	},
-	"to_string": func(val any) any {
-		return cast.ToString(val)
-	},
-	"to_time": func(val any) any {
-		return cast.ToTime(val)
-	},
+	"to_int":    func(val any) any { return cast.ToInt(val) },
+	"to_int64":  func(val any) any { return cast.ToInt64(val) },
+	"to_uint":   func(val any) any { return cast.ToUint(val) },
+	"to_float":  func(val any) any { return cast.ToFloat64(val) },
+	"to_bool":   func(val any) any { return cast.ToBool(val) },
+	"to_string": func(val any) any { return cast.ToString(val) },
+	"to_time":   func(val any) any { return cast.ToTime(val) },
+	"int":       func(val any) any { return cast.ToInt(val) },
+	"int64":     func(val any) any { return cast.ToInt64(val) },
+	"uint":      func(val any) any { return cast.ToUint(val) },
+	"float":     func(val any) any { return cast.ToFloat64(val) },
+	"bool":      func(val any) any { return cast.ToBool(val) },
 
 	// Encoding
-	"escape_html": func(val any) any {
-		return html.EscapeString(cast.ToString(val))
-	},
-	"url_encode": func(val any) any {
-		return url.QueryEscape(cast.ToString(val))
-	},
+	"strip_tags":  func(val any) any { return stripHTMLTags(cast.ToString(val)) },
+	"escape_js":   func(val any) any { return escapeJS(cast.ToString(val)) },
+	"escape_html": func(val any) any { return html.EscapeString(cast.ToString(val)) },
+	"url_encode":  func(val any) any { return url.QueryEscape(cast.ToString(val)) },
 	"url_decode": func(val any) any {
 		decoded, err := url.QueryUnescape(cast.ToString(val))
 		if err != nil {
@@ -102,10 +78,66 @@ var builtinFilters = map[string]func(val any) any{
 		return decoded
 	},
 
-	// Cleaning
-	"strip_tags": func(val any) any {
-		return stripHTMLTags(cast.ToString(val))
+	// String splitting
+	"str_to_ints":  func(val any) any { return strToInts(cast.ToString(val)) },
+	"str_to_array": func(val any) any { return strToArray(cast.ToString(val)) },
+	"str_to_time":  func(val any) any { return cast.ToTime(val) },
+
+	// Deprecated: use snake_case names instead, will be removed in the next version.
+	"trimSpace": func(val any) any { return strings.TrimSpace(cast.ToString(val)) },
+	"trimLeft":  func(val any) any { return strings.TrimLeft(cast.ToString(val), " \t\n\r") },
+	"trimRight": func(val any) any { return strings.TrimRight(cast.ToString(val), " \t\n\r") },
+	"lowercase": func(val any) any { return strings.ToLower(cast.ToString(val)) },
+	"uppercase": func(val any) any { return strings.ToUpper(cast.ToString(val)) },
+	"lowerFirst": func(val any) any {
+		s := cast.ToString(val)
+		if len(s) == 0 {
+			return s
+		}
+		runes := []rune(s)
+		runes[0] = unicode.ToLower(runes[0])
+		return string(runes)
+	},
+	"upperFirst": func(val any) any {
+		s := cast.ToString(val)
+		if len(s) == 0 {
+			return s
+		}
+		runes := []rune(s)
+		runes[0] = unicode.ToUpper(runes[0])
+		return string(runes)
+	},
+	"ucWord":     func(val any) any { return cases.Title(language.Und).String(cast.ToString(val)) },
+	"upperWord":  func(val any) any { return cases.Title(language.Und).String(cast.ToString(val)) },
+	"camelCase":  func(val any) any { return toCamelCase(cast.ToString(val)) },
+	"snakeCase":  func(val any) any { return toSnakeCase(cast.ToString(val)) },
+	"toInt":      func(val any) any { return cast.ToInt(val) },
+	"toUint":     func(val any) any { return cast.ToUint(val) },
+	"toInt64":    func(val any) any { return cast.ToInt64(val) },
+	"toFloat":    func(val any) any { return cast.ToFloat64(val) },
+	"toBool":     func(val any) any { return cast.ToBool(val) },
+	"toString":   func(val any) any { return cast.ToString(val) },
+	"toTime":     func(val any) any { return cast.ToTime(val) },
+	"str2time":   func(val any) any { return cast.ToTime(val) },
+	"strToTime":  func(val any) any { return cast.ToTime(val) },
+	"escapeHtml": func(val any) any { return html.EscapeString(cast.ToString(val)) },
+	"escapeHTML": func(val any) any { return html.EscapeString(cast.ToString(val)) },
+	"escapeJs":   func(val any) any { return escapeJS(cast.ToString(val)) },
+	"escapeJS":   func(val any) any { return escapeJS(cast.ToString(val)) },
+	"urlEncode":  func(val any) any { return url.QueryEscape(cast.ToString(val)) },
+	"urlDecode": func(val any) any {
+		decoded, err := url.QueryUnescape(cast.ToString(val))
+		if err != nil {
+			return cast.ToString(val)
+		}
+		return decoded
 	},
+	"stripTags":  func(val any) any { return stripHTMLTags(cast.ToString(val)) },
+	"str2ints":   func(val any) any { return strToInts(cast.ToString(val)) },
+	"strToInts":  func(val any) any { return strToInts(cast.ToString(val)) },
+	"str2arr":    func(val any) any { return strToArray(cast.ToString(val)) },
+	"str2array":  func(val any) any { return strToArray(cast.ToString(val)) },
+	"strToArray": func(val any) any { return strToArray(cast.ToString(val)) },
 }
 
 // applyFilters applies filter rules to the DataBag.
diff --git a/validation/filters_test.go b/validation/filters_test.go
index b51a50596..453f3e9e5 100644
--- a/validation/filters_test.go
+++ b/validation/filters_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -41,21 +42,72 @@ func TestBuiltinFilters(t *testing.T) {
 		// Type conversion
 		{"to_int from string", "to_int", "42", 42},
 		{"to_int from float", "to_int", 42.9, 42},
+		{"to_int64 from string", "to_int64", "9999999999", int64(9999999999)},
+		{"to_int64 from int", "to_int64", 42, int64(42)},
 		{"to_uint from string", "to_uint", "42", uint(42)},
 		{"to_float from string", "to_float", "3.14", 3.14},
 		{"to_bool true", "to_bool", "true", true},
 		{"to_bool false", "to_bool", "false", false},
 		{"to_string from int", "to_string", 42, "42"},
+		{"to_time", "to_time", "2024-01-01", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{"int alias", "int", "42", 42},
+		{"int64 alias", "int64", "9999999999", int64(9999999999)},
+		{"uint alias", "uint", "42", uint(42)},
+		{"float alias", "float", "3.14", 3.14},
+		{"bool alias", "bool", "true", true},
 
 		// Encoding
+		{"strip_tags", "strip_tags", "<p>Hello <b>World</b></p>", "Hello World"},
+		{"strip_tags no tags", "strip_tags", "Hello World", "Hello World"},
+		{"escape_js", "escape_js", `<script>alert("xss")</script>`, `\x3cscript\x3ealert(\"xss\")\x3c\/script\x3e`},
+		{"escape_js newlines", "escape_js", "line1\nline2", `line1\nline2`},
 		{"escape_html", "escape_html", "<script>alert('xss')</script>", "&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;"},
 		{"url_encode", "url_encode", "hello world&foo=bar", "hello+world%26foo%3Dbar"},
 		{"url_decode", "url_decode", "hello+world%26foo%3Dbar", "hello world&foo=bar"},
 		{"url_decode invalid", "url_decode", "%zz", "%zz"},
 
-		// Cleaning
-		{"strip_tags", "strip_tags", "<p>Hello <b>World</b></p>", "Hello World"},
-		{"strip_tags no tags", "strip_tags", "Hello World", "Hello World"},
+		// String splitting
+		{"str_to_ints", "str_to_ints", "1,2,3", []int{1, 2, 3}},
+		{"str_to_ints with spaces", "str_to_ints", "1, 2, 3", []int{1, 2, 3}},
+		{"str_to_ints single", "str_to_ints", "42", []int{42}},
+		{"str_to_array", "str_to_array", "a,b,c", []string{"a", "b", "c"}},
+		{"str_to_array with spaces", "str_to_array", "a, b, c", []string{"a", "b", "c"}},
+		{"str_to_array single", "str_to_array", "hello", []string{"hello"}},
+		{"str_to_time", "str_to_time", "2024-01-01", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)},
+
+		// Deprecated aliases
+		{"trimSpace", "trimSpace", "  hello  ", "hello"},
+		{"trimLeft", "trimLeft", "  hello  ", "hello  "},
+		{"trimRight", "trimRight", "  hello  ", "  hello"},
+		{"lowercase", "lowercase", "HELLO", "hello"},
+		{"uppercase", "uppercase", "hello", "HELLO"},
+		{"lowerFirst", "lowerFirst", "Hello", "hello"},
+		{"upperFirst", "upperFirst", "hello", "Hello"},
+		{"ucWord", "ucWord", "hello world", "Hello World"},
+		{"upperWord", "upperWord", "hello world", "Hello World"},
+		{"camelCase", "camelCase", "hello_world", "helloWorld"},
+		{"snakeCase", "snakeCase", "helloWorld", "hello_world"},
+		{"toInt", "toInt", "42", 42},
+		{"toUint", "toUint", "42", uint(42)},
+		{"toInt64", "toInt64", "100", int64(100)},
+		{"toFloat", "toFloat", "3.14", 3.14},
+		{"toBool", "toBool", "true", true},
+		{"toString", "toString", 42, "42"},
+		{"toTime", "toTime", "2024-01-01", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{"str2time", "str2time", "2024-01-01", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{"strToTime", "strToTime", "2024-01-01", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)},
+		{"escapeHtml", "escapeHtml", "<b>hi</b>", "&lt;b&gt;hi&lt;/b&gt;"},
+		{"escapeHTML", "escapeHTML", "<b>hi</b>", "&lt;b&gt;hi&lt;/b&gt;"},
+		{"escapeJs", "escapeJs", "alert('x')", `alert(\'x\')`},
+		{"escapeJS", "escapeJS", "alert('x')", `alert(\'x\')`},
+		{"urlEncode", "urlEncode", "a b", "a+b"},
+		{"urlDecode", "urlDecode", "a+b", "a b"},
+		{"stripTags", "stripTags", "<p>hi</p>", "hi"},
+		{"str2ints", "str2ints", "1,2", []int{1, 2}},
+		{"strToInts", "strToInts", "1,2", []int{1, 2}},
+		{"str2arr", "str2arr", "a,b", []string{"a", "b"}},
+		{"str2array", "str2array", "a,b", []string{"a", "b"}},
+		{"strToArray", "strToArray", "a,b", []string{"a", "b"}},
 	}
 
 	for _, tt := range tests {
diff --git a/validation/utils.go b/validation/utils.go
index 12c2ff5da..cd61c9f0f 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -517,6 +517,49 @@ func stripHTMLTags(s string) string {
 	return htmlTagRegex.ReplaceAllString(s, "")
 }
 
+// escapeJS escapes a string for safe embedding in JavaScript.
+func escapeJS(s string) string {
+	replacer := strings.NewReplacer(
+		`\`, `\\`,
+		`"`, `\"`,
+		`'`, `\'`,
+		"\n", `\n`,
+		"\r", `\r`,
+		"<", `\x3c`,
+		">", `\x3e`,
+		"/", `\/`,
+	)
+	return replacer.Replace(s)
+}
+
+// strToInts splits a comma-separated string into []int.
+func strToInts(s string) []int {
+	parts := strings.Split(s, ",")
+	result := make([]int, 0, len(parts))
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		result = append(result, cast.ToInt(p))
+	}
+	return result
+}
+
+// strToArray splits a comma-separated string into []string.
+func strToArray(s string) []string {
+	parts := strings.Split(s, ",")
+	result := make([]string, 0, len(parts))
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		result = append(result, p)
+	}
+	return result
+}
+
 // detectMIME detects the real MIME type of a multipart file by reading its content.
 func detectMIME(fh *multipart.FileHeader) (*mimetype.MIME, error) {
 	f, err := fh.Open()

From e52ab0e85dfeab811b1bc729b7fac90705e09f90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 05:11:37 +0800
Subject: [PATCH 05/11] feat: add more old validation rules

---
 validation/messages.go   |  23 ++++
 validation/rules.go      |  74 +++++++++++
 validation/rules_test.go | 260 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 357 insertions(+)

diff --git a/validation/messages.go b/validation/messages.go
index 45fdea08c..8381d23eb 100644
--- a/validation/messages.go
+++ b/validation/messages.go
@@ -48,6 +48,7 @@ var defaultMessages = map[string]string{
 	"string":  "The :attribute field must be a string.",
 	"integer": "The :attribute field must be an integer.",
 	"int":     "The :attribute field must be an integer.",
+	"uint":    "The :attribute field must be a positive integer.",
 	"numeric": "The :attribute field must be a number.",
 	"boolean": "The :attribute field must be true or false.",
 	"bool":    "The :attribute field must be true or false.",
@@ -114,6 +115,9 @@ var defaultMessages = map[string]string{
 	"mac":         "The :attribute field must be a valid MAC address.",
 	"json":        "The :attribute field must be a valid JSON string.",
 	"uuid":        "The :attribute field must be a valid UUID.",
+	"uuid3":       "The :attribute field must be a valid UUID v3.",
+	"uuid4":       "The :attribute field must be a valid UUID v4.",
+	"uuid5":       "The :attribute field must be a valid UUID v5.",
 	"ulid":        "The :attribute field must be a valid ULID.",
 	"hex_color":   "The :attribute field must be a valid hexadecimal color.",
 	"regex":       "The :attribute field format is invalid.",
@@ -133,6 +137,8 @@ var defaultMessages = map[string]string{
 	// Comparison rules
 	"same":          "The :attribute field must match :other.",
 	"different":     "The :attribute field and :other must be different.",
+	"eq":            "The :attribute field must be equal to :value.",
+	"ne":            "The :attribute field must not be equal to :value.",
 	"in":            "The selected :attribute is invalid.",
 	"not_in":        "The selected :attribute is invalid.",
 	"in_array":      "The :attribute field must exist in :other.",
@@ -171,6 +177,23 @@ var defaultMessages = map[string]string{
 	// Database rules
 	"exists": "The :attribute does not exist.",
 	"unique": "The :attribute has already been taken.",
+
+	// Deprecated: use the new names instead, will be removed in the next version.
+	"len":       "The :attribute field must be :size characters.",
+	"min_len":   "The :attribute field must be at least :min characters.",
+	"max_len":   "The :attribute field must not be greater than :max characters.",
+	"eq_field":  "The :attribute field must match :other.",
+	"ne_field":  "The :attribute field and :other must be different.",
+	"gt_field":  "The :attribute field must be greater than :value.",
+	"gte_field": "The :attribute field must be greater than or equal to :value.",
+	"lt_field":  "The :attribute field must be less than :value.",
+	"lte_field": "The :attribute field must be less than or equal to :value.",
+	"gt_date":   "The :attribute field must be a date after :date.",
+	"lt_date":   "The :attribute field must be a date before :date.",
+	"gte_date":  "The :attribute field must be a date after or equal to :date.",
+	"lte_date":  "The :attribute field must be a date before or equal to :date.",
+	"number":    "The :attribute field must be a number.",
+	"full_url":  "The :attribute field must be a valid URL.",
 }
 
 // sizeRules are rules that have type-specific messages.
diff --git a/validation/rules.go b/validation/rules.go
index 583d0a8ff..1dc5be5c8 100644
--- a/validation/rules.go
+++ b/validation/rules.go
@@ -77,6 +77,7 @@ var builtinRules = map[string]func(ctx *RuleContext) bool{
 	"string":  ruleString,
 	"integer": ruleInteger,
 	"int":     ruleInteger, // Go alias
+	"uint":    ruleUint,    // Go-specific
 	"numeric": ruleNumeric,
 	"boolean": ruleBoolean,
 	"bool":    ruleBoolean, // Go alias
@@ -119,6 +120,9 @@ var builtinRules = map[string]func(ctx *RuleContext) bool{
 	"mac":         ruleMacAddress, // alias
 	"json":        ruleJson,
 	"uuid":        ruleUuid,
+	"uuid3":       ruleUuid3,
+	"uuid4":       ruleUuid4,
+	"uuid5":       ruleUuid5,
 	"ulid":        ruleUlid,
 	"hex_color":   ruleHexColor,
 	"regex":       ruleRegex,
@@ -138,6 +142,8 @@ var builtinRules = map[string]func(ctx *RuleContext) bool{
 	// Comparison
 	"same":          ruleSame,
 	"different":     ruleDifferent,
+	"eq":            ruleEq,
+	"ne":            ruleNe,
 	"in":            ruleIn,
 	"not_in":        ruleNotIn,
 	"in_array":      ruleInArray,
@@ -181,6 +187,23 @@ var builtinRules = map[string]func(ctx *RuleContext) bool{
 	// Database
 	"exists": ruleExists,
 	"unique": ruleUnique,
+
+	// Deprecated: use the new names instead, will be removed in the next version.
+	"len":       ruleSize,          // use "size"
+	"min_len":   ruleMin,           // use "min"
+	"max_len":   ruleMax,           // use "max"
+	"eq_field":  ruleSame,          // use "same"
+	"ne_field":  ruleDifferent,     // use "different"
+	"gt_field":  ruleGt,            // use "gt"
+	"gte_field": ruleGte,           // use "gte"
+	"lt_field":  ruleLt,            // use "lt"
+	"lte_field": ruleLte,           // use "lte"
+	"gt_date":   ruleAfter,         // use "after"
+	"lt_date":   ruleBefore,        // use "before"
+	"gte_date":  ruleAfterOrEqual,  // use "after_or_equal"
+	"lte_date":  ruleBeforeOrEqual, // use "before_or_equal"
+	"number":    ruleNumeric,       // use "numeric"
+	"full_url":  ruleUrl,           // use "url"
 }
 
 // implicitRules are rules that run even when the field is missing or empty.
@@ -1016,6 +1039,36 @@ func ruleUuid(ctx *RuleContext) bool {
 	return uuidRegex.MatchString(s)
 }
 
+var uuid3Regex = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-3[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
+
+func ruleUuid3(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return uuid3Regex.MatchString(s)
+}
+
+var uuid4Regex = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$`)
+
+func ruleUuid4(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return uuid4Regex.MatchString(s)
+}
+
+var uuid5Regex = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-5[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$`)
+
+func ruleUuid5(ctx *RuleContext) bool {
+	s, ok := ctx.Value.(string)
+	if !ok {
+		return false
+	}
+	return uuid5Regex.MatchString(s)
+}
+
 var ulidRegex = regexp.MustCompile(`^[0-9A-HJ-KM-NP-TV-Za-hj-km-np-tv-z]{26}$`)
 
 func ruleUlid(ctx *RuleContext) bool {
@@ -1173,6 +1226,27 @@ func ruleDifferent(ctx *RuleContext) bool {
 	return fmt.Sprintf("%v", ctx.Value) != fmt.Sprintf("%v", otherVal)
 }
 
+func ruleEq(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	return fmt.Sprintf("%v", ctx.Value) == ctx.Parameters[0]
+}
+
+func ruleNe(ctx *RuleContext) bool {
+	if len(ctx.Parameters) == 0 {
+		return false
+	}
+	return fmt.Sprintf("%v", ctx.Value) != ctx.Parameters[0]
+}
+
+func ruleUint(ctx *RuleContext) bool {
+	if !ruleInteger(ctx) {
+		return false
+	}
+	return cast.ToInt64(ctx.Value) >= 0
+}
+
 func ruleIn(ctx *RuleContext) bool {
 	s := fmt.Sprintf("%v", ctx.Value)
 	for _, allowed := range ctx.Parameters {
diff --git a/validation/rules_test.go b/validation/rules_test.go
index 15f068864..9be252fac 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -764,6 +764,45 @@ func (s *RulesTestSuite) TestInteger() {
 	}
 }
 
+func (s *RulesTestSuite) TestUintRule() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_uint", map[string]any{"v": uint(42)}, map[string]any{"v": "uint"}, false},
+		{"pass_uint8", map[string]any{"v": uint8(255)}, map[string]any{"v": "uint"}, false},
+		{"pass_uint16", map[string]any{"v": uint16(65535)}, map[string]any{"v": "uint"}, false},
+		{"pass_uint32", map[string]any{"v": uint32(100)}, map[string]any{"v": "uint"}, false},
+		{"pass_uint64", map[string]any{"v": uint64(100)}, map[string]any{"v": "uint"}, false},
+		{"pass_int_positive", map[string]any{"v": 42}, map[string]any{"v": "uint"}, false},
+		{"pass_int8_positive", map[string]any{"v": int8(1)}, map[string]any{"v": "uint"}, false},
+		{"pass_int16_positive", map[string]any{"v": int16(1)}, map[string]any{"v": "uint"}, false},
+		{"pass_int32_positive", map[string]any{"v": int32(1)}, map[string]any{"v": "uint"}, false},
+		{"pass_int64_positive", map[string]any{"v": int64(1)}, map[string]any{"v": "uint"}, false},
+		{"pass_zero", map[string]any{"v": 0}, map[string]any{"v": "uint"}, false},
+		{"pass_string_zero", map[string]any{"v": "0"}, map[string]any{"v": "uint"}, false},
+		{"pass_string", map[string]any{"v": "42"}, map[string]any{"v": "uint"}, false},
+		{"pass_float64_whole", map[string]any{"v": float64(42)}, map[string]any{"v": "uint"}, false},
+		{"fail_negative", map[string]any{"v": -1}, map[string]any{"v": "uint"}, true},
+		{"fail_negative_int64", map[string]any{"v": int64(-1)}, map[string]any{"v": "uint"}, true},
+		{"fail_float", map[string]any{"v": 3.14}, map[string]any{"v": "uint"}, true},
+		{"fail_string_alpha", map[string]any{"v": "abc"}, map[string]any{"v": "uint"}, true},
+		{"fail_negative_string", map[string]any{"v": "-5"}, map[string]any{"v": "uint"}, true},
+		{"fail_float_string", map[string]any{"v": "3.14"}, map[string]any{"v": "uint"}, true},
+		{"fail_bool", map[string]any{"v": true}, map[string]any{"v": "uint"}, true},
+		{"fail_slice", map[string]any{"v": []any{1}}, map[string]any{"v": "uint"}, true},
+		{"fail_map", map[string]any{"v": map[string]any{}}, map[string]any{"v": "uint"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
 func (s *RulesTestSuite) TestNumeric() {
 	tests := []struct {
 		name  string
@@ -1674,13 +1713,100 @@ func (s *RulesTestSuite) TestUuid() {
 		fails bool
 	}{
 		{"pass_v4", map[string]any{"x": "550e8400-e29b-41d4-a716-446655440000"}, map[string]any{"x": "uuid"}, false},
+		{"pass_v3", map[string]any{"x": "a3bb189e-8bf9-3888-9912-ace4e6543002"}, map[string]any{"x": "uuid"}, false},
+		{"pass_v5", map[string]any{"x": "886313e1-3b8a-5372-9b90-0c9aee199e5d"}, map[string]any{"x": "uuid"}, false},
+		{"pass_v1", map[string]any{"x": "550e8400-e29b-11d4-a716-446655440000"}, map[string]any{"x": "uuid"}, false},
 		{"pass_lowercase", map[string]any{"x": "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11"}, map[string]any{"x": "uuid"}, false},
 		{"pass_uppercase", map[string]any{"x": "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11"}, map[string]any{"x": "uuid"}, false},
 		{"pass_nil_uuid", map[string]any{"x": "00000000-0000-0000-0000-000000000000"}, map[string]any{"x": "uuid"}, false},
 		{"fail_invalid", map[string]any{"x": "not-a-uuid"}, map[string]any{"x": "uuid"}, true},
 		{"fail_missing_dashes", map[string]any{"x": "550e8400e29b41d4a716446655440000"}, map[string]any{"x": "uuid"}, true},
 		{"fail_too_short", map[string]any{"x": "550e8400-e29b"}, map[string]any{"x": "uuid"}, true},
+		{"fail_too_long", map[string]any{"x": "550e8400-e29b-41d4-a716-446655440000a"}, map[string]any{"x": "uuid"}, true},
 		{"fail_invalid_chars", map[string]any{"x": "gggggggg-gggg-gggg-gggg-gggggggggggg"}, map[string]any{"x": "uuid"}, true},
+		{"fail_int", map[string]any{"x": 123}, map[string]any{"x": "uuid"}, true},
+		{"fail_nil", map[string]any{"x": nil}, map[string]any{"x": "uuid"}, true},
+		{"fail_extra_dash", map[string]any{"x": "550e8400-e29b-41d4-a716-4466554400-00"}, map[string]any{"x": "uuid"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUuid3() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass", map[string]any{"v": "a3bb189e-8bf9-3888-9912-ace4e6543002"}, map[string]any{"v": "uuid3"}, false},
+		{"pass_uppercase", map[string]any{"v": "A3BB189E-8BF9-3888-9912-ACE4E6543002"}, map[string]any{"v": "uuid3"}, false},
+		{"fail_uuid4", map[string]any{"v": "550e8400-e29b-41d4-a716-446655440000"}, map[string]any{"v": "uuid3"}, true},
+		{"fail_uuid5", map[string]any{"v": "886313e1-3b8a-5372-9b90-0c9aee199e5d"}, map[string]any{"v": "uuid3"}, true},
+		{"fail_uuid1", map[string]any{"v": "550e8400-e29b-11d4-a716-446655440000"}, map[string]any{"v": "uuid3"}, true},
+		{"fail_not_uuid", map[string]any{"v": "not-a-uuid"}, map[string]any{"v": "uuid3"}, true},
+		{"fail_int", map[string]any{"v": 123}, map[string]any{"v": "uuid3"}, true},
+		{"fail_nil", map[string]any{"v": nil}, map[string]any{"v": "uuid3"}, true},
+		{"fail_too_short", map[string]any{"v": "a3bb189e-8bf9-3888"}, map[string]any{"v": "uuid3"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUuid4() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass", map[string]any{"v": "550e8400-e29b-41d4-a716-446655440000"}, map[string]any{"v": "uuid4"}, false},
+		{"pass_variant_8", map[string]any{"v": "550e8400-e29b-41d4-8716-446655440000"}, map[string]any{"v": "uuid4"}, false},
+		{"pass_variant_9", map[string]any{"v": "550e8400-e29b-41d4-9716-446655440000"}, map[string]any{"v": "uuid4"}, false},
+		{"pass_variant_b", map[string]any{"v": "550e8400-e29b-41d4-b716-446655440000"}, map[string]any{"v": "uuid4"}, false},
+		{"pass_uppercase", map[string]any{"v": "550E8400-E29B-41D4-A716-446655440000"}, map[string]any{"v": "uuid4"}, false},
+		{"fail_uuid3", map[string]any{"v": "a3bb189e-8bf9-3888-9912-ace4e6543002"}, map[string]any{"v": "uuid4"}, true},
+		{"fail_uuid5", map[string]any{"v": "886313e1-3b8a-5372-9b90-0c9aee199e5d"}, map[string]any{"v": "uuid4"}, true},
+		{"fail_uuid1", map[string]any{"v": "550e8400-e29b-11d4-a716-446655440000"}, map[string]any{"v": "uuid4"}, true},
+		{"fail_bad_variant", map[string]any{"v": "550e8400-e29b-41d4-0716-446655440000"}, map[string]any{"v": "uuid4"}, true},
+		{"fail_not_uuid", map[string]any{"v": "not-a-uuid"}, map[string]any{"v": "uuid4"}, true},
+		{"fail_int", map[string]any{"v": 123}, map[string]any{"v": "uuid4"}, true},
+		{"fail_nil", map[string]any{"v": nil}, map[string]any{"v": "uuid4"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestUuid5() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass", map[string]any{"v": "886313e1-3b8a-5372-9b90-0c9aee199e5d"}, map[string]any{"v": "uuid5"}, false},
+		{"pass_variant_8", map[string]any{"v": "886313e1-3b8a-5372-8b90-0c9aee199e5d"}, map[string]any{"v": "uuid5"}, false},
+		{"pass_variant_b", map[string]any{"v": "886313e1-3b8a-5372-bb90-0c9aee199e5d"}, map[string]any{"v": "uuid5"}, false},
+		{"pass_uppercase", map[string]any{"v": "886313E1-3B8A-5372-9B90-0C9AEE199E5D"}, map[string]any{"v": "uuid5"}, false},
+		{"fail_uuid3", map[string]any{"v": "a3bb189e-8bf9-3888-9912-ace4e6543002"}, map[string]any{"v": "uuid5"}, true},
+		{"fail_uuid4", map[string]any{"v": "550e8400-e29b-41d4-a716-446655440000"}, map[string]any{"v": "uuid5"}, true},
+		{"fail_uuid1", map[string]any{"v": "550e8400-e29b-11d4-a716-446655440000"}, map[string]any{"v": "uuid5"}, true},
+		{"fail_bad_variant", map[string]any{"v": "886313e1-3b8a-5372-0b90-0c9aee199e5d"}, map[string]any{"v": "uuid5"}, true},
+		{"fail_not_uuid", map[string]any{"v": "not-a-uuid"}, map[string]any{"v": "uuid5"}, true},
+		{"fail_int", map[string]any{"v": 123}, map[string]any{"v": "uuid5"}, true},
+		{"fail_nil", map[string]any{"v": nil}, map[string]any{"v": "uuid5"}, true},
 	}
 	for _, tt := range tests {
 		s.Run(tt.name, func() {
@@ -2020,6 +2146,59 @@ func (s *RulesTestSuite) TestDifferent() {
 	}
 }
 
+func (s *RulesTestSuite) TestEq() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_string", map[string]any{"v": "hello"}, map[string]any{"v": "eq:hello"}, false},
+		{"pass_int", map[string]any{"v": 42}, map[string]any{"v": "eq:42"}, false},
+		{"pass_float", map[string]any{"v": 3.14}, map[string]any{"v": "eq:3.14"}, false},
+		{"pass_bool_true", map[string]any{"v": true}, map[string]any{"v": "eq:true"}, false},
+		{"pass_bool_false", map[string]any{"v": false}, map[string]any{"v": "eq:false"}, false},
+		{"pass_zero", map[string]any{"v": 0}, map[string]any{"v": "eq:0"}, false},
+		{"pass_empty_string", map[string]any{"v": ""}, map[string]any{"v": "eq:"}, false},
+		{"fail_different_string", map[string]any{"v": "hello"}, map[string]any{"v": "eq:world"}, true},
+		{"fail_different_int", map[string]any{"v": 42}, map[string]any{"v": "eq:43"}, true},
+		{"fail_type_mismatch", map[string]any{"v": 42}, map[string]any{"v": "eq:hello"}, true},
+		{"fail_case_sensitive", map[string]any{"v": "Hello"}, map[string]any{"v": "eq:hello"}, true},
+		{"fail_no_params", map[string]any{"v": "hello"}, map[string]any{"v": "eq"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
+func (s *RulesTestSuite) TestNe() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		{"pass_different_string", map[string]any{"v": "hello"}, map[string]any{"v": "ne:world"}, false},
+		{"pass_different_int", map[string]any{"v": 42}, map[string]any{"v": "ne:43"}, false},
+		{"pass_case_sensitive", map[string]any{"v": "Hello"}, map[string]any{"v": "ne:hello"}, false},
+		{"pass_type_mismatch", map[string]any{"v": 42}, map[string]any{"v": "ne:hello"}, false},
+		{"fail_same_string", map[string]any{"v": "hello"}, map[string]any{"v": "ne:hello"}, true},
+		{"fail_same_int", map[string]any{"v": 42}, map[string]any{"v": "ne:42"}, true},
+		{"fail_same_zero", map[string]any{"v": 0}, map[string]any{"v": "ne:0"}, true},
+		{"fail_same_bool", map[string]any{"v": true}, map[string]any{"v": "ne:true"}, true},
+		{"fail_no_params", map[string]any{"v": "hello"}, map[string]any{"v": "ne"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}
+
 func (s *RulesTestSuite) TestIn() {
 	tests := []struct {
 		name  string
@@ -3892,3 +4071,84 @@ func (s *DBRulesTestSuite) TestRuleUnique_NoParameters() {
 	}
 	s.False(ruleUnique(ctx))
 }
+
+// ===== Deprecated Rule Aliases =====
+
+func (s *RulesTestSuite) TestDeprecatedAliases() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// len → size
+		{"len_string_pass", map[string]any{"name": "hello"}, map[string]any{"name": "string|len:5"}, false},
+		{"len_string_fail", map[string]any{"name": "hi"}, map[string]any{"name": "string|len:5"}, true},
+
+		// min_len → min
+		{"min_len_pass", map[string]any{"name": "hello"}, map[string]any{"name": "string|min_len:3"}, false},
+		{"min_len_fail", map[string]any{"name": "hi"}, map[string]any{"name": "string|min_len:3"}, true},
+
+		// max_len → max
+		{"max_len_pass", map[string]any{"name": "hi"}, map[string]any{"name": "string|max_len:5"}, false},
+		{"max_len_fail", map[string]any{"name": "hello world"}, map[string]any{"name": "string|max_len:5"}, true},
+
+		// eq_field → same
+		{"eq_field_pass", map[string]any{"a": "x", "b": "x"}, map[string]any{"a": "eq_field:b"}, false},
+		{"eq_field_fail", map[string]any{"a": "x", "b": "y"}, map[string]any{"a": "eq_field:b"}, true},
+
+		// ne_field → different
+		{"ne_field_pass", map[string]any{"a": "x", "b": "y"}, map[string]any{"a": "ne_field:b"}, false},
+		{"ne_field_fail", map[string]any{"a": "x", "b": "x"}, map[string]any{"a": "ne_field:b"}, true},
+
+		// gt_field → gt
+		{"gt_field_pass", map[string]any{"a": 10, "b": 5}, map[string]any{"a": "numeric|gt_field:b"}, false},
+		{"gt_field_fail", map[string]any{"a": 3, "b": 5}, map[string]any{"a": "numeric|gt_field:b"}, true},
+
+		// gte_field → gte
+		{"gte_field_pass", map[string]any{"a": 5, "b": 5}, map[string]any{"a": "numeric|gte_field:b"}, false},
+		{"gte_field_fail", map[string]any{"a": 3, "b": 5}, map[string]any{"a": "numeric|gte_field:b"}, true},
+
+		// lt_field → lt
+		{"lt_field_pass", map[string]any{"a": 3, "b": 5}, map[string]any{"a": "numeric|lt_field:b"}, false},
+		{"lt_field_fail", map[string]any{"a": 10, "b": 5}, map[string]any{"a": "numeric|lt_field:b"}, true},
+
+		// lte_field → lte
+		{"lte_field_pass", map[string]any{"a": 5, "b": 5}, map[string]any{"a": "numeric|lte_field:b"}, false},
+		{"lte_field_fail", map[string]any{"a": 10, "b": 5}, map[string]any{"a": "numeric|lte_field:b"}, true},
+
+		// gt_date → after
+		{"gt_date_pass", map[string]any{"d": "2025-01-02"}, map[string]any{"d": "gt_date:2025-01-01"}, false},
+		{"gt_date_fail", map[string]any{"d": "2025-01-01"}, map[string]any{"d": "gt_date:2025-01-02"}, true},
+
+		// lt_date → before
+		{"lt_date_pass", map[string]any{"d": "2025-01-01"}, map[string]any{"d": "lt_date:2025-01-02"}, false},
+		{"lt_date_fail", map[string]any{"d": "2025-01-02"}, map[string]any{"d": "lt_date:2025-01-01"}, true},
+
+		// gte_date → after_or_equal
+		{"gte_date_pass_equal", map[string]any{"d": "2025-01-01"}, map[string]any{"d": "gte_date:2025-01-01"}, false},
+		{"gte_date_pass_after", map[string]any{"d": "2025-01-02"}, map[string]any{"d": "gte_date:2025-01-01"}, false},
+		{"gte_date_fail", map[string]any{"d": "2024-12-31"}, map[string]any{"d": "gte_date:2025-01-01"}, true},
+
+		// lte_date → before_or_equal
+		{"lte_date_pass_equal", map[string]any{"d": "2025-01-01"}, map[string]any{"d": "lte_date:2025-01-01"}, false},
+		{"lte_date_pass_before", map[string]any{"d": "2024-12-31"}, map[string]any{"d": "lte_date:2025-01-01"}, false},
+		{"lte_date_fail", map[string]any{"d": "2025-01-02"}, map[string]any{"d": "lte_date:2025-01-01"}, true},
+
+		// number → numeric
+		{"number_pass_int", map[string]any{"v": 42}, map[string]any{"v": "number"}, false},
+		{"number_pass_string", map[string]any{"v": "3.14"}, map[string]any{"v": "number"}, false},
+		{"number_fail", map[string]any{"v": "abc"}, map[string]any{"v": "number"}, true},
+
+		// full_url → url
+		{"full_url_pass", map[string]any{"v": "https://goravel.dev"}, map[string]any{"v": "full_url"}, false},
+		{"full_url_fail", map[string]any{"v": "not-a-url"}, map[string]any{"v": "full_url"}, true},
+	}
+
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails())
+		})
+	}
+}

From faa965ab052e11a9f03febf6379e549e1e888e03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 05:44:50 +0800
Subject: [PATCH 06/11] fix: lint

---
 validation/utils.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/validation/utils.go b/validation/utils.go
index cd61c9f0f..15fd55764 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -416,8 +416,8 @@ func isAcceptedValue(val any) bool {
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "yes" || v == "on" || v == "1" || v == "true"
 	}
-	v := cast.ToInt(val)
-	return v == 1
+	v, err := cast.ToIntE(val)
+	return v == 1 && err == nil
 }
 
 // isDeclinedValue checks if a value is one of the "declined" values.
@@ -430,8 +430,8 @@ func isDeclinedValue(val any) bool {
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "no" || v == "off" || v == "0" || v == "false"
 	}
-	v := cast.ToInt(val)
-	return v == 0
+	v, err := cast.ToIntE(val)
+	return v == 0 && err == nil
 }
 
 // parseDependentValues extracts the other field's value and comparison values from parameters.

From a6980a4434f8b43b6559f0ecd024a1ad085a119e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 05:48:05 +0800
Subject: [PATCH 07/11] fix: add more tests

---
 validation/utils.go      |  4 ++--
 validation/utils_test.go | 28 ++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/validation/utils.go b/validation/utils.go
index 15fd55764..8af8951e2 100644
--- a/validation/utils.go
+++ b/validation/utils.go
@@ -416,7 +416,7 @@ func isAcceptedValue(val any) bool {
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "yes" || v == "on" || v == "1" || v == "true"
 	}
-	v, err := cast.ToIntE(val)
+	v, err := cast.ToFloat64E(val)
 	return v == 1 && err == nil
 }
 
@@ -430,7 +430,7 @@ func isDeclinedValue(val any) bool {
 		v = strings.ToLower(strings.TrimSpace(v))
 		return v == "no" || v == "off" || v == "0" || v == "false"
 	}
-	v, err := cast.ToIntE(val)
+	v, err := cast.ToFloat64E(val)
 	return v == 0 && err == nil
 }
 
diff --git a/validation/utils_test.go b/validation/utils_test.go
index 82ba9d6d8..9a84c6cab 100644
--- a/validation/utils_test.go
+++ b/validation/utils_test.go
@@ -551,14 +551,28 @@ func TestIsAcceptedValue(t *testing.T) {
 		{"string on", "on", true},
 		{"string 1", "1", true},
 		{"string true", "true", true},
+		{"string YES", "YES", true},
+		{"string True", "True", true},
+		{"string  yes ", " yes ", true},
 		{"string no", "no", false},
 		{"string false", "false", false},
+		{"string empty", "", false},
+		{"string random", "hello", false},
+		{"string 2", "2", false},
 		{"bool true", true, true},
 		{"bool false", false, false},
 		{"int 1", 1, true},
 		{"int 0", 0, false},
+		{"int 2", 2, false},
+		{"int -1", -1, false},
 		{"int64 1", int64(1), true},
+		{"int64 0", int64(0), false},
 		{"float64 1", float64(1), true},
+		{"float64 0", float64(0), false},
+		{"float64 0.5", float64(0.5), false},
+		{"slice", []any{1, 2}, false},
+		{"map", map[string]any{"a": 1}, false},
+		{"struct", struct{ Name string }{"test"}, false},
 	}
 
 	for _, tt := range tests {
@@ -579,14 +593,28 @@ func TestIsDeclinedValue(t *testing.T) {
 		{"string off", "off", true},
 		{"string 0", "0", true},
 		{"string false", "false", true},
+		{"string NO", "NO", true},
+		{"string False", "False", true},
+		{"string  no ", " no ", true},
 		{"string yes", "yes", false},
 		{"string true", "true", false},
+		{"string empty", "", false},
+		{"string random", "hello", false},
+		{"string 2", "2", false},
 		{"bool false", false, true},
 		{"bool true", true, false},
 		{"int 0", 0, true},
 		{"int 1", 1, false},
+		{"int 2", 2, false},
+		{"int -1", -1, false},
 		{"int64 0", int64(0), true},
+		{"int64 1", int64(1), false},
 		{"float64 0", float64(0), true},
+		{"float64 1", float64(1), false},
+		{"float64 0.5", 0.5, false},
+		{"slice", []any{1, 2}, false},
+		{"map", map[string]any{"a": 1}, false},
+		{"struct", struct{ Name string }{"test"}, false},
 	}
 
 	for _, tt := range tests {

From 9a2bf1eb111709048880e5a69dd244ed88400d07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Wed, 18 Mar 2026 06:01:39 +0800
Subject: [PATCH 08/11] fix: add messages replacement

---
 validation/engine.go | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/validation/engine.go b/validation/engine.go
index 1d58e6e5c..e0bf7c42f 100644
--- a/validation/engine.go
+++ b/validation/engine.go
@@ -349,10 +349,21 @@ func (e *Engine) formatErrorMessage(field string, rule ParsedRule, attrType stri
 			}
 			replacements[":values"] = strings.Join(names, ", ")
 		}
+	case "exclude_if", "exclude_unless":
+		if len(rule.Parameters) > 0 {
+			replacements[":other"] = getDisplayableAttribute(rule.Parameters[0], e.attributes)
+		}
+		if len(rule.Parameters) > 1 {
+			replacements[":value"] = strings.Join(rule.Parameters[1:], ", ")
+		}
 	case "same", "different", "in_array", "confirmed", "prohibits":
 		if len(rule.Parameters) > 0 {
 			replacements[":other"] = getDisplayableAttribute(rule.Parameters[0], e.attributes)
 		}
+	case "eq", "ne":
+		if len(rule.Parameters) > 0 {
+			replacements[":value"] = rule.Parameters[0]
+		}
 	case "digits":
 		if len(rule.Parameters) > 0 {
 			replacements[":digits"] = rule.Parameters[0]
@@ -379,6 +390,31 @@ func (e *Engine) formatErrorMessage(field string, rule ParsedRule, attrType stri
 		if len(rule.Parameters) > 0 {
 			replacements[":format"] = rule.Parameters[0]
 		}
+	// Deprecated: will be removed in the next version.
+	case "len":
+		if len(rule.Parameters) > 0 {
+			replacements[":size"] = rule.Parameters[0]
+		}
+	case "min_len":
+		if len(rule.Parameters) > 0 {
+			replacements[":min"] = rule.Parameters[0]
+		}
+	case "max_len":
+		if len(rule.Parameters) > 0 {
+			replacements[":max"] = rule.Parameters[0]
+		}
+	case "eq_field", "ne_field":
+		if len(rule.Parameters) > 0 {
+			replacements[":other"] = getDisplayableAttribute(rule.Parameters[0], e.attributes)
+		}
+	case "gt_field", "gte_field", "lt_field", "lte_field":
+		if len(rule.Parameters) > 0 {
+			replacements[":value"] = getDisplayableAttribute(rule.Parameters[0], e.attributes)
+		}
+	case "gt_date", "lt_date", "gte_date", "lte_date":
+		if len(rule.Parameters) > 0 {
+			replacements[":date"] = rule.Parameters[0]
+		}
 	}
 
 	return formatMessage(msg, replacements)

From 9afab864138310fe4e884ee18ad5ba7aa0611059 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Thu, 19 Mar 2026 14:50:25 +0800
Subject: [PATCH 09/11] fix: address PR review comments

- Add int, uint, float to numericRuleNames for correct size resolution
- Replace google.com with goravel.dev in active_url test
- Add explicit bool handling in isAcceptedValue/isDeclinedValue
- Add DNS lookup comment on ruleActiveUrl
- Add Has("nonexistent") assertion in TestHas

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 validation/errors_test.go | 1 +
 validation/rules.go       | 1 +
 validation/rules_test.go  | 2 +-
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/validation/errors_test.go b/validation/errors_test.go
index 0d6b4cff0..f0a07beea 100644
--- a/validation/errors_test.go
+++ b/validation/errors_test.go
@@ -223,6 +223,7 @@ func TestHas(t *testing.T) {
 				errors := validator.Errors()
 				assert.NotNil(t, errors)
 				assert.Equal(t, test.expectRes, errors.Has("a"), test.describe)
+				assert.False(t, errors.Has("nonexistent"), test.describe)
 			}
 		})
 	}
diff --git a/validation/rules.go b/validation/rules.go
index 1dc5be5c8..21fa280bd 100644
--- a/validation/rules.go
+++ b/validation/rules.go
@@ -234,6 +234,7 @@ var excludeRules = map[string]bool{
 // numericRuleNames are rules that indicate a field should be treated as numeric for size rules.
 var numericRuleNames = map[string]bool{
 	"numeric": true, "integer": true, "decimal": true,
+	"int": true, "uint": true, "float": true,
 }
 
 // ---- Existence Rules ----
diff --git a/validation/rules_test.go b/validation/rules_test.go
index 9be252fac..084a39086 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -3409,7 +3409,7 @@ func (s *RulesTestSuite) TestActiveUrl() {
 		rules map[string]any
 		fails bool
 	}{
-		{"pass_google", map[string]any{"u": "https://google.com"}, map[string]any{"u": "active_url"}, false},
+		{"pass_goravel", map[string]any{"u": "https://goravel.dev"}, map[string]any{"u": "active_url"}, false},
 		{"fail_non_string", map[string]any{"u": 123}, map[string]any{"u": "active_url"}, true},
 		{"fail_no_host", map[string]any{"u": "not-a-url"}, map[string]any{"u": "active_url"}, true},
 	}

From 1593f20da4d69598447a49e3dfd80f62fa2075f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Thu, 19 Mar 2026 14:52:28 +0800
Subject: [PATCH 10/11] test: add numeric alias size resolution tests

Verify int, uint, float aliases resolve size rules as numeric values
instead of string length (e.g. int|max:3 with "42" correctly fails).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 validation/rules_test.go | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/validation/rules_test.go b/validation/rules_test.go
index 084a39086..16e07dcd0 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -1089,6 +1089,43 @@ func (s *RulesTestSuite) TestMax() {
 	}
 }
 
+func (s *RulesTestSuite) TestNumericAliasesWithSizeRules() {
+	tests := []struct {
+		name  string
+		data  map[string]any
+		rules map[string]any
+		fails bool
+	}{
+		// int alias should resolve size as numeric value, not string length
+		{"int_max_pass", map[string]any{"x": 3}, map[string]any{"x": "int|max:3"}, false},
+		{"int_max_fail", map[string]any{"x": 42}, map[string]any{"x": "int|max:3"}, true},
+		{"int_max_string_input_fail", map[string]any{"x": "42"}, map[string]any{"x": "int|max:3"}, true},
+		{"int_min_pass", map[string]any{"x": 10}, map[string]any{"x": "int|min:5"}, false},
+		{"int_min_fail", map[string]any{"x": 2}, map[string]any{"x": "int|min:5"}, true},
+		{"int_between_pass", map[string]any{"x": 5}, map[string]any{"x": "int|between:1,10"}, false},
+		{"int_between_fail", map[string]any{"x": 20}, map[string]any{"x": "int|between:1,10"}, true},
+
+		// uint alias
+		{"uint_max_pass", map[string]any{"x": 3}, map[string]any{"x": "uint|max:5"}, false},
+		{"uint_max_fail", map[string]any{"x": 10}, map[string]any{"x": "uint|max:5"}, true},
+		{"uint_min_pass", map[string]any{"x": 5}, map[string]any{"x": "uint|min:0"}, false},
+
+		// float alias
+		{"float_max_pass", map[string]any{"x": 3.14}, map[string]any{"x": "float|max:5"}, false},
+		{"float_max_fail", map[string]any{"x": 10.5}, map[string]any{"x": "float|max:5"}, true},
+		{"float_min_pass", map[string]any{"x": 3.14}, map[string]any{"x": "float|min:3.14"}, false},
+		{"float_min_fail", map[string]any{"x": 1.5}, map[string]any{"x": "float|min:3.14"}, true},
+		{"float_size_pass", map[string]any{"x": 3.14}, map[string]any{"x": "float|size:3.14"}, false},
+		{"float_size_fail", map[string]any{"x": 2.0}, map[string]any{"x": "float|size:3.14"}, true},
+	}
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			v := s.makeValidator(tt.data, tt.rules)
+			s.Equal(tt.fails, v.Fails(), tt.name)
+		})
+	}
+}
+
 func (s *RulesTestSuite) TestBetween() {
 	tests := []struct {
 		name  string

From 00570538440dce90a601681b6c27faac0ec28c54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=97=E5=AD=90?= <haozi@loli.email>
Date: Thu, 19 Mar 2026 14:55:24 +0800
Subject: [PATCH 11/11] test: add typed slice/array test cases for ruleArray

Cover []float64, []bool, and [N]int fixed array types.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 validation/rules_test.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/validation/rules_test.go b/validation/rules_test.go
index 16e07dcd0..5b04e89d8 100644
--- a/validation/rules_test.go
+++ b/validation/rules_test.go
@@ -904,6 +904,9 @@ func (s *RulesTestSuite) TestArray() {
 		{"pass_empty_slice", map[string]any{"x": []any{}}, map[string]any{"x": "array"}, false},
 		{"pass_empty_map", map[string]any{"x": map[string]any{}}, map[string]any{"x": "array"}, false},
 		{"pass_int_slice", map[string]any{"x": []int{1, 2}}, map[string]any{"x": "array"}, false},
+		{"pass_float64_slice", map[string]any{"x": []float64{1.1, 2.2}}, map[string]any{"x": "array"}, false},
+		{"pass_bool_slice", map[string]any{"x": []bool{true, false}}, map[string]any{"x": "array"}, false},
+		{"pass_fixed_array", map[string]any{"x": [3]int{1, 2, 3}}, map[string]any{"x": "array"}, false},
 		{"fail_string", map[string]any{"x": "hello"}, map[string]any{"x": "array"}, true},
 		{"fail_int", map[string]any{"x": 42}, map[string]any{"x": "array"}, true},
 		{"fail_nil", map[string]any{"x": nil}, map[string]any{"x": "array"}, true},