quantrs2_device/cloud/
cost_management.rs

1//! Cost Management and Optimization Configuration
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::time::Duration;
6
7/// Cost management configuration
8#[derive(Debug, Clone, Serialize, Deserialize)]
9pub struct CostManagementConfig {
10    /// Enable cost optimization
11    pub enable_cost_optimization: bool,
12    /// Cost optimization strategies
13    pub optimization_strategies: Vec<CostOptimizationStrategy>,
14    /// Pricing models
15    pub pricing_models: HashMap<String, PricingModel>,
16    /// Cost prediction and forecasting
17    pub cost_prediction: CostPredictionConfig,
18    /// Budget management
19    pub budget_management: BudgetConfig,
20    /// Cost alerting
21    pub cost_alerting: CostAlertingConfig,
22    /// Financial reporting
23    pub reporting: FinancialReportingConfig,
24    /// Cost allocation
25    pub allocation: CostAllocationConfig,
26}
27
28/// Cost optimization strategies
29#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
30pub enum CostOptimizationStrategy {
31    SpotInstanceOptimization,
32    ReservedInstanceOptimization,
33    RightSizing,
34    SchedulingOptimization,
35    LoadBalancingOptimization,
36    ResourcePooling,
37    AutoShutdown,
38    PriceComparison,
39    ContractNegotiation,
40    CustomStrategy(String),
41}
42
43/// Pricing model
44#[derive(Debug, Clone, Serialize, Deserialize)]
45pub struct PricingModel {
46    pub model_type: String,
47    pub base_rate: f64,
48    pub scaling_factors: HashMap<String, f64>,
49    pub discount_tiers: Vec<f64>,
50    /// Pricing structure
51    pub structure: PricingStructure,
52    /// Contract terms
53    pub contract_terms: ContractTerms,
54    /// Dynamic pricing
55    pub dynamic_pricing: DynamicPricingConfig,
56}
57
58/// Pricing structure
59#[derive(Debug, Clone, Serialize, Deserialize)]
60pub struct PricingStructure {
61    /// Billing model
62    pub billing_model: BillingModel,
63    /// Rate components
64    pub rate_components: Vec<RateComponent>,
65    /// Volume discounts
66    pub volume_discounts: Vec<VolumeDiscount>,
67    /// Time-based pricing
68    pub time_based: TimeBasedPricingConfig,
69}
70
71/// Billing models
72#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
73pub enum BillingModel {
74    PayPerUse,
75    Subscription,
76    Reserved,
77    Spot,
78    Prepaid,
79    Hybrid,
80}
81
82/// Rate component
83#[derive(Debug, Clone, Serialize, Deserialize)]
84pub struct RateComponent {
85    /// Component name
86    pub name: String,
87    /// Rate per unit
88    pub rate: f64,
89    /// Unit type
90    pub unit: String,
91    /// Minimum charge
92    pub minimum_charge: Option<f64>,
93    /// Maximum charge
94    pub maximum_charge: Option<f64>,
95}
96
97/// Volume discount
98#[derive(Debug, Clone, Serialize, Deserialize)]
99pub struct VolumeDiscount {
100    /// Minimum volume
101    pub min_volume: f64,
102    /// Discount percentage
103    pub discount_percent: f64,
104    /// Discount type
105    pub discount_type: DiscountType,
106}
107
108/// Discount types
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
110pub enum DiscountType {
111    Percentage,
112    FixedAmount,
113    TieredDiscount,
114    VolumeDiscount,
115}
116
117/// Time-based pricing configuration
118#[derive(Debug, Clone, Serialize, Deserialize, Default)]
119pub struct TimeBasedPricingConfig {
120    /// Peak hours pricing
121    pub peak_hours: PeakHoursPricing,
122    /// Off-peak hours pricing
123    pub off_peak_hours: OffPeakHoursPricing,
124    /// Weekend pricing
125    pub weekend_pricing: WeekendPricing,
126    /// Holiday pricing
127    pub holiday_pricing: HolidayPricing,
128}
129
130/// Peak hours pricing
131#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct PeakHoursPricing {
133    /// Start time
134    pub start_time: String,
135    /// End time
136    pub end_time: String,
137    /// Rate multiplier
138    pub rate_multiplier: f64,
139    /// Days of week
140    pub days_of_week: Vec<String>,
141}
142
143/// Off-peak hours pricing
144#[derive(Debug, Clone, Serialize, Deserialize)]
145pub struct OffPeakHoursPricing {
146    /// Rate multiplier
147    pub rate_multiplier: f64,
148    /// Minimum discount
149    pub min_discount: f64,
150}
151
152/// Weekend pricing
153#[derive(Debug, Clone, Serialize, Deserialize)]
154pub struct WeekendPricing {
155    /// Weekend rate multiplier
156    pub rate_multiplier: f64,
157    /// Weekend days
158    pub weekend_days: Vec<String>,
159}
160
161/// Holiday pricing
162#[derive(Debug, Clone, Serialize, Deserialize)]
163pub struct HolidayPricing {
164    /// Holiday rate multiplier
165    pub rate_multiplier: f64,
166    /// Holiday calendar
167    pub holiday_calendar: Vec<String>,
168}
169
170/// Contract terms
171#[derive(Debug, Clone, Serialize, Deserialize)]
172pub struct ContractTerms {
173    /// Contract duration
174    pub duration: Duration,
175    /// Commitment level
176    pub commitment_level: CommitmentLevel,
177    /// Early termination fees
178    pub early_termination_fees: EarlyTerminationFees,
179    /// Service level agreements
180    pub sla: ServiceLevelAgreements,
181}
182
183/// Commitment levels
184#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
185pub enum CommitmentLevel {
186    NoCommitment,
187    MonthlyCommitment,
188    YearlyCommitment,
189    MultiYearCommitment,
190    CustomCommitment(Duration),
191}
192
193/// Early termination fees
194#[derive(Debug, Clone, Serialize, Deserialize)]
195pub struct EarlyTerminationFees {
196    /// Fee structure
197    pub fee_structure: FeeStructure,
198    /// Calculation method
199    pub calculation_method: FeeCalculationMethod,
200    /// Waiver conditions
201    pub waiver_conditions: Vec<WaiverCondition>,
202}
203
204/// Fee structures
205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
206pub enum FeeStructure {
207    FixedFee(f64),
208    PercentageOfRemaining(f64),
209    ProRatedFee,
210    NoFee,
211}
212
213/// Fee calculation methods
214#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
215pub enum FeeCalculationMethod {
216    RemainingMonths,
217    UnusedCommitment,
218    TotalContractValue,
219    Custom(String),
220}
221
222/// Waiver conditions
223#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
224pub enum WaiverCondition {
225    ServiceFailure,
226    ForCause,
227    MutualAgreement,
228    Custom(String),
229}
230
231/// Service level agreements
232#[derive(Debug, Clone, Serialize, Deserialize)]
233pub struct ServiceLevelAgreements {
234    /// Uptime SLA
235    pub uptime: f64,
236    /// Performance SLA
237    pub performance: HashMap<String, f64>,
238    /// Support SLA
239    pub support: SupportSLA,
240    /// Penalties
241    pub penalties: SLAPenalties,
242}
243
244/// Support SLA
245#[derive(Debug, Clone, Serialize, Deserialize, Default)]
246pub struct SupportSLA {
247    /// Response time by severity
248    pub response_times: HashMap<String, Duration>,
249    /// Resolution time by severity
250    pub resolution_times: HashMap<String, Duration>,
251    /// Escalation procedures
252    pub escalation: EscalationProcedures,
253}
254
255/// Escalation procedures
256#[derive(Debug, Clone, Serialize, Deserialize, Default)]
257pub struct EscalationProcedures {
258    /// Escalation levels
259    pub levels: Vec<EscalationLevel>,
260    /// Automatic escalation
261    pub automatic: bool,
262    /// Escalation triggers
263    pub triggers: Vec<EscalationTrigger>,
264}
265
266/// Escalation level
267#[derive(Debug, Clone, Serialize, Deserialize)]
268pub struct EscalationLevel {
269    /// Level number
270    pub level: u8,
271    /// Contact information
272    pub contacts: Vec<String>,
273    /// Escalation time
274    pub escalation_time: Duration,
275}
276
277/// Escalation triggers
278#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
279pub enum EscalationTrigger {
280    TimeElapsed,
281    NoResponse,
282    CustomerRequest,
283    SeverityIncrease,
284}
285
286/// SLA penalties
287#[derive(Debug, Clone, Serialize, Deserialize, Default)]
288pub struct SLAPenalties {
289    /// Penalty structure
290    pub structure: PenaltyStructure,
291    /// Credits
292    pub credits: CreditStructure,
293    /// Maximum penalties
294    pub max_penalties: MaxPenalties,
295}
296
297/// Penalty structure
298#[derive(Debug, Clone, Serialize, Deserialize, Default)]
299pub struct PenaltyStructure {
300    /// Uptime penalties
301    pub uptime_penalties: Vec<UptimePenalty>,
302    /// Performance penalties
303    pub performance_penalties: Vec<PerformancePenalty>,
304}
305
306/// Uptime penalty
307#[derive(Debug, Clone, Serialize, Deserialize)]
308pub struct UptimePenalty {
309    /// Minimum uptime
310    pub min_uptime: f64,
311    /// Penalty percentage
312    pub penalty_percent: f64,
313}
314
315/// Performance penalty
316#[derive(Debug, Clone, Serialize, Deserialize)]
317pub struct PerformancePenalty {
318    /// Metric name
319    pub metric: String,
320    /// Threshold
321    pub threshold: f64,
322    /// Penalty percentage
323    pub penalty_percent: f64,
324}
325
326/// Credit structure
327#[derive(Debug, Clone, Serialize, Deserialize, Default)]
328pub struct CreditStructure {
329    /// Service credits
330    pub service_credits: Vec<ServiceCredit>,
331    /// Credit application
332    pub application: CreditApplication,
333}
334
335/// Service credit
336#[derive(Debug, Clone, Serialize, Deserialize)]
337pub struct ServiceCredit {
338    /// Condition
339    pub condition: String,
340    /// Credit amount
341    pub amount: f64,
342    /// Credit type
343    pub credit_type: CreditType,
344}
345
346/// Credit types
347#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
348pub enum CreditType {
349    Percentage,
350    FixedAmount,
351    FreeUsage,
352}
353
354/// Credit application
355#[derive(Debug, Clone, Serialize, Deserialize)]
356pub struct CreditApplication {
357    /// Application method
358    pub method: CreditApplicationMethod,
359    /// Processing time
360    pub processing_time: Duration,
361    /// Verification required
362    pub verification_required: bool,
363}
364
365/// Credit application methods
366#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
367pub enum CreditApplicationMethod {
368    Automatic,
369    Manual,
370    OnRequest,
371}
372
373/// Maximum penalties
374#[derive(Debug, Clone, Serialize, Deserialize)]
375pub struct MaxPenalties {
376    /// Monthly maximum
377    pub monthly_max: Option<f64>,
378    /// Annual maximum
379    pub annual_max: Option<f64>,
380    /// Per incident maximum
381    pub per_incident_max: Option<f64>,
382}
383
384/// Dynamic pricing configuration
385#[derive(Debug, Clone, Serialize, Deserialize)]
386pub struct DynamicPricingConfig {
387    /// Enable dynamic pricing
388    pub enabled: bool,
389    /// Pricing algorithms
390    pub algorithms: Vec<PricingAlgorithm>,
391    /// Update frequency
392    pub update_frequency: Duration,
393    /// Price bounds
394    pub price_bounds: PriceBounds,
395}
396
397/// Pricing algorithms
398#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
399pub enum PricingAlgorithm {
400    SupplyDemand,
401    Competition,
402    CostPlus,
403    ValueBased,
404    MarketBased,
405    Custom(String),
406}
407
408/// Price bounds
409#[derive(Debug, Clone, Serialize, Deserialize)]
410pub struct PriceBounds {
411    /// Minimum price
412    pub min_price: f64,
413    /// Maximum price
414    pub max_price: f64,
415    /// Price change limits
416    pub change_limits: PriceChangeLimits,
417}
418
419/// Price change limits
420#[derive(Debug, Clone, Serialize, Deserialize)]
421pub struct PriceChangeLimits {
422    /// Maximum increase percentage
423    pub max_increase_percent: f64,
424    /// Maximum decrease percentage
425    pub max_decrease_percent: f64,
426    /// Change frequency limit
427    pub change_frequency: Duration,
428}
429
430/// Cost prediction configuration
431#[derive(Debug, Clone, Serialize, Deserialize)]
432pub struct CostPredictionConfig {
433    pub enable_prediction: bool,
434    pub prediction_algorithms: Vec<String>,
435    pub prediction_horizon: u64,
436    /// Prediction models
437    pub models: Vec<CostPredictionModel>,
438    /// Forecasting settings
439    pub forecasting: ForecastingConfig,
440    /// Accuracy monitoring
441    pub accuracy_monitoring: AccuracyMonitoringConfig,
442}
443
444/// Cost prediction models
445#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
446pub enum CostPredictionModel {
447    LinearRegression,
448    ARIMA,
449    LSTM,
450    RandomForest,
451    EnsembleModel,
452    Custom(String),
453}
454
455/// Forecasting configuration
456#[derive(Debug, Clone, Serialize, Deserialize)]
457pub struct ForecastingConfig {
458    /// Forecast horizons
459    pub horizons: Vec<ForecastHorizon>,
460    /// Confidence intervals
461    pub confidence_intervals: Vec<f64>,
462    /// Scenario analysis
463    pub scenario_analysis: ScenarioAnalysisConfig,
464}
465
466/// Forecast horizon
467#[derive(Debug, Clone, Serialize, Deserialize)]
468pub struct ForecastHorizon {
469    /// Horizon name
470    pub name: String,
471    /// Duration
472    pub duration: Duration,
473    /// Update frequency
474    pub update_frequency: Duration,
475}
476
477/// Scenario analysis configuration
478#[derive(Debug, Clone, Serialize, Deserialize, Default)]
479pub struct ScenarioAnalysisConfig {
480    /// Enable scenario analysis
481    pub enabled: bool,
482    /// Scenarios
483    pub scenarios: Vec<CostScenario>,
484    /// Probability weights
485    pub probability_weights: HashMap<String, f64>,
486}
487
488/// Cost scenario
489#[derive(Debug, Clone, Serialize, Deserialize)]
490pub struct CostScenario {
491    /// Scenario name
492    pub name: String,
493    /// Description
494    pub description: String,
495    /// Parameters
496    pub parameters: HashMap<String, f64>,
497    /// Expected impact
498    pub expected_impact: f64,
499}
500
501/// Accuracy monitoring configuration
502#[derive(Debug, Clone, Serialize, Deserialize)]
503pub struct AccuracyMonitoringConfig {
504    /// Enable monitoring
505    pub enabled: bool,
506    /// Accuracy metrics
507    pub metrics: Vec<AccuracyMetric>,
508    /// Threshold alerts
509    pub threshold_alerts: Vec<AccuracyAlert>,
510    /// Model retraining
511    pub retraining: ModelRetrainingConfig,
512}
513
514/// Accuracy metrics
515#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
516pub enum AccuracyMetric {
517    MAPE, // Mean Absolute Percentage Error
518    RMSE, // Root Mean Square Error
519    MAE,  // Mean Absolute Error
520    R2,   // R-squared
521    Custom(String),
522}
523
524/// Accuracy alert
525#[derive(Debug, Clone, Serialize, Deserialize)]
526pub struct AccuracyAlert {
527    /// Metric
528    pub metric: AccuracyMetric,
529    /// Threshold
530    pub threshold: f64,
531    /// Alert action
532    pub action: AlertAction,
533}
534
535/// Alert actions
536#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
537pub enum AlertAction {
538    Notify,
539    RetainModel,
540    SwitchModel,
541    Custom(String),
542}
543
544/// Model retraining configuration
545#[derive(Debug, Clone, Serialize, Deserialize)]
546pub struct ModelRetrainingConfig {
547    /// Auto retraining
548    pub auto_retrain: bool,
549    /// Retraining triggers
550    pub triggers: Vec<RetrainingTrigger>,
551    /// Training frequency
552    pub frequency: Duration,
553}
554
555/// Retraining triggers
556#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
557pub enum RetrainingTrigger {
558    AccuracyDrop,
559    DataDrift,
560    ScheduledRetrain,
561    ManualTrigger,
562}
563
564/// Budget configuration
565#[derive(Debug, Clone, Serialize, Deserialize)]
566pub struct BudgetConfig {
567    pub daily_budget: Option<f64>,
568    pub monthly_budget: Option<f64>,
569    pub auto_scaling_budget: bool,
570    pub budget_alerts: Vec<String>,
571    /// Budget allocation
572    pub allocation: BudgetAllocation,
573    /// Budget tracking
574    pub tracking: BudgetTrackingConfig,
575    /// Budget enforcement
576    pub enforcement: BudgetEnforcementConfig,
577}
578
579/// Budget allocation
580#[derive(Debug, Clone, Serialize, Deserialize)]
581pub struct BudgetAllocation {
582    /// Department allocations
583    pub departments: HashMap<String, f64>,
584    /// Project allocations
585    pub projects: HashMap<String, f64>,
586    /// Provider allocations
587    pub providers: HashMap<String, f64>,
588    /// Reserve allocation
589    pub reserve_percentage: f64,
590}
591
592/// Budget tracking configuration
593#[derive(Debug, Clone, Serialize, Deserialize)]
594pub struct BudgetTrackingConfig {
595    /// Tracking frequency
596    pub frequency: Duration,
597    /// Variance analysis
598    pub variance_analysis: VarianceAnalysisConfig,
599    /// Trend analysis
600    pub trend_analysis: TrendAnalysisConfig,
601}
602
603/// Variance analysis configuration
604#[derive(Debug, Clone, Serialize, Deserialize)]
605pub struct VarianceAnalysisConfig {
606    /// Enable variance analysis
607    pub enabled: bool,
608    /// Variance thresholds
609    pub thresholds: VarianceThresholds,
610    /// Root cause analysis
611    pub root_cause_analysis: bool,
612}
613
614/// Variance thresholds
615#[derive(Debug, Clone, Serialize, Deserialize)]
616pub struct VarianceThresholds {
617    /// Warning threshold
618    pub warning_threshold: f64,
619    /// Critical threshold
620    pub critical_threshold: f64,
621    /// Absolute vs percentage
622    pub is_percentage: bool,
623}
624
625/// Trend analysis configuration
626#[derive(Debug, Clone, Serialize, Deserialize)]
627pub struct TrendAnalysisConfig {
628    /// Enable trend analysis
629    pub enabled: bool,
630    /// Analysis window
631    pub analysis_window: Duration,
632    /// Trend detection methods
633    pub detection_methods: Vec<TrendDetectionMethod>,
634}
635
636/// Trend detection methods
637#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
638pub enum TrendDetectionMethod {
639    MovingAverage,
640    LinearRegression,
641    ExponentialSmoothing,
642    SeasonalDecomposition,
643}
644
645/// Budget enforcement configuration
646#[derive(Debug, Clone, Serialize, Deserialize)]
647pub struct BudgetEnforcementConfig {
648    /// Enforcement policy
649    pub policy: EnforcementPolicy,
650    /// Actions
651    pub actions: Vec<EnforcementAction>,
652    /// Override permissions
653    pub override_permissions: OverridePermissions,
654}
655
656/// Enforcement policies
657#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
658pub enum EnforcementPolicy {
659    SoftLimit,
660    HardLimit,
661    GracePeriod,
662    Escalation,
663}
664
665/// Enforcement actions
666#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
667pub enum EnforcementAction {
668    Alert,
669    Throttle,
670    Block,
671    Approve,
672    RequestApproval,
673}
674
675/// Override permissions
676#[derive(Debug, Clone, Serialize, Deserialize, Default)]
677pub struct OverridePermissions {
678    /// Authorized users
679    pub authorized_users: Vec<String>,
680    /// Approval workflow
681    pub approval_workflow: ApprovalWorkflow,
682    /// Override limits
683    pub override_limits: OverrideLimits,
684}
685
686/// Approval workflow
687#[derive(Debug, Clone, Serialize, Deserialize)]
688pub struct ApprovalWorkflow {
689    /// Required approvers
690    pub required_approvers: usize,
691    /// Approval levels
692    pub levels: Vec<ApprovalLevel>,
693    /// Timeout
694    pub timeout: Duration,
695}
696
697/// Approval level
698#[derive(Debug, Clone, Serialize, Deserialize)]
699pub struct ApprovalLevel {
700    /// Level name
701    pub name: String,
702    /// Approvers
703    pub approvers: Vec<String>,
704    /// Budget limits
705    pub budget_limits: HashMap<String, f64>,
706}
707
708/// Override limits
709#[derive(Debug, Clone, Serialize, Deserialize)]
710pub struct OverrideLimits {
711    /// Maximum override percentage
712    pub max_override_percent: f64,
713    /// Override frequency limits
714    pub frequency_limits: FrequencyLimits,
715    /// Justification required
716    pub justification_required: bool,
717}
718
719/// Frequency limits
720#[derive(Debug, Clone, Serialize, Deserialize)]
721pub struct FrequencyLimits {
722    /// Per day
723    pub per_day: usize,
724    /// Per week
725    pub per_week: usize,
726    /// Per month
727    pub per_month: usize,
728}
729
730/// Cost alerting configuration
731#[derive(Debug, Clone, Serialize, Deserialize)]
732pub struct CostAlertingConfig {
733    pub enable_alerts: bool,
734    pub alert_thresholds: Vec<f64>,
735    pub notification_channels: Vec<String>,
736    /// Alert rules
737    pub rules: Vec<CostAlertRule>,
738    /// Escalation policies
739    pub escalation_policies: Vec<AlertEscalationPolicy>,
740    /// Suppression rules
741    pub suppression_rules: Vec<AlertSuppressionRule>,
742}
743
744/// Cost alert rule
745#[derive(Debug, Clone, Serialize, Deserialize)]
746pub struct CostAlertRule {
747    /// Rule name
748    pub name: String,
749    /// Condition
750    pub condition: AlertCondition,
751    /// Severity
752    pub severity: AlertSeverity,
753    /// Actions
754    pub actions: Vec<AlertAction>,
755}
756
757/// Alert condition
758#[derive(Debug, Clone, Serialize, Deserialize)]
759pub struct AlertCondition {
760    /// Metric
761    pub metric: CostMetric,
762    /// Operator
763    pub operator: ComparisonOperator,
764    /// Threshold
765    pub threshold: f64,
766    /// Time window
767    pub time_window: Duration,
768}
769
770/// Cost metrics
771#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
772pub enum CostMetric {
773    TotalCost,
774    HourlyCost,
775    DailyCost,
776    MonthlyCost,
777    CostPerJob,
778    CostPerQubit,
779    BudgetUtilization,
780    Custom(String),
781}
782
783/// Comparison operators
784#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
785pub enum ComparisonOperator {
786    GreaterThan,
787    LessThan,
788    Equal,
789    GreaterThanOrEqual,
790    LessThanOrEqual,
791    NotEqual,
792}
793
794/// Alert severity
795#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
796pub enum AlertSeverity {
797    Low,
798    Medium,
799    High,
800    Critical,
801}
802
803/// Alert escalation policy
804#[derive(Debug, Clone, Serialize, Deserialize)]
805pub struct AlertEscalationPolicy {
806    /// Policy name
807    pub name: String,
808    /// Escalation levels
809    pub levels: Vec<EscalationStep>,
810    /// Escalation timeouts
811    pub timeouts: HashMap<String, Duration>,
812}
813
814/// Escalation step
815#[derive(Debug, Clone, Serialize, Deserialize)]
816pub struct EscalationStep {
817    /// Step name
818    pub name: String,
819    /// Contacts
820    pub contacts: Vec<String>,
821    /// Actions
822    pub actions: Vec<EscalationAction>,
823    /// Delay before escalation
824    pub delay: Duration,
825}
826
827/// Escalation actions
828#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
829pub enum EscalationAction {
830    Notify,
831    AutoRemediate,
832    ManualIntervention,
833    EmergencyShutdown,
834}
835
836/// Alert suppression rule
837#[derive(Debug, Clone, Serialize, Deserialize)]
838pub struct AlertSuppressionRule {
839    /// Rule name
840    pub name: String,
841    /// Conditions
842    pub conditions: Vec<SuppressionCondition>,
843    /// Duration
844    pub duration: Duration,
845}
846
847/// Suppression condition
848#[derive(Debug, Clone, Serialize, Deserialize)]
849pub struct SuppressionCondition {
850    /// Field
851    pub field: String,
852    /// Operator
853    pub operator: ComparisonOperator,
854    /// Value
855    pub value: String,
856}
857
858/// Financial reporting configuration
859#[derive(Debug, Clone, Serialize, Deserialize)]
860pub struct FinancialReportingConfig {
861    /// Enable reporting
862    pub enabled: bool,
863    /// Report types
864    pub report_types: Vec<ReportType>,
865    /// Report frequency
866    pub frequency: ReportFrequency,
867    /// Report delivery
868    pub delivery: ReportDeliveryConfig,
869}
870
871/// Report types
872#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
873pub enum ReportType {
874    CostSummary,
875    DetailedUsage,
876    BudgetVariance,
877    TrendAnalysis,
878    CostOptimization,
879    CustomReport(String),
880}
881
882/// Report frequency
883#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
884pub enum ReportFrequency {
885    Daily,
886    Weekly,
887    Monthly,
888    Quarterly,
889    OnDemand,
890}
891
892/// Report delivery configuration
893#[derive(Debug, Clone, Serialize, Deserialize)]
894pub struct ReportDeliveryConfig {
895    /// Delivery methods
896    pub methods: Vec<DeliveryMethod>,
897    /// Recipients
898    pub recipients: Vec<String>,
899    /// Format options
900    pub formats: Vec<ReportFormat>,
901}
902
903/// Delivery methods
904#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
905pub enum DeliveryMethod {
906    Email,
907    Dashboard,
908    API,
909    FileSystem,
910    CloudStorage,
911}
912
913/// Report formats
914#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
915pub enum ReportFormat {
916    PDF,
917    CSV,
918    JSON,
919    Excel,
920    HTML,
921}
922
923/// Cost allocation configuration
924#[derive(Debug, Clone, Serialize, Deserialize)]
925pub struct CostAllocationConfig {
926    /// Allocation methods
927    pub methods: Vec<AllocationMethod>,
928    /// Allocation rules
929    pub rules: Vec<AllocationRule>,
930    /// Chargeback configuration
931    pub chargeback: ChargebackConfig,
932}
933
934/// Allocation methods
935#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
936pub enum AllocationMethod {
937    DirectAllocation,
938    ProportionalAllocation,
939    ActivityBasedAllocation,
940    UsageBasedAllocation,
941    CustomAllocation(String),
942}
943
944/// Allocation rule
945#[derive(Debug, Clone, Serialize, Deserialize)]
946pub struct AllocationRule {
947    /// Rule name
948    pub name: String,
949    /// Source
950    pub source: AllocationSource,
951    /// Target
952    pub target: AllocationTarget,
953    /// Method
954    pub method: AllocationMethod,
955    /// Percentage
956    pub percentage: Option<f64>,
957}
958
959/// Allocation source
960#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
961pub enum AllocationSource {
962    SharedResources,
963    Infrastructure,
964    Support,
965    Overhead,
966    Custom(String),
967}
968
969/// Allocation target
970#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
971pub enum AllocationTarget {
972    Department,
973    Project,
974    CostCenter,
975    User,
976    Custom(String),
977}
978
979/// Chargeback configuration
980#[derive(Debug, Clone, Serialize, Deserialize)]
981pub struct ChargebackConfig {
982    /// Enable chargeback
983    pub enabled: bool,
984    /// Chargeback model
985    pub model: ChargebackModel,
986    /// Billing cycle
987    pub billing_cycle: BillingCycle,
988    /// Rate cards
989    pub rate_cards: Vec<RateCard>,
990}
991
992/// Chargeback models
993#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
994pub enum ChargebackModel {
995    FullChargeback,
996    Showback,
997    HybridModel,
998    CustomModel(String),
999}
1000
1001/// Billing cycle
1002#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1003pub enum BillingCycle {
1004    Monthly,
1005    Quarterly,
1006    Annual,
1007    Custom(Duration),
1008}
1009
1010/// Rate card
1011#[derive(Debug, Clone, Serialize, Deserialize)]
1012pub struct RateCard {
1013    /// Service name
1014    pub service: String,
1015    /// Unit rate
1016    pub rate: f64,
1017    /// Unit type
1018    pub unit: String,
1019    /// Effective date
1020    pub effective_date: String,
1021    /// Expiration date
1022    pub expiration_date: Option<String>,
1023}
1024
1025impl Default for CostManagementConfig {
1026    fn default() -> Self {
1027        Self {
1028            enable_cost_optimization: true,
1029            optimization_strategies: vec![
1030                CostOptimizationStrategy::RightSizing,
1031                CostOptimizationStrategy::SchedulingOptimization,
1032            ],
1033            pricing_models: HashMap::new(),
1034            cost_prediction: CostPredictionConfig::default(),
1035            budget_management: BudgetConfig::default(),
1036            cost_alerting: CostAlertingConfig::default(),
1037            reporting: FinancialReportingConfig::default(),
1038            allocation: CostAllocationConfig::default(),
1039        }
1040    }
1041}
1042
1043impl Default for PricingModel {
1044    fn default() -> Self {
1045        Self {
1046            model_type: "pay_per_use".to_string(),
1047            base_rate: 0.1,
1048            scaling_factors: HashMap::new(),
1049            discount_tiers: vec![],
1050            structure: PricingStructure::default(),
1051            contract_terms: ContractTerms::default(),
1052            dynamic_pricing: DynamicPricingConfig::default(),
1053        }
1054    }
1055}
1056
1057impl Default for PricingStructure {
1058    fn default() -> Self {
1059        Self {
1060            billing_model: BillingModel::PayPerUse,
1061            rate_components: vec![],
1062            volume_discounts: vec![],
1063            time_based: TimeBasedPricingConfig::default(),
1064        }
1065    }
1066}
1067
1068impl Default for PeakHoursPricing {
1069    fn default() -> Self {
1070        Self {
1071            start_time: "09:00".to_string(),
1072            end_time: "17:00".to_string(),
1073            rate_multiplier: 1.5,
1074            days_of_week: vec![
1075                "Mon".to_string(),
1076                "Tue".to_string(),
1077                "Wed".to_string(),
1078                "Thu".to_string(),
1079                "Fri".to_string(),
1080            ],
1081        }
1082    }
1083}
1084
1085impl Default for OffPeakHoursPricing {
1086    fn default() -> Self {
1087        Self {
1088            rate_multiplier: 0.8,
1089            min_discount: 0.1,
1090        }
1091    }
1092}
1093
1094impl Default for WeekendPricing {
1095    fn default() -> Self {
1096        Self {
1097            rate_multiplier: 0.7,
1098            weekend_days: vec!["Sat".to_string(), "Sun".to_string()],
1099        }
1100    }
1101}
1102
1103impl Default for HolidayPricing {
1104    fn default() -> Self {
1105        Self {
1106            rate_multiplier: 0.5,
1107            holiday_calendar: vec![],
1108        }
1109    }
1110}
1111
1112impl Default for ContractTerms {
1113    fn default() -> Self {
1114        Self {
1115            duration: Duration::from_secs(86400 * 365), // 1 year
1116            commitment_level: CommitmentLevel::NoCommitment,
1117            early_termination_fees: EarlyTerminationFees::default(),
1118            sla: ServiceLevelAgreements::default(),
1119        }
1120    }
1121}
1122
1123impl Default for EarlyTerminationFees {
1124    fn default() -> Self {
1125        Self {
1126            fee_structure: FeeStructure::NoFee,
1127            calculation_method: FeeCalculationMethod::RemainingMonths,
1128            waiver_conditions: vec![],
1129        }
1130    }
1131}
1132
1133impl Default for ServiceLevelAgreements {
1134    fn default() -> Self {
1135        Self {
1136            uptime: 0.99,
1137            performance: HashMap::new(),
1138            support: SupportSLA::default(),
1139            penalties: SLAPenalties::default(),
1140        }
1141    }
1142}
1143
1144impl Default for CreditApplication {
1145    fn default() -> Self {
1146        Self {
1147            method: CreditApplicationMethod::Manual,
1148            processing_time: Duration::from_secs(86400 * 7), // 1 week
1149            verification_required: true,
1150        }
1151    }
1152}
1153
1154impl Default for MaxPenalties {
1155    fn default() -> Self {
1156        Self {
1157            monthly_max: Some(0.1), // 10% of monthly bill
1158            annual_max: Some(0.05), // 5% of annual bill
1159            per_incident_max: None,
1160        }
1161    }
1162}
1163
1164impl Default for DynamicPricingConfig {
1165    fn default() -> Self {
1166        Self {
1167            enabled: false,
1168            algorithms: vec![],
1169            update_frequency: Duration::from_secs(3600), // 1 hour
1170            price_bounds: PriceBounds::default(),
1171        }
1172    }
1173}
1174
1175impl Default for PriceBounds {
1176    fn default() -> Self {
1177        Self {
1178            min_price: 0.01,
1179            max_price: 10.0,
1180            change_limits: PriceChangeLimits::default(),
1181        }
1182    }
1183}
1184
1185impl Default for PriceChangeLimits {
1186    fn default() -> Self {
1187        Self {
1188            max_increase_percent: 0.1,                   // 10%
1189            max_decrease_percent: 0.1,                   // 10%
1190            change_frequency: Duration::from_secs(3600), // 1 hour
1191        }
1192    }
1193}
1194
1195impl Default for CostPredictionConfig {
1196    fn default() -> Self {
1197        Self {
1198            enable_prediction: true,
1199            prediction_algorithms: vec!["linear_regression".to_string()],
1200            prediction_horizon: 86400 * 30, // 30 days
1201            models: vec![CostPredictionModel::LinearRegression],
1202            forecasting: ForecastingConfig::default(),
1203            accuracy_monitoring: AccuracyMonitoringConfig::default(),
1204        }
1205    }
1206}
1207
1208impl Default for ForecastingConfig {
1209    fn default() -> Self {
1210        Self {
1211            horizons: vec![],
1212            confidence_intervals: vec![0.95],
1213            scenario_analysis: ScenarioAnalysisConfig::default(),
1214        }
1215    }
1216}
1217
1218impl Default for AccuracyMonitoringConfig {
1219    fn default() -> Self {
1220        Self {
1221            enabled: true,
1222            metrics: vec![AccuracyMetric::MAPE],
1223            threshold_alerts: vec![],
1224            retraining: ModelRetrainingConfig::default(),
1225        }
1226    }
1227}
1228
1229impl Default for ModelRetrainingConfig {
1230    fn default() -> Self {
1231        Self {
1232            auto_retrain: true,
1233            triggers: vec![RetrainingTrigger::AccuracyDrop],
1234            frequency: Duration::from_secs(86400 * 7), // weekly
1235        }
1236    }
1237}
1238
1239impl Default for BudgetConfig {
1240    fn default() -> Self {
1241        Self {
1242            daily_budget: None,
1243            monthly_budget: Some(1000.0),
1244            auto_scaling_budget: false,
1245            budget_alerts: vec![],
1246            allocation: BudgetAllocation::default(),
1247            tracking: BudgetTrackingConfig::default(),
1248            enforcement: BudgetEnforcementConfig::default(),
1249        }
1250    }
1251}
1252
1253impl Default for BudgetAllocation {
1254    fn default() -> Self {
1255        Self {
1256            departments: HashMap::new(),
1257            projects: HashMap::new(),
1258            providers: HashMap::new(),
1259            reserve_percentage: 0.1, // 10% reserve
1260        }
1261    }
1262}
1263
1264impl Default for BudgetTrackingConfig {
1265    fn default() -> Self {
1266        Self {
1267            frequency: Duration::from_secs(3600), // hourly
1268            variance_analysis: VarianceAnalysisConfig::default(),
1269            trend_analysis: TrendAnalysisConfig::default(),
1270        }
1271    }
1272}
1273
1274impl Default for VarianceAnalysisConfig {
1275    fn default() -> Self {
1276        Self {
1277            enabled: true,
1278            thresholds: VarianceThresholds::default(),
1279            root_cause_analysis: false,
1280        }
1281    }
1282}
1283
1284impl Default for VarianceThresholds {
1285    fn default() -> Self {
1286        Self {
1287            warning_threshold: 0.1,  // 10%
1288            critical_threshold: 0.2, // 20%
1289            is_percentage: true,
1290        }
1291    }
1292}
1293
1294impl Default for TrendAnalysisConfig {
1295    fn default() -> Self {
1296        Self {
1297            enabled: true,
1298            analysis_window: Duration::from_secs(86400 * 30), // 30 days
1299            detection_methods: vec![TrendDetectionMethod::MovingAverage],
1300        }
1301    }
1302}
1303
1304impl Default for BudgetEnforcementConfig {
1305    fn default() -> Self {
1306        Self {
1307            policy: EnforcementPolicy::SoftLimit,
1308            actions: vec![EnforcementAction::Alert],
1309            override_permissions: OverridePermissions::default(),
1310        }
1311    }
1312}
1313
1314impl Default for ApprovalWorkflow {
1315    fn default() -> Self {
1316        Self {
1317            required_approvers: 1,
1318            levels: vec![],
1319            timeout: Duration::from_secs(86400), // 24 hours
1320        }
1321    }
1322}
1323
1324impl Default for OverrideLimits {
1325    fn default() -> Self {
1326        Self {
1327            max_override_percent: 0.2, // 20%
1328            frequency_limits: FrequencyLimits::default(),
1329            justification_required: true,
1330        }
1331    }
1332}
1333
1334impl Default for FrequencyLimits {
1335    fn default() -> Self {
1336        Self {
1337            per_day: 3,
1338            per_week: 10,
1339            per_month: 20,
1340        }
1341    }
1342}
1343
1344impl Default for CostAlertingConfig {
1345    fn default() -> Self {
1346        Self {
1347            enable_alerts: true,
1348            alert_thresholds: vec![0.8, 0.9, 1.0], // 80%, 90%, 100% of budget
1349            notification_channels: vec!["email".to_string()],
1350            rules: vec![],
1351            escalation_policies: vec![],
1352            suppression_rules: vec![],
1353        }
1354    }
1355}
1356
1357impl Default for FinancialReportingConfig {
1358    fn default() -> Self {
1359        Self {
1360            enabled: true,
1361            report_types: vec![ReportType::CostSummary, ReportType::BudgetVariance],
1362            frequency: ReportFrequency::Monthly,
1363            delivery: ReportDeliveryConfig::default(),
1364        }
1365    }
1366}
1367
1368impl Default for ReportDeliveryConfig {
1369    fn default() -> Self {
1370        Self {
1371            methods: vec![DeliveryMethod::Email],
1372            recipients: vec![],
1373            formats: vec![ReportFormat::PDF],
1374        }
1375    }
1376}
1377
1378impl Default for CostAllocationConfig {
1379    fn default() -> Self {
1380        Self {
1381            methods: vec![AllocationMethod::UsageBasedAllocation],
1382            rules: vec![],
1383            chargeback: ChargebackConfig::default(),
1384        }
1385    }
1386}
1387
1388impl Default for ChargebackConfig {
1389    fn default() -> Self {
1390        Self {
1391            enabled: false,
1392            model: ChargebackModel::Showback,
1393            billing_cycle: BillingCycle::Monthly,
1394            rate_cards: vec![],
1395        }
1396    }
1397}
quantrs2_device/cloud/cost_management.rs

quantrs2_device/cloud/
cost_management.rs
