Please improve the quality of this sturcture. Take care that it has to be implemented in SAP and Interfaces are only allowed if theres no better solution.
The goal is to design an Object-Oriented Framework that provides a scalable, extensible, and robust solution for managing and orchestrating various types of rules and notifications (such as email, SAP messages, and Teams workflow messages). This system must allow incidents and communication clusters to be stored in a database and retrieved from the database dynamically, ensuring high cohesion and low coupling between different message types and their respective communication channels.

Core Objectives (as an orientation):
Abstraction and Extensibility: The framework should abstract the specific logic for each element into distinct, modular components. This allows for adding new communication methods without affecting the core logic.
Communication Cluster Management: Communication clusters should be treated as top-level entities that contain relevant details (messages, recipients, channels, senders). These clusters must be easily retrievable from the database based on incidents and cluster IDs. The framework should support creating new clusters and persisting them into the database seamlessly.
Ruleset Management: A ruleset and rule should also be treated as top level entities. A rule can have multiple variants of itself. The data is different. Its needs to be extracted and be hold temporarily.
Message Routing and Notification Dispatching: Each communication cluster should dynamically handle different message types and recipients. The system must ensure that the appropriate notification channels are utilized for the specific message, leveraging polymorphism and dependency inversion to enable easy extension for future communication types.
Database Integration: The framework should support dynamic loading and saving of communication clusters and incidents from the database, ensuring that incidents can be easily reconstructed from persistent storage.
Rule-Based Incident Handling: Incidents that trigger notifications must be processed via rule sets, which dynamically create communication clusters. The framework should allow rules to define when, how, and to whom notifications are sent, ensuring flexibility in incident escalation.
Loose CouplingDesign: The system should rely on polymprohie and abstract classes to ensure loose coupling between message handling, incident handling, recipient management, and notification dispatching. This will allow for different implementations (such as SMS, email, or third-party APIs) without requiring major modifications to the framework.
Reusability and Error Handling: Every component should be reusable across multiple communication types and channels. Centralized error handling mechanisms should be in place to ensure the system is resilient to communication failures.
Dynamic and Flexible Message Creation: The framework must support the dynamic creation of messages, including adaptive message formats (e.g., rich text, HTML, or structured JSON for Teams workflows). Each message type should have a clear and extensible validation and verification process.
Rules need to be checked against RuleData. If it is activated an incident will be spawned. The Rule knows about the details for message, recipient,...
An incident should either be solved automatically, while detecting, or manually solved. Maybe there is a defined way how to solve an incident if yes it will be executed otherwise the user will be trusted that he has removed the incident.
The data to solve an incident is also needed to be stored. E.g. the idoc number if an idoc fails.

Please provide a plantuml class diagram ans sequence diagram. Also provide a data model.