// ✅ Valid
{ "loan_amount": 50000 }

// ❌ Invalid - below minimum
{ "loan_amount": 500 }

// ❌ Invalid - exceeds typical product limit
{ "loan_amount": 1000000 }

// ✅ Valid - with hyphens
{ "ssn": "123-45-6789" }

// ✅ Valid - without hyphens
{ "ssn": "123456789" }

// ❌ Invalid - wrong length
{ "ssn": "123-45-67" }

// ✅ Valid - ISO 8601 date
{ "loan_start_date": "2025-12-20" }

// ✅ Valid - ISO 8601 datetime
{ "created_at": "2025-12-15T10:30:00Z" }

// ❌ Invalid - wrong format
{ "application_date": "12/15/2025" }

def validate_loan_amount(loan_amount, product):
    """Validate loan amount against product limits."""
    if loan_amount < product.min_amount:
        raise ValidationError(
            code="LOAN_AMOUNT_BELOW_MINIMUM",
            message=f"Loan amount ${loan_amount} below minimum ${product.min_amount}",
            details={"min_amount": product.min_amount, "provided": loan_amount}
        )
    
    if loan_amount > product.max_amount:
        raise ValidationError(
            code="LOAN_AMOUNT_EXCEEDS_LIMIT",
            message=f"Loan amount exceeds product maximum of ${product.max_amount}",
            details={"max_amount": product.max_amount, "provided": loan_amount}
        )

def validate_dti_ratio(total_monthly_debt, monthly_income, max_dti=43):
    """Validate debt-to-income ratio."""
    if monthly_income <= 0:
        raise ValidationError(
            code="INVALID_INCOME",
            message="Monthly income must be greater than zero"
        )
    
    dti_ratio = (total_monthly_debt / monthly_income) * 100
    
    if dti_ratio > max_dti:
        raise ValidationError(
            code="DTI_TOO_HIGH",
            message=f"DTI ratio {dti_ratio:.1f}% exceeds maximum {max_dti}%",
            details={"dti_ratio": dti_ratio, "max_dti": max_dti}
        )
    
    return dti_ratio

def validate_credit_score(credit_score, product):
    """Validate credit score against product requirements."""
    if credit_score < product.min_credit_score:
        raise ValidationError(
            code="CREDIT_SCORE_TOO_LOW",
            message=f"Credit score {credit_score} below minimum {product.min_credit_score}",
            details={
                "credit_score": credit_score,
                "min_required": product.min_credit_score
            }
        )

def validate_collateral(loan_amount, collateral_value, ltv_max=80):
    """Validate loan-to-value ratio."""
    if collateral_value <= 0:
        raise ValidationError(
            code="INVALID_COLLATERAL_VALUE",
            message="Collateral value must be greater than zero"
        )
    
    ltv_ratio = (loan_amount / collateral_value) * 100
    
    if ltv_ratio > ltv_max:
        raise ValidationError(
            code="INSUFFICIENT_COLLATERAL",
            message=f"LTV ratio {ltv_ratio:.1f}% exceeds maximum {ltv_max}%",
            details={
                "ltv_ratio": ltv_ratio,
                "max_ltv": ltv_max,
                "required_collateral": loan_amount / (ltv_max / 100)
            }
        )

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Request failed validation",
    "details": [
      {
        "field": "loan_amount",
        "issue": "MAX_LIMIT_EXCEEDED",
        "message": "Loan amount exceeds maximum product limit",
        "max": 50000,
        "provided": 75000
      }
    ],
    "trace_id": "a1b2c3d4e5"
  }
}

class LoanApplicationValidator:
    """Complete validation for loan applications."""
    
    def __init__(self, product_config):
        self.product = product_config
    
    def validate(self, application):
        """Run all validations on application."""
        errors = []
        
        # Field format validations
        errors.extend(self._validate_ssn(application.get('ssn')))
        errors.extend(self._validate_email(application.get('email')))
        errors.extend(self._validate_phone(application.get('phone')))
        errors.extend(self._validate_dates(application))
        
        # Business rule validations
        errors.extend(self._validate_loan_amount(application.get('loan_amount')))
        errors.extend(self._validate_dti(application))
        errors.extend(self._validate_collateral(application))
        
        if errors:
            raise ValidationError(
                code="VALIDATION_ERROR",
                message="Application validation failed",
                details=errors
            )
        
        return True
    
    def _validate_ssn(self, ssn):
        """Validate SSN format."""
        import re
        errors = []
        
        if not ssn:
            errors.append({"field": "ssn", "issue": "REQUIRED_FIELD_MISSING"})
        elif not re.match(r'^\d{3}-?\d{2}-?\d{4}$', ssn):
            errors.append({"field": "ssn", "issue": "INVALID_FORMAT"})
        
        return errors
    
    def _validate_loan_amount(self, amount):
        """Validate loan amount against product limits."""
        errors = []
        
        if not amount:
            errors.append({"field": "loan_amount", "issue": "REQUIRED_FIELD_MISSING"})
        elif amount < self.product.min_amount:
            errors.append({
                "field": "loan_amount",
                "issue": "BELOW_MINIMUM",
                "min": self.product.min_amount,
                "provided": amount
            })
        elif amount > self.product.max_amount:
            errors.append({
                "field": "loan_amount",
                "issue": "EXCEEDS_MAXIMUM",
                "max": self.product.max_amount,
                "provided": amount
            })
        
        return errors
    
    # ... additional validation methods

# Usage
validator = LoanApplicationValidator(product_config)
try:
    validator.validate(application_data)
    print("✅ Validation passed")
except ValidationError as e:
    print(f"❌ Validation failed: {e.details}")