Skip to main content

basaltic/services/
mod.rs

1//! Generated typed service accessors.
2use crate::Client;
3pub mod audit;
4impl Client {
5    pub fn audit(&self) -> audit::AuditService {
6        audit::AuditService {
7            client: self.clone(),
8        }
9    }
10}
11pub mod billing;
12impl Client {
13    pub fn billing(&self) -> billing::BillingService {
14        billing::BillingService {
15            client: self.clone(),
16        }
17    }
18}
19pub mod catalog;
20impl Client {
21    pub fn catalog(&self) -> catalog::CatalogService {
22        catalog::CatalogService {
23            client: self.clone(),
24        }
25    }
26}
27pub mod certificate;
28impl Client {
29    pub fn certificate(&self) -> certificate::CertificateService {
30        certificate::CertificateService {
31            client: self.clone(),
32        }
33    }
34}
35pub mod compute;
36impl Client {
37    pub fn compute(&self) -> compute::ComputeService {
38        compute::ComputeService {
39            client: self.clone(),
40        }
41    }
42}
43pub mod dns;
44impl Client {
45    pub fn dns(&self) -> dns::DnsService {
46        dns::DnsService {
47            client: self.clone(),
48        }
49    }
50}
51pub mod email;
52impl Client {
53    pub fn email(&self) -> email::EmailService {
54        email::EmailService {
55            client: self.clone(),
56        }
57    }
58}
59pub mod iam;
60impl Client {
61    pub fn iam(&self) -> iam::IamService {
62        iam::IamService {
63            client: self.clone(),
64        }
65    }
66}
67pub mod kms;
68impl Client {
69    pub fn kms(&self) -> kms::KmsService {
70        kms::KmsService {
71            client: self.clone(),
72        }
73    }
74}
75pub mod loadbalancer;
76impl Client {
77    pub fn loadbalancer(&self) -> loadbalancer::LoadbalancerService {
78        loadbalancer::LoadbalancerService {
79            client: self.clone(),
80        }
81    }
82}
83pub mod network;
84impl Client {
85    pub fn network(&self) -> network::NetworkService {
86        network::NetworkService {
87            client: self.clone(),
88        }
89    }
90}
91pub mod notifications;
92impl Client {
93    pub fn notifications(&self) -> notifications::NotificationsService {
94        notifications::NotificationsService {
95            client: self.clone(),
96        }
97    }
98}
99pub mod queue;
100impl Client {
101    pub fn queue(&self) -> queue::QueueService {
102        queue::QueueService {
103            client: self.clone(),
104        }
105    }
106}
107pub mod quota;
108impl Client {
109    pub fn quota(&self) -> quota::QuotaService {
110        quota::QuotaService {
111            client: self.clone(),
112        }
113    }
114}
115pub mod registry;
116impl Client {
117    pub fn registry(&self) -> registry::RegistryService {
118        registry::RegistryService {
119            client: self.clone(),
120        }
121    }
122}
123pub mod secrets;
124impl Client {
125    pub fn secrets(&self) -> secrets::SecretsService {
126        secrets::SecretsService {
127            client: self.clone(),
128        }
129    }
130}
131pub mod storage;
132impl Client {
133    pub fn storage(&self) -> storage::StorageService {
134        storage::StorageService {
135            client: self.clone(),
136        }
137    }
138}
139pub mod telemetry;
140impl Client {
141    pub fn telemetry(&self) -> telemetry::TelemetryService {
142        telemetry::TelemetryService {
143            client: self.clone(),
144        }
145    }
146}
147pub mod workspace;
148impl Client {
149    pub fn workspace(&self) -> workspace::WorkspaceService {
150        workspace::WorkspaceService {
151            client: self.clone(),
152        }
153    }
154}