### Single Validator Interceptor Example

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Implement `IValidatorInterceptor` directly on a validator class to intercept validation for that specific validator. This allows for fine-grained control over the validation flow.

```cs
// Example of a single validator interceptor.
private class TestValidator : AbstractValidator<TestModel>, IValidatorInterceptor
{
    public TestValidator()
    {
        RuleFor(x => x.Parameter1).Empty();
        RuleFor(x => x.Parameter2).Empty();
        RuleFor(x => x.Parameter3).Empty();
    }

    public Task<IValidationContext?> BeforeValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, CancellationToken cancellationToken = default)
    {
        // Return a custom `IValidationContext` or null.
        return Task.FromResult<IValidationContext?>(null);
    }

    public Task<ValidationResult?> AfterValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default)
    {
        // Return a custom `ValidationResult` or null.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Global Validation Interceptor for Minimal APIs

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Implement IGlobalValidationInterceptor to provide custom logic before or after validation for all endpoints. This example shows how to register the interceptor and provides a basic implementation.

```cs
builder.Services.AddTransient<IGlobalValidationInterceptor, CustomGlobalValidationInterceptor>();

public class CustomGlobalValidationInterceptor : IGlobalValidationInterceptor
{
    public Task<IValidationContext?> BeforeValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, CancellationToken cancellationToken = default)
    {
        // Return a custom `IValidationContext` or null.
        return Task.FromResult<IValidationContext?>(null);
    }

    public Task<ValidationResult?> AfterValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default)
    {
        // Return a custom `ValidationResult` or null.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Implement Global Validation Interceptor for Minimal APIs

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Register and implement `IGlobalValidationInterceptor` for Minimal APIs to intercept validation before it occurs. This example shows how to inject tenant information into the validation context.

```csharp
using FluentValidation;
using FluentValidation.Results;
using Microsoft.AspNetCore.Http;
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Interceptors;

builder.Services.AddTransient<IGlobalValidationInterceptor, TenantValidationInterceptor>();

public class TenantValidationInterceptor : IGlobalValidationInterceptor
{
    public Task<IValidationContext?> BeforeValidation(
        EndpointFilterInvocationContext context,
        IValidationContext validationContext,
        CancellationToken cancellationToken = default)
    {
        // Example: inject a tenant ID into the validation root context data.
        var tenantId = context.HttpContext.Request.Headers["X-Tenant-Id"].ToString();
        validationContext.RootContextData["TenantId"] = tenantId;

        return Task.FromResult<IValidationContext?>(validationContext);
    }

    public Task<ValidationResult?> AfterValidation(
        EndpointFilterInvocationContext context,
        IValidationContext validationContext,
        ValidationResult validationResult,
        CancellationToken cancellationToken = default)
    {
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Configure AutoValidation for Minimal APIs

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Configure FluentValidation.AutoValidation for minimal APIs by registering services and optionally overriding the default result factory. This setup enables automatic validation for endpoints.

```cs
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Extensions;

builder.Services.AddFluentValidationAutoValidation(configuration =>
{
    // Replace the default result factory with a custom implementation.
    configuration.OverrideDefaultResultFactoryWith<CustomResultFactory>();
});

public class CustomResultFactory : IFluentValidationAutoValidationResultFactory
{
    public IResult CreateResult(EndpointFilterInvocationContext context, ValidationResult validationResult)
    {
        var validationProblemErrors = validationResult.ToValidationProblemErrors();

        return Results.ValidationProblem(validationProblemErrors, "Some details text.", "Some instance text.", (int) HttpStatusCode.BadRequest, "Some title.");
    }
}
```

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

### Custom Validation Result Factory Implementation

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Implement the IFluentValidationAutoValidationResultFactory interface to create a custom result factory. This example demonstrates returning a BadRequestObjectResult with validation errors.

```csharp
public class CustomResultFactory : IFluentValidationAutoValidationResultFactory
{
    public Task<IActionResult?> CreateActionResult(ActionExecutingContext context, ValidationProblemDetails validationProblemDetails, IDictionary<IValidationContext, ValidationResult> validationResults)
    {
        return new BadRequestObjectResult(new {Title = "Validation errors", ValidationErrors = validationProblemDetails?.Errors});
    }
}
```

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

### Single Validator Interceptor for Minimal APIs

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Implement IValidatorInterceptor on a specific validator to apply custom logic only to that validator. This example demonstrates a validator with rules and interceptor methods.

```cs
private class TestValidator : AbstractValidator<TestModel>, IValidatorInterceptor
{
    public TestValidator()
    {
        RuleFor(x => x.Parameter1).Empty();
        RuleFor(x => x.Parameter2).Empty();
        RuleFor(x => x.Parameter3).Empty();
    }

    public Task<IValidationContext?> BeforeValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, CancellationToken cancellationToken = default)
    {
        // Return a custom `IValidationContext` or null.
        return Task.FromResult<IValidationContext?>(null);
    }

    public Task<ValidationResult?> AfterValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default)
    {
        // Return a custom `ValidationResult` or null.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Global Validation Interceptor Example

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Register a custom global validation interceptor to modify the validation process before and after validation occurs. This is an advanced feature for custom logic.

```cs
// Example of a global validation interceptor.
builder.Services.AddTransient<IGlobalValidationInterceptor, CustomGlobalValidationInterceptor>();

public class CustomGlobalValidationInterceptor : IGlobalValidationInterceptor
{
    public Task<IValidationContext?> BeforeValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, CancellationToken cancellationToken = default)
    {
        // Return a custom `IValidationContext` or null.
        return Task.FromResult<IValidationContext?>(null);
    }

    public Task<ValidationResult?> AfterValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default)
    {
        // Return a custom `ValidationResult` or null.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Enable Auto Validation for Minimal APIs

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Configure services and apply FluentValidation auto-validation to minimal API route groups or individual routes.

```csharp
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Extensions;

builder.Services.AddFluentValidationAutoValidation();

var app = builder.Build();
var endpointGroup = app.MapGroup("/some-group").AddFluentValidationAutoValidation();
endpointGroup.MapPost("/", (SomeModel someModel) => $"Hello {someModel.Name}");

app.MapPost("/", (SomeOtherModel someOtherModel) => $"Hello again {someOtherModel.Name}").AddFluentValidationAutoValidation();
```

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

### Configure FluentValidation AutoValidation for MVC and Minimal APIs

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Configure `AddFluentValidationAutoValidation` for both MVC and Minimal APIs. This includes options to disable built-in model validation and override the default result factory.

```csharp
// Minimal complete wiring example:
builder.Services.AddValidatorsFromAssemblyContaining<OrderValidator>();
builder.Services.AddTransient<IGlobalValidationInterceptor, TenantValidationInterceptor>();

// MVC
builder.Services.AddFluentValidationAutoValidation(cfg =>
{
    cfg.DisableBuiltInModelValidation = true;
    cfg.OverrideDefaultResultFactoryWith<ApiErrorResultFactory>();
});

// Minimal APIs
builder.Services.AddFluentValidationAutoValidation(cfg =>
{
    cfg.OverrideDefaultResultFactoryWith<CustomEndpointResultFactory>();
});
var apiGroup = app.MapGroup("/api").AddFluentValidationAutoValidation();
```

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

### Customize Validation Result Factory for Minimal APIs

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Implement IFluentValidationAutoValidationResultFactory (Endpoints namespace) to customize the failure response for minimal API endpoints. Use ToValidationProblemErrors() to group failures by property name.

```csharp
using System.Net;
using FluentValidation.Results;
using Microsoft.AspNetCore.Http;
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Extensions;
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Results;
using SharpGrip.FluentValidation.AutoValidation.Shared.Extensions;

builder.Services.AddFluentValidationAutoValidation(config =>
{
    config.OverrideDefaultResultFactoryWith<CustomEndpointResultFactory>();
});

public class CustomEndpointResultFactory : IFluentValidationAutoValidationResultFactory
{
    public IResult CreateResult(EndpointFilterInvocationContext context, ValidationResult validationResult)
    {
        // ToValidationProblemErrors() groups failures by property name.
        var errors = validationResult.ToValidationProblemErrors();

        return Results.ValidationProblem(
            errors,
            detail:   "Please fix the validation errors and retry.",
            instance: context.HttpContext.Request.Path,
            statusCode: (int) HttpStatusCode.UnprocessableEntity,
            title:    "Unprocessable Request");
    }
}
```

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

### Enable Auto Validation for MVC Controllers

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Add the necessary services to enable automatic FluentValidation for MVC controllers.

```csharp
using SharpGrip.FluentValidation.AutoValidation.Mvc.Extensions;

builder.Services.AddFluentValidationAutoValidation();
```

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

### Update Validation Interceptor Signatures - Minimal APIs

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/UPGRADING.md

Signatures for `BeforeValidation` and `AfterValidation` interceptors in Minimal APIs have been updated to include `CancellationToken`. Ensure your interceptor implementations accommodate these changes.

```csharp
public Task<IValidationContext?> BeforeValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, CancellationToken cancellationToken = default);
```

```csharp
public Task<ValidationResult?> AfterValidation(EndpointFilterInvocationContext endpointFilterInvocationContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default);
```

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

### Enable Automatic Validation for MVC Binding Sources

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Configure FluentValidation to automatically validate parameters based on their BindingSource. This includes Body, Form, Query, Path, and Custom binding sources. Ensure this configuration is applied during application startup.

```csharp
configuration.EnableBodyBindingSourceAutomaticValidation = true;

    // Enable validation for parameters bound from `BindingSource.Form` binding sources.
    configuration.EnableFormBindingSourceAutomaticValidation = true;

    // Enable validation for parameters bound from `BindingSource.Query` binding sources.
    configuration.EnableQueryBindingSourceAutomaticValidation = true;

    // Enable validation for parameters bound from `BindingSource.Path` binding sources.
    configuration.EnablePathBindingSourceAutomaticValidation = true;

    // Enable validation for parameters bound from 'BindingSource.Custom' binding sources.
    configuration.EnableCustomBindingSourceAutomaticValidation = true;
```

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

### Customize Validation Result Factory for MVC

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Implement IFluentValidationAutoValidationResultFactory to replace the default BadRequestObjectResult response. Return null to allow the action to execute despite validation errors.

```csharp
using System.Collections.Generic;
using System.Threading.Tasks;
using FluentValidation;
using FluentValidation.Results;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Extensions;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Results;

builder.Services.AddFluentValidationAutoValidation(config =>
{
    config.OverrideDefaultResultFactoryWith<ApiErrorResultFactory>();
});

public class ApiErrorResultFactory : IFluentValidationAutoValidationResultFactory
{
    public Task<IActionResult?> CreateActionResult(
        ActionExecutingContext context,
        ValidationProblemDetails validationProblemDetails,
        IDictionary<IValidationContext, ValidationResult> validationResults)
    {
        var response = new
        {
            success = false,
            code    = "VALIDATION_FAILED",
            errors  = validationProblemDetails.Errors
        };

        return Task.FromResult<IActionResult?>(new BadRequestObjectResult(response));
    }
}

// Custom response shape:
// {
//   "success": false,
//   "code": "VALIDATION_FAILED",
//   "errors": {
//     "Name": ["'Name' must not be empty."]
//   }
// }
```

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

### Control Validation with MVC Attributes

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Use attributes like [AutoValidation], [AutoValidateNever], and [AutoValidateAlways] to manage automatic validation for controllers, actions, and parameters. [AutoValidation] enables validation for the decorated element, while [AutoValidateNever] disables it. [AutoValidateAlways] forces validation regardless of other settings.

```csharp
using Microsoft.AspNetCore.Mvc;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Attributes;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Enums;

// When ValidationStrategy.Annotations is configured, only controllers or
// actions decorated with [AutoValidation] are validated automatically.
[AutoValidation]
[ApiController]
[Route("accounts")]
public class AccountsController : ControllerBase
{
    // Inherits [AutoValidation] from the class — validation runs.
    [HttpPost]
    public IActionResult Create([FromBody] CreateAccountRequest request) => Ok();

    // [AutoValidateNever] on the method suppresses validation for all parameters.
    [HttpPut("{id}")]
    [AutoValidateNever]
    public IActionResult Update(int id, [FromBody] UpdateAccountRequest request) => Ok();

    // [AutoValidateNever] on a single parameter skips only that parameter.
    [HttpPatch("{id}")]
    public IActionResult Patch(
        int id,
        [FromBody][AutoValidateNever] PatchAccountRequest request) => Ok();

    // [AutoValidateAlways] forces validation regardless of binding-source settings.
    // Useful when ApiBehaviorOptions.SuppressInferBindingSourcesForParameters is enabled.
    [HttpPost("bulk")]
    public IActionResult Bulk([AutoValidateAlways] BulkRequest request) => Ok();
}
```

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

### Register All Validators Automatically

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Automatically register all validators from the assembly containing the specified validator type.

```csharp
services.AddValidatorsFromAssemblyContaining<UserValidator>();
```

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

### Override Default Result Factory with Custom Implementation

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Replace the default result factory with a custom implementation to control how validation errors are presented. This is useful for standardizing error responses across your application.

```csharp
configuration.OverrideDefaultResultFactoryWith<CustomResultFactory>();
```

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

### Implement Per-Validator Interceptor

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Implement `IValidatorInterceptor` directly on an `AbstractValidator<T>` to intercept validation specifically for that validator type. This allows for custom logic, such as modifying the validation context or adjusting the validation result.

```csharp
using FluentValidation;
using FluentValidation.Results;
using Microsoft.AspNetCore.Mvc.Filters;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Interceptors;

public class OrderValidator : AbstractValidator<CreateOrderRequest>, IValidatorInterceptor
{
    public OrderValidator()
    {
        RuleFor(x => x.Item).NotEmpty().MaximumLength(200);
        RuleFor(x => x.Quantity).InclusiveBetween(1, 1000);
    }

    public Task<IValidationContext?> BeforeValidation(
        ActionExecutingContext context,
        IValidationContext validationContext,
        CancellationToken cancellationToken = default)
    {
        // Swap in a custom validation context, e.g. to set a RuleSet.
        var customContext = new ValidationContext<CreateOrderRequest>(
            (CreateOrderRequest) validationContext.InstanceToValidate,
            new PropertyChain(),
            new RulesetValidatorSelector(new[] { "Default" }));

        return Task.FromResult<IValidationContext?>(customContext);
    }

    public Task<ValidationResult?> AfterValidation(
        ActionExecutingContext context,
        IValidationContext validationContext,
        ValidationResult validationResult,
        CancellationToken cancellationToken = default)
    {
        // Optionally strip or add failures before the result factory sees them.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Register FluentValidation Validators

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Register validators with the ASP.NET Core DI container. Use `AddScoped` for individual registration or `AddValidatorsFromAssemblyContaining` to scan an entire assembly.

```csharp
using FluentValidation;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Option 1: manual, per-type registration
builder.Services.AddScoped<IValidator<CreateUserRequest>, CreateUserRequestValidator>();

// Option 2: scan an entire assembly automatically (recommended)
builder.Services.AddValidatorsFromAssemblyContaining<CreateUserRequestValidator>();

// Define the validator
public class CreateUserRequest
{
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public int Age { get; set; }
}

public class CreateUserRequestValidator : AbstractValidator<CreateUserRequest>
{
    public CreateUserRequestValidator()
    {
        RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Email).NotEmpty().EmailAddress();
        RuleFor(x => x.Age).InclusiveBetween(18, 120);
    }
}
```

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

### Update Result Factory Signature - MVC Controllers

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/UPGRADING.md

The signature for `CreateActionResult` in MVC controllers has been updated to include `ValidationProblemDetails` and `IDictionary<IValidationContext, ValidationResult>`. Use this updated signature for compatibility with v2.

```csharp
public Task<IActionResult?> CreateActionResult(ActionExecutingContext context, ValidationProblemDetails validationProblemDetails, IDictionary<IValidationContext, ValidationResult> validationResults);
```

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

### Register User Validator Manually

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Manually register a specific validator with the service container for dependency injection.

```csharp
services.AddScoped<IValidator<User>, UserValidator>();
```

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

### Register Auto Validation for Minimal APIs

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Registers automatic validation for minimal API route groups or individual routes by attaching FluentValidationAutoValidationEndpointFilter. Ensure validators are registered with the service container.

```csharp
using FluentValidation;
using SharpGrip.FluentValidation.AutoValidation.Endpoints.Extensions;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddValidatorsFromAssemblyContaining<CreateOrderRequestValidator>();

// Register the service-level infrastructure once.
builder.Services.AddFluentValidationAutoValidation();

var app = builder.Build();

// Apply to an entire route group — all routes in the group are validated.
var ordersGroup = app.MapGroup("/orders")
    .AddFluentValidationAutoValidation();

ordersGroup.MapPost("/", (CreateOrderRequest request) =>
    Results.Ok(new { orderId = Guid.NewGuid(), item = request.Item }));

// Or apply only to a single route.
app.MapPost("/products", (CreateProductRequest req) =>
        Results.Created($"/products/{Guid.NewGuid()}", req))
    .AddFluentValidationAutoValidation();

app.Run();

public record CreateOrderRequest(string Item, int Quantity);

public class CreateOrderRequestValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderRequestValidator()
    {
        RuleFor(x => x.Item).NotEmpty();
        RuleFor(x => x.Quantity).GreaterThan(0);
    }
}

// Failure response (HTTP 400 ValidationProblem):
// {
//   "type": "https://tools.ietf.org/html/rfc4918#section-11.2",
//   "title": "One or more validation errors occurred.",
//   "status": 400,
//   "errors": {
//     "Quantity": ["'Quantity' must be greater than '0'."]
//   }
// }
```

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

### Configure AutoValidation for MVC Controllers

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Register automatic validation for MVC controllers by adding `FluentValidationAutoValidationActionFilter`. Configure validation behavior, such as disabling built-in model validation or specifying validation strategy.

```csharp
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Extensions;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Enums;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddValidatorsFromAssemblyContaining<CreateUserRequestValidator>();
builder.Services.AddControllers();

builder.Services.AddFluentValidationAutoValidation(config =>
{
    // Disable .NET data-annotation validation so only FluentValidation runs.
    config.DisableBuiltInModelValidation = true;

    // Only validate controllers/actions decorated with [AutoValidation].
    config.ValidationStrategy = ValidationStrategy.Annotations;

    // Enable/disable per binding source (defaults shown).
    config.EnableBodyBindingSourceAutomaticValidation   = true;  // [FromBody]
    config.EnableFormBindingSourceAutomaticValidation   = true;  // [FromForm]
    config.EnableQueryBindingSourceAutomaticValidation  = true;  // [FromQuery]
    config.EnablePathBindingSourceAutomaticValidation   = true;  // [FromRoute]
    config.EnableHeaderBindingSourceAutomaticValidation = false; // [FromHeader]
    config.EnableCustomBindingSourceAutomaticValidation = false;
    config.EnableNullBindingSourceAutomaticValidation   = false;
});

var app = builder.Build();
app.MapControllers();
app.Run();

// Controller — validation runs automatically before the action body executes.
[ApiController]
[Route("users")]
public class UsersController : ControllerBase
{
    [HttpPost]
    public IActionResult Create([FromBody] CreateUserRequest request)
    {
        // Only reached when request passes validation.
        return Ok(new { message = "User '" + request.Name + "' created." });
    }
}

// Failure response (HTTP 400):
// {
//   "type": "https://tools.ietf.org/html/rfc7231#section-6.5.1",
//   "title": "One or more validation errors occurred.",
//   "status": 400,
//   "errors": {
//     "Email": ["'Email' is not a valid email address."],
//     "Age":   ["'Age' must be between 18 and 120."]
//   }
// }
```

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

### Configure MVC AutoValidation Options

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/README.md

Use this configuration to customize FluentValidation's automatic validation behavior in MVC controllers. Options include disabling built-in model validation and setting the validation strategy.

```csharp
using SharpGrip.FluentValidation.AutoValidation.Mvc.Extensions;

builder.Services.AddFluentValidationAutoValidation(configuration =>
{
    // Disable the built-in .NET model (data annotations) validation.
    configuration.DisableBuiltInModelValidation = true;

    // Only validate controllers decorated with the `AutoValidation` attribute.
    configuration.ValidationStrategy = ValidationStrategy.Annotations;

    // Enable validation for parameters bound from `BindingSource.Body` binding sources.

```

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

### Implement Global Validation Interceptor

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Register a class implementing `IGlobalValidationInterceptor` to intercept all validation attempts across MVC controllers. This allows modification of the validation context before validation or overriding the result after validation.

```csharp
using FluentValidation;
using FluentValidation.Results;
using Microsoft.AspNetCore.Mvc.Filters;
using SharpGrip.FluentValidation.AutoValidation.Mvc.Interceptors;

// Register with DI — called for every validated model.
builder.Services.AddTransient<IGlobalValidationInterceptor, LoggingValidationInterceptor>();

public class LoggingValidationInterceptor : IGlobalValidationInterceptor
{
    private readonly ILogger<LoggingValidationInterceptor> _logger;

    public LoggingValidationInterceptor(ILogger<LoggingValidationInterceptor> logger)
        => _logger = logger;

    public Task<IValidationContext?> BeforeValidation(
        ActionExecutingContext context,
        IValidationContext validationContext,
        CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("Validating {ModelType}", validationContext.InstanceToValidate?.GetType().Name);
        // Return null to use the unchanged validationContext.
        return Task.FromResult<IValidationContext?>(null);
    }

    public Task<ValidationResult?> AfterValidation(
        ActionExecutingContext context,
        IValidationContext validationContext,
        ValidationResult validationResult,
        CancellationToken cancellationToken = default)
    {
        if (!validationResult.IsValid)
            _logger.LogWarning("Validation failed with {Count} errors.", validationResult.Errors.Count);

        // Return null to use the unchanged validationResult.
        return Task.FromResult<ValidationResult?>(null);
    }
}
```

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

### Update Validation Interceptor Signatures - MVC Controllers

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/UPGRADING.md

Signatures for `BeforeValidation` and `AfterValidation` interceptors in MVC controllers have been updated to include `CancellationToken`. Ensure your interceptor implementations accommodate these changes.

```csharp
public Task<IValidationContext?> BeforeValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, CancellationToken cancellationToken = default);
```

```csharp
public Task<ValidationResult?> AfterValidation(ActionExecutingContext actionExecutingContext, IValidationContext validationContext, ValidationResult validationResult, CancellationToken cancellationToken = default);
```

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

### Convert ValidationResult to ValidationProblemErrors

Source: https://context7.com/sharpgrip/fluentvalidation.autovalidation/llms.txt

Use the `ToValidationProblemErrors` extension method to transform a `ValidationResult` into the dictionary format required by `Results.ValidationProblem`. This is useful for standalone validation or custom result factories.

```csharp
using FluentValidation;
using FluentValidation.Results;
using SharpGrip.FluentValidation.AutoValidation.Shared.Extensions;

// Standalone usage — e.g. inside a custom result factory or manual validation path.
var validator = new CreateUserRequestValidator();
var result = await validator.ValidateAsync(new CreateUserRequest
{
    Name  = "",
    Email = "not-an-email",
    Age   = 10
});

IDictionary<string, string[]> problemErrors = result.ToValidationProblemErrors();

// problemErrors:
// {
//   "Name":  ["'Name' must not be empty."],
//   "Email": ["'Email' is not a valid email address."],
//   "Age":   ["'Age' must be between 18 and 120."]
// }

// Use directly with minimal API Results helper:
if (!result.IsValid)
    return Results.ValidationProblem(problemErrors);
```

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

### Replace FluentValidationAutoValidationAttribute with AutoValidationAttribute

Source: https://github.com/sharpgrip/fluentvalidation.autovalidation/blob/master/UPGRADING.md

The `FluentValidationAutoValidationAttribute` is deprecated and should be replaced with `AutoValidationAttribute` in MVC controllers for v2 compatibility.

```csharp
[AutoValidation]
```

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