ruler

```python
# Standardized Python function for data validation
# Project: Customer Analytics Pipeline
# Rules: PEP8 compliance, type hints required, docstrings mandatory

def validate_customer_data(data: list[dict]) -> bool:
    """
    Validates customer data against schema requirements.
    
    Args:
        data: List of customer records as dictionaries
        
    Returns:
        bool: True if all records are valid, False otherwise
        
    Raises:
        ValueError: If data structure is invalid
    """
    required_fields = {'customer_id', 'email', 'join_date'}
    
    for record in data:
        if not isinstance(record, dict):
            raise ValueError("Record must be a dictionary")
        
        missing_fields = required_fields - set(record.keys())
        if missing_fields:
            raise ValueError(f"Missing fields: {missing_fields}")
            
        if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', record['email']):
            raise ValueError(f"Invalid email format: {record['email']}")
    
    return True
```

// Corresponding TypeScript version following same rules
interface CustomerRecord {
  customerId: string;
  email: string;
  joinDate: string;
}

function validateCustomerData(data: CustomerRecord[]): boolean {
  const requiredFields = new Set(['customerId', 'email', 'joinDate']);
  
  for (const record of data) {
    const missingFields = [...requiredFields].filter(field => !(field in record));
    if (missingFields.length > 0) {
      throw new Error(`Missing fields: ${missingFields.join(', ')}`);
    }
    
    if (!/^[^@]+@[^@]+\.[^@]+$/.test(record.email)) {
      throw new Error(`Invalid email format: ${record.email}`);
    }
  }
  
  return true;
}
```