Skip to main content

qualia_core_db/specialized_libs/medical_computing/
privacy.rs

1use super::*;
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4
5/// Privacy protection
6pub struct PrivacyProtection {
7    encryption: EncryptionManager,
8    anonymization: AnonymizationEngine,
9    access_logging: AccessLogging,
10    consent_management: ConsentManagement,
11}
12
13/// Encryption manager
14pub struct EncryptionManager {
15    encryption_algorithms: HashMap<String, EncryptionAlgorithm>,
16    key_management: KeyManagement,
17    data_protection: DataProtection,
18}
19
20/// Encryption algorithms
21#[derive(Debug, Clone)]
22pub struct EncryptionAlgorithm {
23    pub algorithm_id: String,
24    pub algorithm_name: String,
25    pub algorithm_type: EncryptionType,
26    pub key_size: u32,
27    pub strength: EncryptionStrength,
28}
29
30/// Encryption types
31#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32pub enum EncryptionType {
33    AES,
34    RSA,
35    ECC,
36    ChaCha20,
37    Custom(String),
38}
39
40/// Encryption strength
41#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
42pub enum EncryptionStrength {
43    Weak,
44    Moderate,
45    Strong,
46    Military,
47}
48
49/// Key management
50pub struct KeyManagement {
51    keys: HashMap<String, EncryptionKey>,
52    key_rotation: KeyRotation,
53    key_recovery: KeyRecovery,
54}
55
56/// Encryption keys
57#[derive(Debug, Clone)]
58pub struct EncryptionKey {
59    pub key_id: String,
60    pub key_type: KeyType,
61    pub key_value: Vec<u8>,
62    pub creation_date: u64,
63    pub expiry_date: Option<u64>,
64    pub usage_count: u64,
65}
66
67/// Key types
68#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
69pub enum KeyType {
70    Symmetric,
71    Asymmetric,
72    Public,
73    Private,
74}
75
76/// Key rotation
77pub struct KeyRotation {
78    rotation_policy: RotationPolicy,
79    rotation_schedule: RotationSchedule,
80    rotation_history: RotationHistory,
81}
82
83/// Rotation policy
84#[derive(Debug, Clone)]
85pub struct RotationPolicy {
86    pub policy_id: String,
87    pub rotation_interval: u32,
88    pub rotation_trigger: RotationTrigger,
89    pub compliance_requirements: Vec<ComplianceRequirement>,
90}
91
92/// Rotation triggers
93#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
94pub enum RotationTrigger {
95    TimeBased,
96    UsageBased,
97    SecurityEvent,
98    Manual,
99}
100
101/// Compliance requirements
102#[derive(Debug, Clone)]
103pub struct ComplianceRequirement {
104    pub requirement_id: String,
105    pub standard: String,
106    pub requirement: String,
107    pub mandatory: bool,
108}
109
110/// Rotation schedule
111#[derive(Debug, Clone)]
112pub struct RotationSchedule {
113    pub schedule_id: String,
114    pub next_rotation: u64,
115    pub rotation_frequency: u32,
116    pub affected_keys: Vec<String>,
117}
118
119/// Rotation history
120#[derive(Debug, Clone)]
121pub struct RotationHistory {
122    pub history_id: String,
123    pub rotation_date: u64,
124    pub old_key: String,
125    pub new_key: String,
126    pub reason: String,
127}
128
129/// Key recovery
130pub struct KeyRecovery {
131    recovery_methods: HashMap<String, RecoveryMethod>,
132    recovery_procedures: HashMap<String, RecoveryProcedure>,
133}
134
135/// Recovery methods
136#[derive(Debug, Clone)]
137pub struct RecoveryMethod {
138    pub method_id: String,
139    pub method_type: RecoveryMethodType,
140    pub security_level: SecurityLevel,
141}
142
143/// Recovery method types
144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145pub enum RecoveryMethodType {
146    ShamirSecretSharing,
147    HardwareToken,
148    Biometric,
149    MultiFactor,
150}
151
152/// Security levels
153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
154pub enum SecurityLevel {
155    Low,
156    Medium,
157    High,
158    Maximum,
159}
160
161/// Recovery procedures
162#[derive(Debug, Clone)]
163pub struct RecoveryProcedure {
164    pub procedure_id: String,
165    pub steps: Vec<RecoveryStep>,
166    pub verification_required: bool,
167}
168
169/// Recovery steps
170#[derive(Debug, Clone)]
171pub struct RecoveryStep {
172    pub step_id: String,
173    pub step_description: String,
174    pub step_type: RecoveryStepType,
175}
176
177/// Recovery step types
178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
179pub enum RecoveryStepType {
180    Authentication,
181    Verification,
182    Decryption,
183    Validation,
184}
185
186/// Data protection
187pub struct DataProtection {
188    protection_policies: HashMap<String, ProtectionPolicy>,
189    breach_detection: BreachDetection,
190    incident_response: IncidentResponse,
191}
192
193/// Protection policies
194#[derive(Debug, Clone)]
195pub struct ProtectionPolicy {
196    pub policy_id: String,
197    pub policy_name: String,
198    pub policy_type: PolicyType,
199    pub data_classification: DataClassification,
200    pub access_controls: Vec<AccessControl>,
201}
202
203/// Policy types
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
205pub enum PolicyType {
206    HIPAA,
207    GDPR,
208    CCPA,
209    HITRUST,
210    Custom(String),
211}
212
213/// Data classification
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
215pub enum DataClassification {
216    Public,
217    Internal,
218    Confidential,
219    Restricted,
220    PHI, // Protected Health Information
221}
222
223/// Access controls
224#[derive(Debug, Clone)]
225pub struct AccessControl {
226    pub control_id: String,
227    pub control_type: AccessControlType,
228    pub permissions: Vec<Permission>,
229    pub conditions: Vec<AccessCondition>,
230}
231
232/// Access control types
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234pub enum AccessControlType {
235    RoleBased,
236    AttributeBased,
237    RuleBased,
238    Discretionary,
239}
240
241/// Permissions
242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
243pub enum Permission {
244    Read,
245    Write,
246    Delete,
247    Share,
248    Export,
249}
250
251/// Access conditions
252#[derive(Debug, Clone)]
253pub struct AccessCondition {
254    pub condition_id: String,
255    pub condition_type: ConditionType,
256    pub condition_value: String,
257}
258
259/// Condition types
260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
261pub enum ConditionType {
262    Time,
263    Location,
264    Device,
265    User,
266}
267
268/// Breach detection
269pub struct BreachDetection {
270    detection_algorithms: HashMap<String, DetectionAlgorithm>,
271    alert_systems: HashMap<String, AlertSystem>,
272}
273
274/// Detection algorithms
275#[derive(Debug, Clone)]
276pub struct DetectionAlgorithm {
277    pub algorithm_id: String,
278    pub algorithm_type: DetectionAlgorithmType,
279    pub sensitivity: f64,
280    pub false_positive_rate: f64,
281}
282
283/// Detection algorithm types
284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
285pub enum DetectionAlgorithmType {
286    AnomalyDetection,
287    PatternRecognition,
288    MachineLearning,
289    RuleBased,
290}
291
292/// Alert systems
293#[derive(Debug, Clone)]
294pub struct AlertSystem {
295    pub system_id: String,
296    pub system_type: AlertSystemType,
297    pub notification_channels: Vec<NotificationChannel>,
298}
299
300/// Alert system types
301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
302pub enum AlertSystemType {
303    Email,
304    SMS,
305    Slack,
306    Pager,
307    Custom(String),
308}
309
310/// Notification channels
311#[derive(Debug, Clone)]
312pub struct NotificationChannel {
313    pub channel_id: String,
314    pub channel_type: NotificationChannelType,
315    pub configuration: ChannelConfiguration,
316}
317
318/// Notification channel types
319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
320pub enum NotificationChannelType {
321    Email,
322    SMS,
323    Webhook,
324    API,
325}
326
327/// Channel configuration
328#[derive(Debug, Clone)]
329pub struct ChannelConfiguration {
330    pub endpoint: String,
331    pub authentication: AuthenticationMethod,
332    pub format: MessageFormat,
333}
334
335/// Message formats
336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
337pub enum MessageFormat {
338    JSON,
339    XML,
340    Text,
341    Custom(String),
342}
343
344/// Incident response
345pub struct IncidentResponse {
346    response_plans: HashMap<String, ResponsePlan>,
347    response_team: ResponseTeam,
348    escalation_procedures: EscalationProcedures,
349}
350
351/// Response plans
352#[derive(Debug, Clone)]
353pub struct ResponsePlan {
354    pub plan_id: String,
355    pub plan_name: String,
356    pub plan_type: ResponsePlanType,
357    pub steps: Vec<ResponseStep>,
358}
359
360/// Response plan types
361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
362pub enum ResponsePlanType {
363    DataBreach,
364    SecurityIncident,
365    PrivacyViolation,
366    SystemOutage,
367}
368
369/// Response steps
370#[derive(Debug, Clone)]
371pub struct ResponseStep {
372    pub step_id: String,
373    pub step_description: String,
374    pub step_type: ResponseStepType,
375    pub responsible_party: String,
376    pub deadline: u32,
377}
378
379/// Response step types
380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
381pub enum ResponseStepType {
382    Investigation,
383    Containment,
384    Eradication,
385    Recovery,
386    Reporting,
387}
388
389/// Response team
390#[derive(Debug, Clone)]
391pub struct ResponseTeam {
392    pub team_id: String,
393    pub team_name: String,
394    pub members: Vec<TeamMember>,
395    pub roles: HashMap<String, TeamRole>,
396}
397
398/// Team members
399#[derive(Debug, Clone)]
400pub struct TeamMember {
401    pub member_id: String,
402    pub name: String,
403    pub role: String,
404    pub contact_info: ContactInfo,
405    pub availability: Availability,
406}
407
408/// Availability
409#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
410pub enum Availability {
411    Available,
412    Busy,
413    OnCall,
414    Unavailable,
415}
416
417/// Team roles
418#[derive(Debug, Clone)]
419pub struct TeamRole {
420    pub role_id: String,
421    pub role_name: String,
422    pub responsibilities: Vec<String>,
423    pub authority_level: AuthorityLevel,
424}
425
426/// Authority levels
427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
428pub enum AuthorityLevel {
429    Observer,
430    Operator,
431    Manager,
432    Director,
433}
434
435/// Escalation procedures
436pub struct EscalationProcedures {
437    escalation_rules: HashMap<String, EscalationRule>,
438    escalation_matrix: EscalationMatrix,
439}
440
441/// Escalation rules
442#[derive(Debug, Clone)]
443pub struct EscalationRule {
444    pub rule_id: String,
445    pub rule_name: String,
446    pub trigger_conditions: Vec<TriggerCondition>,
447    pub escalation_actions: Vec<EscalationAction>,
448}
449
450/// Trigger conditions
451#[derive(Debug, Clone)]
452pub struct TriggerCondition {
453    pub condition_id: String,
454    pub condition_type: TriggerConditionType,
455    pub condition_value: String,
456}
457
458/// Trigger condition types
459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
460pub enum TriggerConditionType {
461    Severity,
462    Time,
463    Impact,
464    Compliance,
465}
466
467/// Escalation actions
468#[derive(Debug, Clone)]
469pub struct EscalationAction {
470    pub action_id: String,
471    pub action_type: EscalationActionType,
472    pub action_details: String,
473}
474
475/// Escalation action types
476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
477pub enum EscalationActionType {
478    Notify,
479    Escalate,
480    Activate,
481    Report,
482}
483
484/// Escalation matrix
485#[derive(Debug, Clone)]
486pub struct EscalationMatrix {
487    pub matrix_id: String,
488    pub matrix_name: String,
489    pub escalation_levels: Vec<EscalationLevel>,
490}
491
492/// Escalation levels
493#[derive(Debug, Clone)]
494pub struct EscalationLevel {
495    pub level_id: String,
496    pub level_name: String,
497    pub level_number: u32,
498    pub notification_recipients: Vec<String>,
499    pub response_time: u32,
500}
501
502/// Anonymization engine
503pub struct AnonymizationEngine {
504    anonymization_methods: HashMap<String, AnonymizationMethod>,
505    privacy_models: HashMap<String, PrivacyModel>,
506    risk_assessment: RiskAssessment,
507}
508
509/// Anonymization methods
510#[derive(Debug, Clone)]
511pub struct AnonymizationMethod {
512    pub method_id: String,
513    pub method_name: String,
514    pub method_type: AnonymizationMethodType,
515    pub parameters: AnonymizationParameters,
516}
517
518/// Anonymization method types
519#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
520pub enum AnonymizationMethodType {
521    Suppression,
522    Generalization,
523    Perturbation,
524    Masking,
525    Pseudonymization,
526}
527
528/// Anonymization parameters
529#[derive(Debug, Clone, Serialize, Deserialize)]
530pub struct AnonymizationParameters {
531    pub privacy_threshold: f64,
532    pub information_loss: f64,
533    pub utility_preservation: f64,
534}
535
536/// Privacy models
537#[derive(Debug, Clone)]
538pub struct PrivacyModel {
539    pub model_id: String,
540    pub model_name: String,
541    pub model_type: PrivacyModelType,
542    pub parameters: PrivacyModelParameters,
543}
544
545/// Privacy model types
546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
547pub enum PrivacyModelType {
548    KAnonymity,
549    LDiversity,
550    TCloseness,
551    DifferentialPrivacy,
552}
553
554/// Privacy model parameters
555#[derive(Debug, Clone, Serialize, Deserialize)]
556pub struct PrivacyModelParameters {
557    pub k_value: Option<u32>,
558    pub l_value: Option<u32>,
559    pub t_value: Option<f64>,
560    pub epsilon: Option<f64>,
561}
562
563/// Risk assessment
564pub struct RiskAssessment {
565    risk_models: HashMap<String, RiskModel>,
566    risk_metrics: HashMap<String, RiskMetric>,
567}
568
569/// Risk models
570#[derive(Debug, Clone)]
571pub struct RiskModel {
572    pub model_id: String,
573    pub model_name: String,
574    pub model_type: RiskModelType,
575    pub risk_factors: Vec<RiskFactor>,
576}
577
578/// Risk model types
579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
580pub enum RiskModelType {
581    Statistical,
582    MachineLearning,
583    ExpertSystem,
584    Hybrid,
585}
586
587/// Risk factors
588#[derive(Debug, Clone)]
589pub struct RiskFactor {
590    pub factor_id: String,
591    pub factor_name: String,
592    pub factor_weight: f64,
593    pub factor_value: f64,
594}
595
596/// Risk metrics
597#[derive(Debug, Clone)]
598pub struct RiskMetric {
599    pub metric_id: String,
600    pub metric_name: String,
601    pub metric_value: f64,
602    pub metric_threshold: f64,
603}
604
605/// Access logging
606pub struct AccessLogging {
607    log_entries: HashMap<String, LogEntry>,
608    log_analysis: LogAnalysis,
609    retention_policy: RetentionPolicy,
610}
611
612/// Log entries
613#[derive(Debug, Clone)]
614pub struct LogEntry {
615    pub entry_id: String,
616    pub timestamp: u64,
617    pub user_id: String,
618    pub action: AccessAction,
619    pub resource: String,
620    pub outcome: AccessOutcome,
621    pub details: String,
622}
623
624/// Access actions
625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
626pub enum AccessAction {
627    Read,
628    Write,
629    Delete,
630    Share,
631    Export,
632    Login,
633    Logout,
634}
635
636/// Access outcomes
637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
638pub enum AccessOutcome {
639    Success,
640    Failure,
641    Blocked,
642    Suspicious,
643}
644
645/// Log analysis
646pub struct LogAnalysis {
647    analysis_methods: HashMap<String, AnalysisMethod>,
648    anomaly_detection: AnomalyDetection,
649}
650
651/// Analysis methods
652#[derive(Debug, Clone)]
653pub struct AnalysisMethod {
654    pub method_id: String,
655    pub method_name: String,
656    pub method_type: AnalysisMethodType,
657}
658
659/// Analysis method types
660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
661pub enum AnalysisMethodType {
662    Statistical,
663    Pattern,
664    Behavioral,
665    Temporal,
666}
667
668/// Anomaly detection
669#[derive(Debug, Clone)]
670pub struct AnomalyDetection {
671    detection_algorithms: HashMap<String, DetectionAlgorithm>,
672    alert_thresholds: HashMap<String, f64>,
673}
674
675/// Retention policy
676#[derive(Debug, Clone)]
677pub struct RetentionPolicy {
678    pub policy_id: String,
679    pub policy_name: String,
680    pub retention_period: u32,
681    pub archival_period: u32,
682    pub deletion_method: DeletionMethod,
683}
684
685/// Deletion methods
686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
687pub enum DeletionMethod {
688    SoftDelete,
689    HardDelete,
690    SecureDelete,
691}
692
693/// Consent management
694pub struct ConsentManagement {
695    consent_records: HashMap<String, ConsentRecord>,
696    consent_policies: HashMap<String, ConsentPolicy>,
697    consent_workflows: HashMap<String, ConsentWorkflow>,
698}
699
700/// Consent records
701#[derive(Debug, Clone)]
702pub struct ConsentRecord {
703    pub record_id: String,
704    pub patient_id: String,
705    pub consent_type: ConsentType,
706    pub consent_status: ConsentStatus,
707    pub granted_date: u64,
708    pub expiry_date: Option<u64>,
709    pub purpose: String,
710    pub limitations: Vec<String>,
711}
712
713/// Consent types
714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
715pub enum ConsentType {
716    Treatment,
717    Research,
718    DataSharing,
719    Marketing,
720    Genetic,
721}
722
723/// Consent status
724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
725pub enum ConsentStatus {
726    Granted,
727    Denied,
728    Revoked,
729    Expired,
730}
731
732/// Consent policies
733#[derive(Debug, Clone)]
734pub struct ConsentPolicy {
735    pub policy_id: String,
736    pub policy_name: String,
737    pub policy_type: ConsentPolicyType,
738    pub requirements: Vec<ConsentRequirement>,
739}
740
741/// Consent policy types
742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
743pub enum ConsentPolicyType {
744    HIPAA,
745    GDPR,
746    Institutional,
747    StudySpecific,
748}
749
750/// Consent requirements
751#[derive(Debug, Clone)]
752pub struct ConsentRequirement {
753    pub requirement_id: String,
754    pub requirement_name: String,
755    pub requirement_type: RequirementType,
756    pub mandatory: bool,
757}
758
759/// Requirement types
760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
761pub enum RequirementType {
762    Informed,
763    Written,
764    Witnessed,
765    Electronic,
766}
767
768/// Consent workflows
769#[derive(Debug, Clone)]
770pub struct ConsentWorkflow {
771    pub workflow_id: String,
772    pub workflow_name: String,
773    pub workflow_steps: Vec<WorkflowStep>,
774}
775
776/// Workflow steps
777#[derive(Debug, Clone)]
778pub struct WorkflowStep {
779    pub step_id: String,
780    pub step_name: String,
781    pub step_type: WorkflowStepType,
782    pub step_order: u32,
783}
784
785/// Workflow step types
786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
787pub enum WorkflowStepType {
788    Information,
789    Acknowledgment,
790    Signature,
791    Review,
792}
793
794/// Data access control
795pub struct DataAccessControl {
796    access_policies: HashMap<String, AccessPolicy>,
797    authentication: AuthenticationSystem,
798    authorization: AuthorizationSystem,
799}
800
801/// Access policies
802#[derive(Debug, Clone)]
803pub struct AccessPolicy {
804    pub policy_id: String,
805    pub policy_name: String,
806    pub policy_type: AccessPolicyType,
807    pub rules: Vec<AccessRule>,
808}
809
810/// Access policy types
811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
812pub enum AccessPolicyType {
813    RoleBased,
814    AttributeBased,
815    RuleBased,
816    Hybrid,
817}
818
819/// Access rules
820#[derive(Debug, Clone)]
821pub struct AccessRule {
822    pub rule_id: String,
823    pub rule_name: String,
824    pub conditions: Vec<AccessCondition>,
825    pub actions: Vec<AccessAction>,
826}
827
828/// Authentication system
829pub struct AuthenticationSystem {
830    authentication_methods: HashMap<String, AuthenticationMethod>,
831    session_management: SessionManagement,
832    multi_factor: MultiFactorAuthentication,
833}
834
835/// Authentication methods
836#[derive(Debug, Clone)]
837pub struct AuthenticationMethod {
838    pub method_id: String,
839    pub method_name: String,
840    pub method_type: AuthenticationMethodType,
841    pub security_level: SecurityLevel,
842}
843
844/// Authentication method types
845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
846pub enum AuthenticationMethodType {
847    Password,
848    Biometric,
849    Token,
850    Certificate,
851    SSO,
852}
853
854/// Session management
855pub struct SessionManagement {
856    sessions: HashMap<String, Session>,
857    session_policies: HashMap<String, SessionPolicy>,
858}
859
860/// Sessions
861#[derive(Debug, Clone)]
862pub struct Session {
863    pub session_id: String,
864    pub user_id: String,
865    pub creation_time: u64,
866    pub expiry_time: u64,
867    pub last_activity: u64,
868    pub ip_address: String,
869    pub user_agent: String,
870}
871
872/// Session policies
873#[derive(Debug, Clone)]
874pub struct SessionPolicy {
875    pub policy_id: String,
876    pub policy_name: String,
877    pub session_timeout: u32,
878    pub idle_timeout: u32,
879    pub max_concurrent_sessions: u32,
880}
881
882/// Multi-factor authentication
883pub struct MultiFactorAuthentication {
884    factors: HashMap<String, AuthenticationFactor>,
885    factor_combinations: HashMap<String, FactorCombination>,
886}
887
888/// Authentication factors
889#[derive(Debug, Clone)]
890pub struct AuthenticationFactor {
891    pub factor_id: String,
892    pub factor_type: AuthenticationFactorType,
893    pub factor_provider: String,
894}
895
896/// Authentication factor types
897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
898pub enum AuthenticationFactorType {
899    Knowledge,
900    Possession,
901    Inherence,
902    Location,
903}
904
905/// Factor combinations
906#[derive(Debug, Clone)]
907pub struct FactorCombination {
908    pub combination_id: String,
909    pub combination_name: String,
910    pub required_factors: Vec<String>,
911}
912
913/// Authorization system
914pub struct AuthorizationSystem {
915    authorization_policies: HashMap<String, AuthorizationPolicy>,
916    permission_management: PermissionManagement,
917    role_management: RoleManagement,
918}
919
920/// Authorization policies
921#[derive(Debug, Clone)]
922pub struct AuthorizationPolicy {
923    pub policy_id: String,
924    pub policy_name: String,
925    pub policy_type: AuthorizationPolicyType,
926    pub policy_rules: Vec<AuthorizationRule>,
927}
928
929/// Authorization policy types
930#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
931pub enum AuthorizationPolicyType {
932    Allow,
933    Deny,
934    Conditional,
935}
936
937/// Authorization rules
938#[derive(Debug, Clone)]
939pub struct AuthorizationRule {
940    pub rule_id: String,
941    pub rule_name: String,
942    pub conditions: Vec<AuthorizationCondition>,
943    pub decision: AuthorizationDecision,
944}
945
946/// Authorization conditions
947#[derive(Debug, Clone)]
948pub struct AuthorizationCondition {
949    pub condition_id: String,
950    pub condition_type: AuthorizationConditionType,
951    pub condition_value: String,
952}
953
954/// Authorization condition types
955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
956pub enum AuthorizationConditionType {
957    User,
958    Role,
959    Resource,
960    Time,
961    Location,
962}
963
964/// Authorization decisions
965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
966pub enum AuthorizationDecision {
967    Permit,
968    Deny,
969    NotApplicable,
970}
971
972/// Permission management
973pub struct PermissionManagement {
974    permissions: HashMap<String, Permission>,
975    permission_groups: HashMap<String, PermissionGroup>,
976}
977
978/// Permission groups
979#[derive(Debug, Clone)]
980pub struct PermissionGroup {
981    pub group_id: String,
982    pub group_name: String,
983    pub permissions: Vec<String>,
984}
985
986/// Role management
987pub struct RoleManagement {
988    roles: HashMap<String, Role>,
989    role_hierarchy: RoleHierarchy,
990}
991
992/// Roles
993#[derive(Debug, Clone)]
994pub struct Role {
995    pub role_id: String,
996    pub role_name: String,
997    pub role_description: String,
998    pub permissions: Vec<String>,
999}
1000
1001/// Role hierarchy
1002#[derive(Debug, Clone)]
1003pub struct RoleHierarchy {
1004    pub hierarchy_id: String,
1005    pub parent_roles: Vec<String>,
1006    pub child_roles: Vec<String>,
1007}
1008impl PrivacyProtection {
1009    /// Create a `PrivacyProtection` with default sub-components / empty registries.
1010    pub fn new() -> Self {
1011        Self {
1012            encryption: EncryptionManager::new(),
1013            anonymization: AnonymizationEngine::new(),
1014            access_logging: AccessLogging::new(),
1015            consent_management: ConsentManagement::new(),
1016        }
1017    }
1018
1019    /// Initialize owned sub-components in dependency order.
1020    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1021        self.encryption.initialize()?;
1022        self.anonymization.initialize()?;
1023        self.access_logging.initialize()?;
1024        self.consent_management.initialize()?;
1025        Ok(())
1026    }
1027}
1028
1029impl EncryptionManager {
1030    /// Create a `EncryptionManager` with default sub-components / empty registries.
1031    pub fn new() -> Self {
1032        Self {
1033            encryption_algorithms: HashMap::new(),
1034            key_management: KeyManagement::new(),
1035            data_protection: DataProtection::new(),
1036        }
1037    }
1038
1039    /// Initialize owned sub-components in dependency order.
1040    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1041        self.key_management.initialize()?;
1042        self.data_protection.initialize()?;
1043        Ok(())
1044    }
1045
1046    /// Register `algorithm` (keyed by its id field).
1047    pub fn add_algorithm(&mut self, algorithm: EncryptionAlgorithm) {
1048        self.encryption_algorithms
1049            .insert(algorithm.algorithm_id.clone(), algorithm);
1050    }
1051
1052    /// Fetch the registered `algorithm` by id, or `None`.
1053    pub fn get_algorithm(&self, algorithm_id: &str) -> Option<&EncryptionAlgorithm> {
1054        self.encryption_algorithms.get(algorithm_id)
1055    }
1056
1057    /// Ids of every registered `algorithms`.
1058    pub fn list_algorithms(&self) -> Vec<String> {
1059        self.encryption_algorithms.keys().cloned().collect()
1060    }
1061}
1062
1063impl KeyManagement {
1064    /// Create a `KeyManagement` with default sub-components / empty registries.
1065    pub fn new() -> Self {
1066        Self {
1067            keys: HashMap::new(),
1068            key_rotation: KeyRotation::new(),
1069            key_recovery: KeyRecovery::new(),
1070        }
1071    }
1072
1073    /// Initialize owned sub-components in dependency order.
1074    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1075        Ok(())
1076    }
1077
1078    /// Register `key` (keyed by its id field).
1079    pub fn add_key(&mut self, key: EncryptionKey) {
1080        self.keys.insert(key.key_id.clone(), key);
1081    }
1082
1083    /// Fetch the registered `key` by id, or `None`.
1084    pub fn get_key(&self, key_id: &str) -> Option<&EncryptionKey> {
1085        self.keys.get(key_id)
1086    }
1087
1088    /// Remove `key` by id, returning it when present.
1089    pub fn remove_key(&mut self, key_id: &str) -> Option<EncryptionKey> {
1090        self.keys.remove(key_id)
1091    }
1092
1093    /// Borrow the `KeyRotation` sub-component.
1094    pub fn key_rotation(&self) -> &KeyRotation {
1095        &self.key_rotation
1096    }
1097
1098    /// Borrow the `KeyRecovery` sub-component.
1099    pub fn key_recovery(&self) -> &KeyRecovery {
1100        &self.key_recovery
1101    }
1102}
1103
1104impl KeyRotation {
1105    /// Create a `KeyRotation` with default sub-components / empty registries.
1106    pub fn new() -> Self {
1107        Self {
1108            rotation_policy: RotationPolicy::new(),
1109            rotation_schedule: RotationSchedule::new(),
1110            rotation_history: RotationHistory::new(),
1111        }
1112    }
1113
1114    /// Borrow the `RotationPolicy` sub-component.
1115    pub fn rotation_policy(&self) -> &RotationPolicy {
1116        &self.rotation_policy
1117    }
1118
1119    /// Borrow the `RotationSchedule` sub-component.
1120    pub fn rotation_schedule(&self) -> &RotationSchedule {
1121        &self.rotation_schedule
1122    }
1123
1124    /// Borrow the `RotationHistory` sub-component.
1125    pub fn rotation_history(&self) -> &RotationHistory {
1126        &self.rotation_history
1127    }
1128}
1129
1130impl RotationPolicy {
1131    /// Create a `RotationPolicy` with default sub-components / empty registries.
1132    pub fn new() -> Self {
1133        Self {
1134            policy_id: "policy_1".to_string(),
1135            rotation_interval: 90, // 90 days
1136            rotation_trigger: RotationTrigger::TimeBased,
1137            compliance_requirements: Vec::new(),
1138        }
1139    }
1140}
1141
1142impl RotationSchedule {
1143    /// Create a `RotationSchedule` with default sub-components / empty registries.
1144    pub fn new() -> Self {
1145        Self {
1146            schedule_id: "schedule_1".to_string(),
1147            next_rotation: 0,
1148            rotation_frequency: 90,
1149            affected_keys: Vec::new(),
1150        }
1151    }
1152}
1153
1154impl RotationHistory {
1155    /// Create a `RotationHistory` with default sub-components / empty registries.
1156    pub fn new() -> Self {
1157        Self {
1158            history_id: "history_1".to_string(),
1159            rotation_date: 0,
1160            old_key: String::new(),
1161            new_key: String::new(),
1162            reason: String::new(),
1163        }
1164    }
1165}
1166
1167impl KeyRecovery {
1168    /// Create a `KeyRecovery` with default sub-components / empty registries.
1169    pub fn new() -> Self {
1170        Self {
1171            recovery_methods: HashMap::new(),
1172            recovery_procedures: HashMap::new(),
1173        }
1174    }
1175
1176    /// Register `recovery_method` (keyed by its id field).
1177    pub fn add_recovery_method(&mut self, method: RecoveryMethod) {
1178        self.recovery_methods
1179            .insert(method.method_id.clone(), method);
1180    }
1181
1182    /// Fetch the registered `recovery_method` by id, or `None`.
1183    pub fn get_recovery_method(&self, method_id: &str) -> Option<&RecoveryMethod> {
1184        self.recovery_methods.get(method_id)
1185    }
1186
1187    /// Register `recovery_procedure` (keyed by its id field).
1188    pub fn add_recovery_procedure(&mut self, procedure: RecoveryProcedure) {
1189        self.recovery_procedures
1190            .insert(procedure.procedure_id.clone(), procedure);
1191    }
1192
1193    /// Fetch the registered `recovery_procedure` by id, or `None`.
1194    pub fn get_recovery_procedure(&self, procedure_id: &str) -> Option<&RecoveryProcedure> {
1195        self.recovery_procedures.get(procedure_id)
1196    }
1197}
1198
1199impl DataProtection {
1200    /// Create a `DataProtection` with default sub-components / empty registries.
1201    pub fn new() -> Self {
1202        Self {
1203            protection_policies: HashMap::new(),
1204            breach_detection: BreachDetection::new(),
1205            incident_response: IncidentResponse::new(),
1206        }
1207    }
1208
1209    /// Initialize owned sub-components in dependency order.
1210    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1211        Ok(())
1212    }
1213
1214    /// Register `protection_policy` (keyed by its id field).
1215    pub fn add_protection_policy(&mut self, policy: ProtectionPolicy) {
1216        self.protection_policies
1217            .insert(policy.policy_id.clone(), policy);
1218    }
1219
1220    /// Fetch the registered `protection_policy` by id, or `None`.
1221    pub fn get_protection_policy(&self, policy_id: &str) -> Option<&ProtectionPolicy> {
1222        self.protection_policies.get(policy_id)
1223    }
1224
1225    /// Borrow the `BreachDetection` sub-component.
1226    pub fn breach_detection(&self) -> &BreachDetection {
1227        &self.breach_detection
1228    }
1229
1230    /// Borrow the `IncidentResponse` sub-component.
1231    pub fn incident_response(&self) -> &IncidentResponse {
1232        &self.incident_response
1233    }
1234}
1235
1236impl BreachDetection {
1237    /// Create a `BreachDetection` with default sub-components / empty registries.
1238    pub fn new() -> Self {
1239        Self {
1240            detection_algorithms: HashMap::new(),
1241            alert_systems: HashMap::new(),
1242        }
1243    }
1244
1245    /// Register `detection_algorithm` (keyed by its id field).
1246    pub fn add_detection_algorithm(&mut self, algorithm: DetectionAlgorithm) {
1247        self.detection_algorithms
1248            .insert(algorithm.algorithm_id.clone(), algorithm);
1249    }
1250
1251    /// Fetch the registered `detection_algorithm` by id, or `None`.
1252    pub fn get_detection_algorithm(&self, algorithm_id: &str) -> Option<&DetectionAlgorithm> {
1253        self.detection_algorithms.get(algorithm_id)
1254    }
1255
1256    /// Register `alert_system` (keyed by its id field).
1257    pub fn add_alert_system(&mut self, system: AlertSystem) {
1258        self.alert_systems.insert(system.system_id.clone(), system);
1259    }
1260
1261    /// Fetch the registered `alert_system` by id, or `None`.
1262    pub fn get_alert_system(&self, system_id: &str) -> Option<&AlertSystem> {
1263        self.alert_systems.get(system_id)
1264    }
1265}
1266
1267impl IncidentResponse {
1268    /// Create a `IncidentResponse` with default sub-components / empty registries.
1269    pub fn new() -> Self {
1270        Self {
1271            response_plans: HashMap::new(),
1272            response_team: ResponseTeam::new(),
1273            escalation_procedures: EscalationProcedures::new(),
1274        }
1275    }
1276
1277    /// Register `response_plan` (keyed by its id field).
1278    pub fn add_response_plan(&mut self, plan: ResponsePlan) {
1279        self.response_plans.insert(plan.plan_id.clone(), plan);
1280    }
1281
1282    /// Fetch the registered `response_plan` by id, or `None`.
1283    pub fn get_response_plan(&self, plan_id: &str) -> Option<&ResponsePlan> {
1284        self.response_plans.get(plan_id)
1285    }
1286
1287    /// Borrow the `ResponseTeam` sub-component.
1288    pub fn response_team(&self) -> &ResponseTeam {
1289        &self.response_team
1290    }
1291
1292    /// Borrow the `EscalationProcedures` sub-component.
1293    pub fn escalation_procedures(&self) -> &EscalationProcedures {
1294        &self.escalation_procedures
1295    }
1296}
1297
1298impl ResponseTeam {
1299    /// Create a `ResponseTeam` with default sub-components / empty registries.
1300    pub fn new() -> Self {
1301        Self {
1302            team_id: "team_1".to_string(),
1303            team_name: "Incident Response Team".to_string(),
1304            members: Vec::new(),
1305            roles: HashMap::new(),
1306        }
1307    }
1308}
1309
1310impl EscalationProcedures {
1311    /// Create a `EscalationProcedures` with default sub-components / empty registries.
1312    pub fn new() -> Self {
1313        Self {
1314            escalation_rules: HashMap::new(),
1315            escalation_matrix: EscalationMatrix::new(),
1316        }
1317    }
1318
1319    /// Register `escalation_rule` (keyed by its id field).
1320    pub fn add_escalation_rule(&mut self, rule: EscalationRule) {
1321        self.escalation_rules.insert(rule.rule_id.clone(), rule);
1322    }
1323
1324    /// Fetch the registered `escalation_rule` by id, or `None`.
1325    pub fn get_escalation_rule(&self, rule_id: &str) -> Option<&EscalationRule> {
1326        self.escalation_rules.get(rule_id)
1327    }
1328
1329    /// Borrow the `EscalationMatrix` sub-component.
1330    pub fn escalation_matrix(&self) -> &EscalationMatrix {
1331        &self.escalation_matrix
1332    }
1333}
1334
1335impl EscalationMatrix {
1336    /// Create a `EscalationMatrix` with default sub-components / empty registries.
1337    pub fn new() -> Self {
1338        Self {
1339            matrix_id: "matrix_1".to_string(),
1340            matrix_name: "Escalation Matrix".to_string(),
1341            escalation_levels: Vec::new(),
1342        }
1343    }
1344}
1345
1346impl AnonymizationEngine {
1347    /// Create a `AnonymizationEngine` with default sub-components / empty registries.
1348    pub fn new() -> Self {
1349        Self {
1350            anonymization_methods: HashMap::new(),
1351            privacy_models: HashMap::new(),
1352            risk_assessment: RiskAssessment::new(),
1353        }
1354    }
1355
1356    /// Initialize owned sub-components in dependency order.
1357    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1358        Ok(())
1359    }
1360
1361    /// Register `anonymization_method` (keyed by its id field).
1362    pub fn add_anonymization_method(&mut self, method: AnonymizationMethod) {
1363        self.anonymization_methods
1364            .insert(method.method_id.clone(), method);
1365    }
1366
1367    /// Fetch the registered `anonymization_method` by id, or `None`.
1368    pub fn get_anonymization_method(&self, method_id: &str) -> Option<&AnonymizationMethod> {
1369        self.anonymization_methods.get(method_id)
1370    }
1371
1372    /// Register `privacy_model` (keyed by its id field).
1373    pub fn add_privacy_model(&mut self, model: PrivacyModel) {
1374        self.privacy_models.insert(model.model_id.clone(), model);
1375    }
1376
1377    /// Fetch the registered `privacy_model` by id, or `None`.
1378    pub fn get_privacy_model(&self, model_id: &str) -> Option<&PrivacyModel> {
1379        self.privacy_models.get(model_id)
1380    }
1381
1382    /// Borrow the `RiskAssessment` sub-component.
1383    pub fn risk_assessment(&self) -> &RiskAssessment {
1384        &self.risk_assessment
1385    }
1386}
1387
1388impl RiskAssessment {
1389    /// Create a `RiskAssessment` with default sub-components / empty registries.
1390    pub fn new() -> Self {
1391        Self {
1392            risk_models: HashMap::new(),
1393            risk_metrics: HashMap::new(),
1394        }
1395    }
1396
1397    /// Register `risk_model` (keyed by its id field).
1398    pub fn add_risk_model(&mut self, model: RiskModel) {
1399        self.risk_models.insert(model.model_id.clone(), model);
1400    }
1401
1402    /// Fetch the registered `risk_model` by id, or `None`.
1403    pub fn get_risk_model(&self, model_id: &str) -> Option<&RiskModel> {
1404        self.risk_models.get(model_id)
1405    }
1406
1407    /// Register `risk_metric` (keyed by its id field).
1408    pub fn add_risk_metric(&mut self, metric: RiskMetric) {
1409        self.risk_metrics.insert(metric.metric_id.clone(), metric);
1410    }
1411
1412    /// Fetch the registered `risk_metric` by id, or `None`.
1413    pub fn get_risk_metric(&self, metric_id: &str) -> Option<&RiskMetric> {
1414        self.risk_metrics.get(metric_id)
1415    }
1416
1417    /// Weighted-average risk score over `factors`; 0.0 on empty input or zero total weight.
1418    pub fn assess_risk(&self, factors: &[RiskFactor]) -> f64 {
1419        if factors.is_empty() {
1420            return 0.0;
1421        }
1422        let total_weight: f64 = factors.iter().map(|f| f.factor_weight).sum();
1423        if total_weight == 0.0 {
1424            return 0.0;
1425        }
1426        factors
1427            .iter()
1428            .map(|f| f.factor_weight * f.factor_value)
1429            .sum::<f64>()
1430            / total_weight
1431    }
1432}
1433
1434impl AccessLogging {
1435    /// Create a `AccessLogging` with default sub-components / empty registries.
1436    pub fn new() -> Self {
1437        Self {
1438            log_entries: HashMap::new(),
1439            log_analysis: LogAnalysis::new(),
1440            retention_policy: RetentionPolicy::new(),
1441        }
1442    }
1443
1444    /// Initialize owned sub-components in dependency order.
1445    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1446        Ok(())
1447    }
1448
1449    /// Register `log_entry` (keyed by its id field).
1450    pub fn add_log_entry(&mut self, entry: LogEntry) {
1451        self.log_entries.insert(entry.entry_id.clone(), entry);
1452    }
1453
1454    /// Fetch the registered `log_entry` by id, or `None`.
1455    pub fn get_log_entry(&self, entry_id: &str) -> Option<&LogEntry> {
1456        self.log_entries.get(entry_id)
1457    }
1458
1459    /// Borrow the `LogAnalysis` sub-component.
1460    pub fn log_analysis(&self) -> &LogAnalysis {
1461        &self.log_analysis
1462    }
1463
1464    /// Borrow the `RetentionPolicy` sub-component.
1465    pub fn retention_policy(&self) -> &RetentionPolicy {
1466        &self.retention_policy
1467    }
1468}
1469
1470impl LogAnalysis {
1471    /// Create a `LogAnalysis` with default sub-components / empty registries.
1472    pub fn new() -> Self {
1473        Self {
1474            analysis_methods: HashMap::new(),
1475            anomaly_detection: AnomalyDetection::new(),
1476        }
1477    }
1478
1479    /// Register `analysis_method` (keyed by its id field).
1480    pub fn add_analysis_method(&mut self, method: AnalysisMethod) {
1481        self.analysis_methods
1482            .insert(method.method_id.clone(), method);
1483    }
1484
1485    /// Fetch the registered `analysis_method` by id, or `None`.
1486    pub fn get_analysis_method(&self, method_id: &str) -> Option<&AnalysisMethod> {
1487        self.analysis_methods.get(method_id)
1488    }
1489
1490    /// Borrow the `AnomalyDetection` sub-component.
1491    pub fn anomaly_detection(&self) -> &AnomalyDetection {
1492        &self.anomaly_detection
1493    }
1494}
1495
1496impl AnomalyDetection {
1497    /// Create a `AnomalyDetection` with default sub-components / empty registries.
1498    pub fn new() -> Self {
1499        Self {
1500            detection_algorithms: HashMap::new(),
1501            alert_thresholds: HashMap::new(),
1502        }
1503    }
1504
1505    /// Register `detection_algorithm` (keyed by its id field).
1506    pub fn add_detection_algorithm(&mut self, algorithm: DetectionAlgorithm) {
1507        self.detection_algorithms
1508            .insert(algorithm.algorithm_id.clone(), algorithm);
1509    }
1510
1511    /// Fetch the registered `detection_algorithm` by id, or `None`.
1512    pub fn get_detection_algorithm(&self, algorithm_id: &str) -> Option<&DetectionAlgorithm> {
1513        self.detection_algorithms.get(algorithm_id)
1514    }
1515
1516    /// Set the `alert_threshold`.
1517    pub fn set_alert_threshold(&mut self, metric_name: &str, threshold: f64) {
1518        self.alert_thresholds
1519            .insert(metric_name.to_string(), threshold);
1520    }
1521
1522    /// Fetch the registered `alert_threshold` by id, or `None`.
1523    pub fn get_alert_threshold(&self, metric_name: &str) -> Option<&f64> {
1524        self.alert_thresholds.get(metric_name)
1525    }
1526}
1527
1528impl RetentionPolicy {
1529    /// Create a `RetentionPolicy` with default sub-components / empty registries.
1530    pub fn new() -> Self {
1531        Self {
1532            policy_id: "policy_1".to_string(),
1533            policy_name: "Log Retention Policy".to_string(),
1534            retention_period: 2555, // 7 years
1535            archival_period: 3650,  // 10 years
1536            deletion_method: DeletionMethod::SecureDelete,
1537        }
1538    }
1539}
1540
1541impl ConsentManagement {
1542    /// Create a `ConsentManagement` with default sub-components / empty registries.
1543    pub fn new() -> Self {
1544        Self {
1545            consent_records: HashMap::new(),
1546            consent_policies: HashMap::new(),
1547            consent_workflows: HashMap::new(),
1548        }
1549    }
1550
1551    /// Initialize owned sub-components in dependency order.
1552    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1553        Ok(())
1554    }
1555
1556    /// Register `consent_record` (keyed by its id field).
1557    pub fn add_consent_record(&mut self, record: ConsentRecord) {
1558        self.consent_records
1559            .insert(record.record_id.clone(), record);
1560    }
1561
1562    /// Fetch the registered `consent_record` by id, or `None`.
1563    pub fn get_consent_record(&self, record_id: &str) -> Option<&ConsentRecord> {
1564        self.consent_records.get(record_id)
1565    }
1566
1567    /// Register `consent_policy` (keyed by its id field).
1568    pub fn add_consent_policy(&mut self, policy: ConsentPolicy) {
1569        self.consent_policies
1570            .insert(policy.policy_id.clone(), policy);
1571    }
1572
1573    /// Fetch the registered `consent_policy` by id, or `None`.
1574    pub fn get_consent_policy(&self, policy_id: &str) -> Option<&ConsentPolicy> {
1575        self.consent_policies.get(policy_id)
1576    }
1577
1578    /// Register `consent_workflow` (keyed by its id field).
1579    pub fn add_consent_workflow(&mut self, workflow: ConsentWorkflow) {
1580        self.consent_workflows
1581            .insert(workflow.workflow_id.clone(), workflow);
1582    }
1583
1584    /// Fetch the registered `consent_workflow` by id, or `None`.
1585    pub fn get_consent_workflow(&self, workflow_id: &str) -> Option<&ConsentWorkflow> {
1586        self.consent_workflows.get(workflow_id)
1587    }
1588}
1589
1590impl DataAccessControl {
1591    /// Create a `DataAccessControl` with default sub-components / empty registries.
1592    pub fn new() -> Self {
1593        Self {
1594            access_policies: HashMap::new(),
1595            authentication: AuthenticationSystem::new(),
1596            authorization: AuthorizationSystem::new(),
1597        }
1598    }
1599
1600    /// Initialize owned sub-components in dependency order.
1601    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1602        self.authentication.initialize()?;
1603        self.authorization.initialize()?;
1604        Ok(())
1605    }
1606
1607    /// Register `access_policy` (keyed by its id field).
1608    pub fn add_access_policy(&mut self, policy: AccessPolicy) {
1609        self.access_policies
1610            .insert(policy.policy_id.clone(), policy);
1611    }
1612
1613    /// Fetch the registered `access_policy` by id, or `None`.
1614    pub fn get_access_policy(&self, policy_id: &str) -> Option<&AccessPolicy> {
1615        self.access_policies.get(policy_id)
1616    }
1617
1618    /// Ids of every registered `access_policies`.
1619    pub fn list_access_policies(&self) -> Vec<String> {
1620        self.access_policies.keys().cloned().collect()
1621    }
1622}
1623
1624impl AuthenticationSystem {
1625    /// Create a `AuthenticationSystem` with default sub-components / empty registries.
1626    pub fn new() -> Self {
1627        Self {
1628            authentication_methods: HashMap::new(),
1629            session_management: SessionManagement::new(),
1630            multi_factor: MultiFactorAuthentication::new(),
1631        }
1632    }
1633
1634    /// Initialize owned sub-components in dependency order.
1635    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1636        Ok(())
1637    }
1638
1639    /// Register `authentication_method` (keyed by its id field).
1640    pub fn add_authentication_method(&mut self, method: AuthenticationMethod) {
1641        self.authentication_methods
1642            .insert(method.method_id.clone(), method);
1643    }
1644
1645    /// Fetch the registered `authentication_method` by id, or `None`.
1646    pub fn get_authentication_method(&self, method_id: &str) -> Option<&AuthenticationMethod> {
1647        self.authentication_methods.get(method_id)
1648    }
1649
1650    /// Borrow the `SessionManagement` sub-component.
1651    pub fn session_management(&self) -> &SessionManagement {
1652        &self.session_management
1653    }
1654
1655    /// Borrow the `MultiFactorAuthentication` sub-component.
1656    pub fn multi_factor(&self) -> &MultiFactorAuthentication {
1657        &self.multi_factor
1658    }
1659}
1660
1661impl SessionManagement {
1662    /// Create a `SessionManagement` with default sub-components / empty registries.
1663    pub fn new() -> Self {
1664        Self {
1665            sessions: HashMap::new(),
1666            session_policies: HashMap::new(),
1667        }
1668    }
1669
1670    /// Register `session` (keyed by its id field).
1671    pub fn add_session(&mut self, session: Session) {
1672        self.sessions.insert(session.session_id.clone(), session);
1673    }
1674
1675    /// Fetch the registered `session` by id, or `None`.
1676    pub fn get_session(&self, session_id: &str) -> Option<&Session> {
1677        self.sessions.get(session_id)
1678    }
1679
1680    /// Remove `session` by id, returning it when present.
1681    pub fn remove_session(&mut self, session_id: &str) -> Option<Session> {
1682        self.sessions.remove(session_id)
1683    }
1684
1685    /// Register `session_policy` (keyed by its id field).
1686    pub fn add_session_policy(&mut self, policy: SessionPolicy) {
1687        self.session_policies
1688            .insert(policy.policy_id.clone(), policy);
1689    }
1690
1691    /// Fetch the registered `session_policy` by id, or `None`.
1692    pub fn get_session_policy(&self, policy_id: &str) -> Option<&SessionPolicy> {
1693        self.session_policies.get(policy_id)
1694    }
1695}
1696
1697impl MultiFactorAuthentication {
1698    /// Create a `MultiFactorAuthentication` with default sub-components / empty registries.
1699    pub fn new() -> Self {
1700        Self {
1701            factors: HashMap::new(),
1702            factor_combinations: HashMap::new(),
1703        }
1704    }
1705
1706    /// Register `factor` (keyed by its id field).
1707    pub fn add_factor(&mut self, factor: AuthenticationFactor) {
1708        self.factors.insert(factor.factor_id.clone(), factor);
1709    }
1710
1711    /// Fetch the registered `factor` by id, or `None`.
1712    pub fn get_factor(&self, factor_id: &str) -> Option<&AuthenticationFactor> {
1713        self.factors.get(factor_id)
1714    }
1715
1716    /// Register `factor_combination` (keyed by its id field).
1717    pub fn add_factor_combination(&mut self, combination: FactorCombination) {
1718        self.factor_combinations
1719            .insert(combination.combination_id.clone(), combination);
1720    }
1721
1722    /// Fetch the registered `factor_combination` by id, or `None`.
1723    pub fn get_factor_combination(&self, combination_id: &str) -> Option<&FactorCombination> {
1724        self.factor_combinations.get(combination_id)
1725    }
1726}
1727
1728impl AuthorizationSystem {
1729    /// Create a `AuthorizationSystem` with default sub-components / empty registries.
1730    pub fn new() -> Self {
1731        Self {
1732            authorization_policies: HashMap::new(),
1733            permission_management: PermissionManagement::new(),
1734            role_management: RoleManagement::new(),
1735        }
1736    }
1737
1738    /// Initialize owned sub-components in dependency order.
1739    pub fn initialize(&mut self) -> Result<(), MedicalError> {
1740        Ok(())
1741    }
1742
1743    /// Register `authorization_policy` (keyed by its id field).
1744    pub fn add_authorization_policy(&mut self, policy: AuthorizationPolicy) {
1745        self.authorization_policies
1746            .insert(policy.policy_id.clone(), policy);
1747    }
1748
1749    /// Fetch the registered `authorization_policy` by id, or `None`.
1750    pub fn get_authorization_policy(&self, policy_id: &str) -> Option<&AuthorizationPolicy> {
1751        self.authorization_policies.get(policy_id)
1752    }
1753
1754    /// Borrow the `PermissionManagement` sub-component.
1755    pub fn permission_management(&self) -> &PermissionManagement {
1756        &self.permission_management
1757    }
1758
1759    /// Borrow the `RoleManagement` sub-component.
1760    pub fn role_management(&self) -> &RoleManagement {
1761        &self.role_management
1762    }
1763}
1764
1765impl PermissionManagement {
1766    /// Create a `PermissionManagement` with default sub-components / empty registries.
1767    pub fn new() -> Self {
1768        Self {
1769            permissions: HashMap::new(),
1770            permission_groups: HashMap::new(),
1771        }
1772    }
1773
1774    /// Register `permission` (keyed by its id field).
1775    pub fn add_permission(&mut self, name: &str, permission: Permission) {
1776        self.permissions.insert(name.to_string(), permission);
1777    }
1778
1779    /// Fetch the registered `permission` by id, or `None`.
1780    pub fn get_permission(&self, name: &str) -> Option<&Permission> {
1781        self.permissions.get(name)
1782    }
1783
1784    /// Register `permission_group` (keyed by its id field).
1785    pub fn add_permission_group(&mut self, group: PermissionGroup) {
1786        self.permission_groups.insert(group.group_id.clone(), group);
1787    }
1788
1789    /// Fetch the registered `permission_group` by id, or `None`.
1790    pub fn get_permission_group(&self, group_id: &str) -> Option<&PermissionGroup> {
1791        self.permission_groups.get(group_id)
1792    }
1793}
1794
1795impl RoleManagement {
1796    /// Create a `RoleManagement` with default sub-components / empty registries.
1797    pub fn new() -> Self {
1798        Self {
1799            roles: HashMap::new(),
1800            role_hierarchy: RoleHierarchy::new(),
1801        }
1802    }
1803
1804    /// Register `role` (keyed by its id field).
1805    pub fn add_role(&mut self, role: Role) {
1806        self.roles.insert(role.role_id.clone(), role);
1807    }
1808
1809    /// Fetch the registered `role` by id, or `None`.
1810    pub fn get_role(&self, role_id: &str) -> Option<&Role> {
1811        self.roles.get(role_id)
1812    }
1813
1814    /// Borrow the `RoleHierarchy` sub-component.
1815    pub fn role_hierarchy(&self) -> &RoleHierarchy {
1816        &self.role_hierarchy
1817    }
1818}
1819
1820impl RoleHierarchy {
1821    /// Create a `RoleHierarchy` with default sub-components / empty registries.
1822    pub fn new() -> Self {
1823        Self {
1824            hierarchy_id: "hierarchy_1".to_string(),
1825            parent_roles: Vec::new(),
1826            child_roles: Vec::new(),
1827        }
1828    }
1829}