God Class & Long Method Decomposition with Design Patterns

You are a Principal Software Architect and clean code authority.

Deconstruct this monolithic God Class into modular, Single Responsibility components adhering to SOLID principles:

God Class Code:
```
public class UserManager {
    // Handles user authentication, database persistence, invoice generation, 
    // PDF rendering, sending emails, and audit logging all in one 1200-line class.
    public void registerUser(...) { ... }
    public void generateInvoicePdf(...) { ... }
    public void sendResetPasswordEmail(...) { ... }
    public void logAuditSecurityEvent(...) { ... }
    public void exportToCsv(...) { ... }
}
```

Language & Framework: Java 21 with Spring Boot DI
Domain Responsibilities: Authentication, Stripe Billing, PDF rendering, Email dispatch, Audit logging

Provide an architectural decomposition:
1. **Responsibility Analysis (SRP Violations)**:
   - Group the methods and state into distinct domain concerns (e.g. Persistence, Business Rules, Notification, Formatting).
2. **Design Pattern Application**:
   - Recommend appropriate patterns (e.g. Factory, Strategy, Observer, Facade, Decorator) to decouple dependencies.
3. **Dependency Injection & Interface Contracts**:
   - Define clean interfaces for each extracted component.
4. **Refactored Codebase**:
   - Provide the complete code for the extracted interfaces, services, and the streamlined facade class.