### Validate String Content with rule.Prefix, rule.Suffix, rule.StringContains (Go)

Source: https://context7.com/foomo/fender/llms.txt

Validates that strings start with a specific prefix (`rule.Prefix`), end with a specific suffix (`rule.Suffix`), or contain a specific substring (`rule.StringContains`). These rules take the target string as an argument. The example demonstrates validation for SKU, filename, and description fields.

```Go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("sku", "ITEM-12345", rule.Prefix("SKU-")),
		fend.Field("filename", "document.txt", rule.Suffix(".pdf")),
		fend.Field("description", "Hello World", rule.StringContains("foo")),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: sku:prefix=SKU-;filename:suffix=.pdf;description:contains
	}
}
```

--------------------------------

### Detailed Error Handling and Iteration (Go)

Source: https://github.com/foomo/fender/blob/main/README.md

This example demonstrates how to handle and iterate through validation errors returned by Fender. It shows casting errors to specific types (`fender.AsError`, `fend.AsError`, `rule.AsError`) to access detailed information about failed fields and rules.

```go
func ExampleErrors() {
	err := fender.All(
		context.Background(),
		fend.Field("one", "", rule.RequiredString, rule.MinString(10)),
		fend.Field("two", "", rule.RequiredString, rule.MinString(10)),
	)

	// cast fender error
	if fenderErr := fender.AsError(err); fenderErr != nil {

		// iterate fend errors
		for _, err := range fenderErr.Errors() {

			// cast fend error
			if fendErr := fend.AsError(err); fendErr != nil {

				fmt.Println(fendErr.Name())

				// iterate rule errors
				for _, err := range fendErr.Errors() {

					// cast rule error
					if ruleErr := rule.AsError(err); ruleErr != nil {
						fmt.Println(ruleErr.Error())
					}
				}
			}
		}
	} else if err != nil {
		panic(err)
	}
	// Output:
	// one
	// required
	// min=10
	// two
	// required
	// min=10
}
```

--------------------------------

### Implement OR-Logic Validation with fend.Union (Go)

Source: https://context7.com/foomo/fender/llms.txt

Illustrates how to use `fend.Union` to create a validation rule that passes if any of the provided rule sets are satisfied. This is useful for implementing OR-logic where a field can meet multiple criteria. The example shows testing with both valid and invalid inputs.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	// Define rule sets for email OR phone validation
	emailRules := fend.NewRules(rule.StringMin(5), rule.Email)
	phoneRules := fend.NewRules(rule.StringMin(3), rule.Numeric)

	// Create a union rule that accepts either email or phone
	contactRules := fend.NewRules(fend.Union(emailRules, phoneRules))

	// Test with invalid input (neither email nor phone)
	err := fender.All(context.Background(),
		fend.Field("contact", "foo", fend.Union(emailRules, phoneRules)),
	)
	fmt.Println(err)
	// Output: contact:numeric=^[0-9]+$

	// Test with valid email
	err = fender.All(context.Background(),
		contactRules.Field("contact", "user@example.com"),
	)
	fmt.Println(err)
	// Output: <nil>

	// Test with valid phone number
	err = fender.All(context.Background(),
		contactRules.Field("contact", "1234567890"),
	)
	fmt.Println(err)
	// Output: <nil>
}
```

--------------------------------

### Skip Validation for Empty Values with rule.Optional (Go)

Source: https://context7.com/foomo/fender/llms.txt

Demonstrates the `rule.Optional` rule, which skips subsequent validation rules if the field's value is empty (zero value). This is useful for making fields optional. The example shows validation behavior for both empty and non-empty values.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	// Empty value - Optional skips subsequent rules
	err := fender.All(
		context.Background(),
		fend.Field("nickname", "", rule.Optional[string], rule.StringMin(3), rule.Alpha),
	)
	fmt.Println(err)
	// Output: <nil>

	// Non-empty value - subsequent rules are applied
	err = fender.All(
		context.Background(),
		fend.Field("nickname", "ab", rule.Optional[string], rule.StringMin(3), rule.Alpha),
	)
	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: nickname:min=3
	}
}
```

--------------------------------

### Runtime-Typed Validation with fend.DynamicField/Var (Go)

Source: https://context7.com/foomo/fender/llms.txt

Explains the use of `fend.DynamicField` and `fend.DynamicVar` for creating validators whose rules capture values at definition time. This is beneficial for complex validation scenarios where rule logic depends on runtime values. The example demonstrates a password confirmation check.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	password := "secret123"
	confirmPassword := "secret124"

	err := fender.All(
		context.Background(),
		fend.Field("password", password, rule.Required[string], rule.StringMin(8)),
		fend.DynamicField("confirmPassword", func(ctx context.Context) error {
			if password != confirmPassword {
				return fend.NewRuleError("confirmPassword", "match", "passwords must match")
			}
			return nil
		}),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: confirmPassword:match=passwords must match
	}
}
```

--------------------------------

### Validate Non-Empty Values with rule.Required (Go)

Source: https://context7.com/foomo/fender/llms.txt

Shows how to use the generic `rule.Required` to validate that a value is not the zero value for its type. This rule works with any data type. The example demonstrates its application to string, int, and bool types, showing the output when values are zero.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("name", "", rule.Required[string]),
		fend.Field("age", 0, rule.Required[int]),
		fend.Field("active", false, rule.Required[bool]),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: name:required;age:required;active:required
	}
}
```

--------------------------------

### Validate Custom Types with rule.Valid (Go)

Source: https://context7.com/foomo/fender/llms.txt

Validates custom types that implement the `Validator` interface, which requires a `Valid() bool` method. This is ideal for custom enum types or complex validation logic. The `rule.Valid` function uses generics to specify the type being validated. The example shows validation for a custom `Status` type.

```Go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

type Status string

const (
	StatusPending  Status = "pending"
	StatusApproved Status = "approved"
	StatusRejected Status = "rejected"
)

func (s Status) Valid() bool {
	return s == StatusPending || s == StatusApproved || s == StatusRejected
}

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("status1", StatusApproved, rule.Valid[Status]),
		fend.Field("status2", Status("invalid"), rule.Valid[Status]),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: status2:valid
	}
}
```

--------------------------------

### Create Reusable Rule Sets with fend.NewRules (Go)

Source: https://context7.com/foomo/fender/llms.txt

Demonstrates how to create reusable validation rule sets using `fend.NewRules`. These sets can be applied to multiple fields or variables, promoting consistency. It shows applying these rules to fields and variables using `fender.All`.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

// Define reusable validation rule sets
var (
	emailRules = fend.NewRules(
		rule.Required[string],
		rule.StringMin(6),
		rule.StringMax(100),
		rule.Email,
	)
	usernameRules = fend.NewRules(
		rule.Required[string],
		rule.StringMin(3),
		rule.StringMax(30),
		rule.Alnum,
	)
	ageRules = fend.NewRules(
		rule.Required[int],
		rule.NumberMin(18),
		rule.NumberMax(120),
	)
)

func main() {
	// Apply rule sets to fields
	err := fender.All(
		context.Background(),
		emailRules.Field("email", "test@example.com"),
		usernameRules.Field("username", "john_doe123"),
		ageRules.Field("age", 25),
	)

	if err == nil {
		fmt.Println("Validation passed!")
		// Output: Validation passed!
	}

	// Apply rule sets to variables
	err = fender.All(
		context.Background(),
		emailRules.Var("bad"),
		usernameRules.Var("ab"),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: min=6:email=parse;min=3:alnum=^[a-zA-Z0-9]+$
	}
}
```

--------------------------------

### Fender AllFirst: Validate All Fields, Return First Error (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `fender.AllFirst` function validates all fields but halts after the first field containing an error, returning all rule errors associated with that initial failing field. This is useful for validating all inputs while only displaying errors for the first problematic field encountered. It requires a context and a list of `fend.Field` validators.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.AllFirst(
		context.Background(),
		fend.Field("email", "", rule.Required[string], rule.StringMin(10)),
		fend.Field("password", "abc", rule.Required[string], rule.StringMin(8)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: email:required:min=10
	}
}
```

--------------------------------

### Validate Value Equality with rule.Equal and rule.NotEqual (Go)

Source: https://context7.com/foomo/fender/llms.txt

Validates that a given value strictly equals or does not equal an expected value using `rule.Equal` and `rule.NotEqual`. This is useful for checking against specific string literals or other comparable types. The function takes the expected value as an argument.

```Go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("status", "pending", rule.Equal("approved")),
		fend.Field("role", "admin", rule.NotEqual("admin")),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: status:equal=approved;role:equal=admin
	}
}
```

--------------------------------

### Validate Strings with Regex Patterns using rule.Match and rule.NotMatch (Go)

Source: https://context7.com/foomo/fender/llms.txt

Validates strings against custom regular expression patterns using `rule.Match` and `rule.NotMatch`. Supports named aliases for clearer error messages. This function takes a context, field name, the string to validate, and the regex rule.

```Go
package main

import (
	"context"
	"fmt"
	"regexp"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

var (
	slugPattern     = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`) 
	noSpecialChars  = regexp.MustCompile(`[^a-zA-Z0-9]`) 
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("slug", "my-blog-post", rule.Match("slug", slugPattern)),
		fend.Field("invalidSlug", "My Blog Post!", rule.Match("slug", slugPattern)),
		fend.Field("safeInput", "hello@world", rule.NotMatch("no-special", noSpecialChars)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: invalidSlug:slug=^[a-z0-9]+(?:-[a-z0-9]+)*$;safeInput:no-special=[^a-zA-Z0-9]
	}
}
```

--------------------------------

### Fender All: Validate All Fields and Collect All Errors (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `fender.All` function runs all field validators and collects every validation error from all rules across all fields. This mode is ideal for scenarios where all validation problems need to be displayed to the user simultaneously, such as in form validation. It requires a context and a variadic list of `fend.Field` validators.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("email", "", rule.Required[string], rule.StringMin(6)),
		fend.Field("username", "ab", rule.Required[string], rule.StringMin(3)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: email:required:min=6;username:min=3
	} else if err != nil {
		panic(err)
	}
}
```

--------------------------------

### Validate String Length Constraints (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.StringMin` and `rule.StringMax` functions enforce minimum and maximum length constraints for string fields, respectively. These rules are commonly used for validating user inputs like passwords or usernames to ensure they meet specific length requirements.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("password", "abc", rule.StringMin(8), rule.StringMax(64)),
		fend.Field("bio", "This is a very long biography that exceeds the maximum allowed length for this field.", rule.StringMax(50)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: password:min=8;bio:max=50
	}
}
```

--------------------------------

### Fender First: Stop at First Error (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `fender.First` function stops validation at the first field that encounters an error and returns only the first rule error from that specific field. This mode is suitable for quick validation checks or when only a single error needs to be reported at a time. It takes a context and a list of `fend.Field` validators.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.First(
		context.Background(),
		fend.Field("email", "", rule.Required[string], rule.StringMin(10)),
		fend.Field("password", "", rule.Required[string], rule.StringMin(8)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: email:required
	}
}
```

--------------------------------

### Validate Numeric Constraints (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.NumberMin`, `rule.NumberMax`, and `rule.NumberRange` functions validate numeric values against minimum, maximum, or inclusive range constraints. These rules support all numeric types through Go generics, making them versatile for various numerical validations.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("age", 15, rule.NumberMin(18)),
		fend.Field("quantity", 150, rule.NumberMax(100)),
		fend.Field("rating", 6.5, rule.NumberRange(1.0, 5.0)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: age:min=18;quantity:max=100;rating:range=1[5]
	}
}
```

--------------------------------

### Validate All Fields, Return First Error (Go)

Source: https://github.com/foomo/fender/blob/main/README.md

The `AllFirst` function validates all provided fields but stops and returns the first encountered validation error. This is efficient for scenarios where immediate feedback on the first issue is sufficient.

```go
func ExampleAllFirst() {
	err := fender.AllFirst(
		context.Background(),
		fend.Field("one", "", rule.RequiredString, rule.MinString(10)),
		fend.Field("two", "", rule.RequiredString, rule.MinString(10)),
	)

	// check for fender error
	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
	} else if err != nil {
		panic(err)
	}
	// Output: one:required:min=10
}
```

--------------------------------

### Validate URL Format (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.URL` function validates that a string represents a properly formatted URL, including a required scheme (e.g., `http`, `https`). This rule is essential for ensuring that provided URLs are syntactically correct and can be processed by web clients or servers.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("website", "https://example.com/path", rule.URL),
		fend.Field("callback", "not-a-url", rule.URL),
		fend.Field("redirect", "example.com", rule.URL),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: callback:url;redirect:url
	}
}
```

--------------------------------

### Parse and Iterate Validation Errors with Fender in Go

Source: https://context7.com/foomo/fender/llms.txt

This Go code snippet demonstrates how to use Fender's `AsError` functions to unwrap and iterate through validation errors at different levels (top-level, field, and rule). It shows how to access error details like field names, rule types, and associated metadata.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("email", "x", rule.Required[string], rule.StringMin(6), rule.Email),
		fend.Field("age", -5, rule.Required[int], rule.NumberMin(0), rule.NumberMax(120)),
	)

	// Cast to fender.Error for top-level access
	if fenderErr := fender.AsError(err); fenderErr != nil {
		fmt.Printf("Total validation errors: %d\n", len(fenderErr.FendErrs))

		// Iterate through field errors
		for _, fieldErr := range fenderErr.Errors() {
			// Cast to fend.Error for field-level access
			if fendErr := fend.AsError(fieldErr); fendErr != nil {
				fmt.Printf("\nField: %s\n", fendErr.Name())

				// Iterate through rule errors
				for _, ruleErr := range fendErr.Errors() {
					// Cast to rule.Error for rule-level access
					if rErr := rule.AsError(ruleErr); rErr != nil {
						fmt.Printf("  - Rule: %s, Meta: %v\n", rErr.Rule, rErr.Meta)
					}
				}
			}
		}
	}

	// Output:
	// Total validation errors: 2
	//
	// Field: email
	//   - Rule: min, Meta: [6]
	//   - Rule: email, Meta: [parse]
	//
	// Field: age
	//   - Rule: min, Meta: [0]
}

```

--------------------------------

### Validate All Fields (Go)

Source: https://github.com/foomo/fender/blob/main/README.md

The `All` function validates all provided fields against their respective rules. It returns an error if any validation fails, detailing all failed validations. This is useful for comprehensive data integrity checks.

```go
func ExampleAll() {
	err := fender.All(
		context.Background(),
		fend.Field("one", "", rule.RequiredString, rule.MinString(10)),
		fend.Field("two", "", rule.RequiredString, rule.MinString(10)),
	)
	// check for fender error
	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
	} else if err != nil {
		panic(err)
	}
	// Output: one:required:min=10;two:required:min=10
}
```

--------------------------------

### Validate Email Address Format (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.Email` function validates email addresses using Go's standard `mail.ParseAddress`. Additionally, `rule.EmailWeak` offers basic regex validation, and `rule.EmailLookup` performs DNS verification for more robust checks. These rules are essential for ensuring valid email inputs.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("email1", "valid@example.com", rule.Email),
		fend.Field("email2", "invalid-email", rule.Email),
		fend.Field("email3", "weak@test", rule.EmailWeak),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: email2:email=parse;email3:email=weak
	}
}
```

--------------------------------

### Validate String Length Range (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.StringRange` function validates that the length of a string falls within a specified inclusive range. This rule is useful when a field must meet both a minimum and maximum length requirement, providing a concise way to define such constraints.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("username", "ab", rule.StringRange(3, 20)),
		fend.Field("password", "x", rule.StringRange(8, 64)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: username:range=3[20];password:range=8[64]
	}
}
```

--------------------------------

### Validate UUID Format (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.UUID` function validates that a given string adheres to the standard Universally Unique Identifier (UUID) format. This is crucial for ensuring data integrity when dealing with unique identifiers across distributed systems.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("userId", "550e8400-e29b-41d4-a716-446655440000", rule.UUID),
		fend.Field("orderId", "not-a-uuid", rule.UUID),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: orderId:uuid
	}
}
```

--------------------------------

### Validate First Field Only (Go)

Source: https://github.com/foomo/fender/blob/main/README.md

The `First` function validates fields sequentially and returns the error from the very first field that fails validation. This is useful for simple, ordered validation checks.

```go
func ExampleFirst() {
	err := fender.First(
		context.Background(),
		fend.Field("one", "", rule.RequiredString, rule.MinString(10)),
		fend.Field("two", "", rule.RequiredString, rule.MinString(10)),
	)

	// check for fender error
	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
	} else if err != nil {
		panic(err)
	}
	// Output: one:required
}
```

--------------------------------

### Validate Character Types with rule.Alpha, rule.Alnum, rule.Numeric (Go)

Source: https://context7.com/foomo/fender/llms.txt

Validates that strings contain only alphabetic characters (`rule.Alpha`), alphanumeric characters (`rule.Alnum`), or numeric digits (`rule.Numeric`). These rules are applied directly without arguments. The output shows the default regex patterns used for validation.

```Go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	err := fender.All(
		context.Background(),
		fend.Field("firstName", "John123", rule.Alpha),
		fend.Field("username", "user@name", rule.Alnum),
		fend.Field("zipCode", "12345a", rule.Numeric),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: firstName:alpha=^[a-zA-Z]+$;username:alnum=^[a-zA-Z0-9]+$;zipCode:numeric=^[0-9]+$
	}
}
```

--------------------------------

### Fend Var: Anonymous Variable Validation (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `fend.Var` function creates a validator for a standalone value without associating it with a field name. This is useful for validating variables where field names are not relevant in error messages. It accepts the value to validate and a variadic list of validation rules.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	password := "short"

	err := fender.All(
		context.Background(),
		fend.Var(password, rule.Required[string], rule.StringMin(8), rule.StringMax(64)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: min=8
	}
}
```

--------------------------------

### Fend Field: Named Field Validation (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `fend.Field` function creates a validator for a specific named field, associating a value with a set of validation rules. The field's name is included in error messages, simplifying the identification of validation failures. This function is used within orchestrator functions like `fender.All`.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	type UserInput struct {
		Email    string
		Username string
		Age      int
	}

	input := UserInput{
		Email:    "invalid",
		Username: "jo",
		Age:      15,
	}

	err := fender.All(
		context.Background(),
		fend.Field("email", input.Email, rule.Required[string], rule.Email),
		fend.Field("username", input.Username, rule.Required[string], rule.StringMin(3)),
		fend.Field("age", input.Age, rule.Required[int], rule.NumberMin(18)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: email:email=parse;username:min=3;age:min=18
	}
}
```

--------------------------------

### Conditionally Validate Field as Required (Go)

Source: https://context7.com/foomo/fender/llms.txt

The `rule.IsRequired` function conditionally validates a field to be required based on a boolean flag. If the field is not required, it returns `ErrBreak` to skip subsequent validation rules for that field. This is useful for scenarios where a field's mandatory status depends on other conditions.

```go
package main

import (
	"context"
	"fmt"

	"github.com/foomo/fender"
	"github.com/foomo/fender/fend"
	"github.com/foomo/fender/rule"
)

func main() {
	isBusinessAccount := true

	err := fender.All(
		context.Background(),
		fend.Field("companyName", "", rule.IsRequired[string](isBusinessAccount), rule.StringMin(2)),
	)

	if fendErr := fender.AsError(err); fendErr != nil {
		fmt.Println(err)
		// Output: companyName:required
	}

	// When not required, empty values pass
	isBusinessAccount = false
	err = fender.All(
		context.Background(),
		fend.Field("companyName", "", rule.IsRequired[string](isBusinessAccount), rule.StringMin(2)),
	)
	fmt.Println(err)
	// Output: <nil>
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.