1use std::{error, fmt};
2
3#[derive(Debug, Clone)]
4pub struct ResponseContent<T> {
5 pub status: reqwest::StatusCode,
6 pub content: String,
7 pub entity: Option<T>,
8}
9
10#[derive(Debug)]
11pub enum Error<T> {
12 Reqwest(reqwest::Error),
13 Serde(serde_json::Error),
14 Io(std::io::Error),
15 ResponseError(ResponseContent<T>),
16}
17
18impl<T> fmt::Display for Error<T> {
19 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20 let (module, e) = match self {
21 Error::Reqwest(e) => ("reqwest", e.to_string()),
22 Error::Serde(e) => ("serde", e.to_string()),
23 Error::Io(e) => ("IO", e.to_string()),
24 Error::ResponseError(e) => ("response", format!("status code {}", e.status)),
25 };
26 write!(f, "error in {}: {}", module, e)
27 }
28}
29
30impl<T: fmt::Debug> error::Error for Error<T> {
31 fn source(&self) -> Option<&(dyn error::Error + 'static)> {
32 Some(match self {
33 Error::Reqwest(e) => e,
34 Error::Serde(e) => e,
35 Error::Io(e) => e,
36 Error::ResponseError(_) => return None,
37 })
38 }
39}
40
41impl<T> From<reqwest::Error> for Error<T> {
42 fn from(e: reqwest::Error) -> Self {
43 Error::Reqwest(e)
44 }
45}
46
47impl<T> From<serde_json::Error> for Error<T> {
48 fn from(e: serde_json::Error) -> Self {
49 Error::Serde(e)
50 }
51}
52
53impl<T> From<std::io::Error> for Error<T> {
54 fn from(e: std::io::Error) -> Self {
55 Error::Io(e)
56 }
57}
58
59pub fn urlencode<T: AsRef<str>>(s: T) -> String {
60 ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
61}
62
63pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> {
64 if let serde_json::Value::Object(object) = value {
65 let mut params = vec![];
66
67 for (key, value) in object {
68 match value {
69 serde_json::Value::Object(_) => params.append(&mut parse_deep_object(
70 &format!("{}[{}]", prefix, key),
71 value,
72 )),
73 serde_json::Value::Array(array) => {
74 for (i, value) in array.iter().enumerate() {
75 params.append(&mut parse_deep_object(
76 &format!("{}[{}][{}]", prefix, key, i),
77 value,
78 ));
79 }
80 }
81 serde_json::Value::String(s) => {
82 params.push((format!("{}[{}]", prefix, key), s.clone()))
83 }
84 _ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
85 }
86 }
87
88 return params;
89 }
90
91 unimplemented!("Only objects are supported with style=deepObject")
92}
93
94#[allow(dead_code)]
97enum ContentType {
98 Json,
99 Text,
100 Unsupported(String),
101}
102
103impl From<&str> for ContentType {
104 fn from(content_type: &str) -> Self {
105 if content_type.starts_with("application") && content_type.contains("json") {
106 return Self::Json;
107 } else if content_type.starts_with("text/plain") {
108 return Self::Text;
109 } else {
110 return Self::Unsupported(content_type.to_string());
111 }
112 }
113}
114
115pub mod access_policies_api;
116pub mod account_billing_v_next_api;
117pub mod accounts_api;
118pub mod accounts_billing_api;
119pub mod accounts_key_management_api;
120pub mod auth_requests_api;
121pub mod ciphers_api;
122pub mod collections_api;
123pub mod config_api;
124pub mod counts_api;
125pub mod devices_api;
126pub mod emergency_access_api;
127pub mod events_api;
128pub mod folders_api;
129pub mod groups_api;
130pub mod hibp_api;
131pub mod import_ciphers_api;
132pub mod info_api;
133pub mod installations_api;
134pub mod invoices_api;
135pub mod licenses_api;
136pub mod misc_api;
137pub mod notifications_api;
138pub mod organization_auth_requests_api;
139pub mod organization_billing_api;
140pub mod organization_billing_v_next_api;
141pub mod organization_connections_api;
142pub mod organization_domain_api;
143pub mod organization_export_api;
144pub mod organization_integration_api;
145pub mod organization_integration_configuration_api;
146pub mod organization_reports_api;
147pub mod organization_sponsorships_api;
148pub mod organization_users_api;
149pub mod organizations_api;
150pub mod phishing_domains_api;
151pub mod plans_api;
152pub mod policies_api;
153pub mod projects_api;
154pub mod provider_billing_api;
155pub mod provider_billing_v_next_api;
156pub mod provider_clients_api;
157pub mod provider_organizations_api;
158pub mod provider_users_api;
159pub mod providers_api;
160pub mod push_api;
161pub mod reports_api;
162pub mod request_sm_access_api;
163pub mod secrets_api;
164pub mod secrets_manager_events_api;
165pub mod secrets_manager_porting_api;
166pub mod security_task_api;
167pub mod self_hosted_account_billing_api;
168pub mod self_hosted_organization_licenses_api;
169pub mod self_hosted_organization_sponsorships_api;
170pub mod sends_api;
171pub mod service_accounts_api;
172pub mod settings_api;
173pub mod slack_integration_api;
174pub mod stripe_api;
175pub mod sync_api;
176pub mod tax_api;
177pub mod trash_api;
178pub mod two_factor_api;
179pub mod users_api;
180pub mod web_authn_api;
181
182pub mod configuration;
183
184use std::sync::Arc;
185
186#[allow(clippy::large_enum_variant, private_interfaces)]
187pub enum ApiClient {
188 Real(ApiClientReal),
189 #[cfg(feature = "mockall")]
190 Mock(ApiClientMock),
191}
192
193struct ApiClientReal {
194 access_policies_api: access_policies_api::AccessPoliciesApiClient,
195 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient,
196 accounts_api: accounts_api::AccountsApiClient,
197 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient,
198 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient,
199 auth_requests_api: auth_requests_api::AuthRequestsApiClient,
200 ciphers_api: ciphers_api::CiphersApiClient,
201 collections_api: collections_api::CollectionsApiClient,
202 config_api: config_api::ConfigApiClient,
203 counts_api: counts_api::CountsApiClient,
204 devices_api: devices_api::DevicesApiClient,
205 emergency_access_api: emergency_access_api::EmergencyAccessApiClient,
206 events_api: events_api::EventsApiClient,
207 folders_api: folders_api::FoldersApiClient,
208 groups_api: groups_api::GroupsApiClient,
209 hibp_api: hibp_api::HibpApiClient,
210 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient,
211 info_api: info_api::InfoApiClient,
212 installations_api: installations_api::InstallationsApiClient,
213 invoices_api: invoices_api::InvoicesApiClient,
214 licenses_api: licenses_api::LicensesApiClient,
215 misc_api: misc_api::MiscApiClient,
216 notifications_api: notifications_api::NotificationsApiClient,
217 organization_auth_requests_api:
218 organization_auth_requests_api::OrganizationAuthRequestsApiClient,
219 organization_billing_api: organization_billing_api::OrganizationBillingApiClient,
220 organization_billing_v_next_api:
221 organization_billing_v_next_api::OrganizationBillingVNextApiClient,
222 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient,
223 organization_domain_api: organization_domain_api::OrganizationDomainApiClient,
224 organization_export_api: organization_export_api::OrganizationExportApiClient,
225 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient,
226 organization_integration_configuration_api:
227 organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient,
228 organization_reports_api: organization_reports_api::OrganizationReportsApiClient,
229 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient,
230 organization_users_api: organization_users_api::OrganizationUsersApiClient,
231 organizations_api: organizations_api::OrganizationsApiClient,
232 phishing_domains_api: phishing_domains_api::PhishingDomainsApiClient,
233 plans_api: plans_api::PlansApiClient,
234 policies_api: policies_api::PoliciesApiClient,
235 projects_api: projects_api::ProjectsApiClient,
236 provider_billing_api: provider_billing_api::ProviderBillingApiClient,
237 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient,
238 provider_clients_api: provider_clients_api::ProviderClientsApiClient,
239 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient,
240 provider_users_api: provider_users_api::ProviderUsersApiClient,
241 providers_api: providers_api::ProvidersApiClient,
242 push_api: push_api::PushApiClient,
243 reports_api: reports_api::ReportsApiClient,
244 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient,
245 secrets_api: secrets_api::SecretsApiClient,
246 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient,
247 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient,
248 security_task_api: security_task_api::SecurityTaskApiClient,
249 self_hosted_account_billing_api:
250 self_hosted_account_billing_api::SelfHostedAccountBillingApiClient,
251 self_hosted_organization_licenses_api:
252 self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient,
253 self_hosted_organization_sponsorships_api:
254 self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient,
255 sends_api: sends_api::SendsApiClient,
256 service_accounts_api: service_accounts_api::ServiceAccountsApiClient,
257 settings_api: settings_api::SettingsApiClient,
258 slack_integration_api: slack_integration_api::SlackIntegrationApiClient,
259 stripe_api: stripe_api::StripeApiClient,
260 sync_api: sync_api::SyncApiClient,
261 tax_api: tax_api::TaxApiClient,
262 trash_api: trash_api::TrashApiClient,
263 two_factor_api: two_factor_api::TwoFactorApiClient,
264 users_api: users_api::UsersApiClient,
265 web_authn_api: web_authn_api::WebAuthnApiClient,
266}
267
268#[cfg(feature = "mockall")]
269pub struct ApiClientMock {
270 pub access_policies_api: access_policies_api::MockAccessPoliciesApi,
271 pub account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi,
272 pub accounts_api: accounts_api::MockAccountsApi,
273 pub accounts_billing_api: accounts_billing_api::MockAccountsBillingApi,
274 pub accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi,
275 pub auth_requests_api: auth_requests_api::MockAuthRequestsApi,
276 pub ciphers_api: ciphers_api::MockCiphersApi,
277 pub collections_api: collections_api::MockCollectionsApi,
278 pub config_api: config_api::MockConfigApi,
279 pub counts_api: counts_api::MockCountsApi,
280 pub devices_api: devices_api::MockDevicesApi,
281 pub emergency_access_api: emergency_access_api::MockEmergencyAccessApi,
282 pub events_api: events_api::MockEventsApi,
283 pub folders_api: folders_api::MockFoldersApi,
284 pub groups_api: groups_api::MockGroupsApi,
285 pub hibp_api: hibp_api::MockHibpApi,
286 pub import_ciphers_api: import_ciphers_api::MockImportCiphersApi,
287 pub info_api: info_api::MockInfoApi,
288 pub installations_api: installations_api::MockInstallationsApi,
289 pub invoices_api: invoices_api::MockInvoicesApi,
290 pub licenses_api: licenses_api::MockLicensesApi,
291 pub misc_api: misc_api::MockMiscApi,
292 pub notifications_api: notifications_api::MockNotificationsApi,
293 pub organization_auth_requests_api:
294 organization_auth_requests_api::MockOrganizationAuthRequestsApi,
295 pub organization_billing_api: organization_billing_api::MockOrganizationBillingApi,
296 pub organization_billing_v_next_api:
297 organization_billing_v_next_api::MockOrganizationBillingVNextApi,
298 pub organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi,
299 pub organization_domain_api: organization_domain_api::MockOrganizationDomainApi,
300 pub organization_export_api: organization_export_api::MockOrganizationExportApi,
301 pub organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi,
302 pub organization_integration_configuration_api:
303 organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi,
304 pub organization_reports_api: organization_reports_api::MockOrganizationReportsApi,
305 pub organization_sponsorships_api:
306 organization_sponsorships_api::MockOrganizationSponsorshipsApi,
307 pub organization_users_api: organization_users_api::MockOrganizationUsersApi,
308 pub organizations_api: organizations_api::MockOrganizationsApi,
309 pub phishing_domains_api: phishing_domains_api::MockPhishingDomainsApi,
310 pub plans_api: plans_api::MockPlansApi,
311 pub policies_api: policies_api::MockPoliciesApi,
312 pub projects_api: projects_api::MockProjectsApi,
313 pub provider_billing_api: provider_billing_api::MockProviderBillingApi,
314 pub provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi,
315 pub provider_clients_api: provider_clients_api::MockProviderClientsApi,
316 pub provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi,
317 pub provider_users_api: provider_users_api::MockProviderUsersApi,
318 pub providers_api: providers_api::MockProvidersApi,
319 pub push_api: push_api::MockPushApi,
320 pub reports_api: reports_api::MockReportsApi,
321 pub request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi,
322 pub secrets_api: secrets_api::MockSecretsApi,
323 pub secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi,
324 pub secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi,
325 pub security_task_api: security_task_api::MockSecurityTaskApi,
326 pub self_hosted_account_billing_api:
327 self_hosted_account_billing_api::MockSelfHostedAccountBillingApi,
328 pub self_hosted_organization_licenses_api:
329 self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi,
330 pub self_hosted_organization_sponsorships_api:
331 self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi,
332 pub sends_api: sends_api::MockSendsApi,
333 pub service_accounts_api: service_accounts_api::MockServiceAccountsApi,
334 pub settings_api: settings_api::MockSettingsApi,
335 pub slack_integration_api: slack_integration_api::MockSlackIntegrationApi,
336 pub stripe_api: stripe_api::MockStripeApi,
337 pub sync_api: sync_api::MockSyncApi,
338 pub tax_api: tax_api::MockTaxApi,
339 pub trash_api: trash_api::MockTrashApi,
340 pub two_factor_api: two_factor_api::MockTwoFactorApi,
341 pub users_api: users_api::MockUsersApi,
342 pub web_authn_api: web_authn_api::MockWebAuthnApi,
343}
344
345impl ApiClient {
346 pub fn new(configuration: &Arc<configuration::Configuration>) -> Self {
347 Self::Real(ApiClientReal {
348 access_policies_api: access_policies_api::AccessPoliciesApiClient::new(configuration.clone()),
349 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient::new(configuration.clone()),
350 accounts_api: accounts_api::AccountsApiClient::new(configuration.clone()),
351 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient::new(configuration.clone()),
352 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient::new(configuration.clone()),
353 auth_requests_api: auth_requests_api::AuthRequestsApiClient::new(configuration.clone()),
354 ciphers_api: ciphers_api::CiphersApiClient::new(configuration.clone()),
355 collections_api: collections_api::CollectionsApiClient::new(configuration.clone()),
356 config_api: config_api::ConfigApiClient::new(configuration.clone()),
357 counts_api: counts_api::CountsApiClient::new(configuration.clone()),
358 devices_api: devices_api::DevicesApiClient::new(configuration.clone()),
359 emergency_access_api: emergency_access_api::EmergencyAccessApiClient::new(configuration.clone()),
360 events_api: events_api::EventsApiClient::new(configuration.clone()),
361 folders_api: folders_api::FoldersApiClient::new(configuration.clone()),
362 groups_api: groups_api::GroupsApiClient::new(configuration.clone()),
363 hibp_api: hibp_api::HibpApiClient::new(configuration.clone()),
364 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient::new(configuration.clone()),
365 info_api: info_api::InfoApiClient::new(configuration.clone()),
366 installations_api: installations_api::InstallationsApiClient::new(configuration.clone()),
367 invoices_api: invoices_api::InvoicesApiClient::new(configuration.clone()),
368 licenses_api: licenses_api::LicensesApiClient::new(configuration.clone()),
369 misc_api: misc_api::MiscApiClient::new(configuration.clone()),
370 notifications_api: notifications_api::NotificationsApiClient::new(configuration.clone()),
371 organization_auth_requests_api: organization_auth_requests_api::OrganizationAuthRequestsApiClient::new(configuration.clone()),
372 organization_billing_api: organization_billing_api::OrganizationBillingApiClient::new(configuration.clone()),
373 organization_billing_v_next_api: organization_billing_v_next_api::OrganizationBillingVNextApiClient::new(configuration.clone()),
374 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient::new(configuration.clone()),
375 organization_domain_api: organization_domain_api::OrganizationDomainApiClient::new(configuration.clone()),
376 organization_export_api: organization_export_api::OrganizationExportApiClient::new(configuration.clone()),
377 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient::new(configuration.clone()),
378 organization_integration_configuration_api: organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient::new(configuration.clone()),
379 organization_reports_api: organization_reports_api::OrganizationReportsApiClient::new(configuration.clone()),
380 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient::new(configuration.clone()),
381 organization_users_api: organization_users_api::OrganizationUsersApiClient::new(configuration.clone()),
382 organizations_api: organizations_api::OrganizationsApiClient::new(configuration.clone()),
383 phishing_domains_api: phishing_domains_api::PhishingDomainsApiClient::new(configuration.clone()),
384 plans_api: plans_api::PlansApiClient::new(configuration.clone()),
385 policies_api: policies_api::PoliciesApiClient::new(configuration.clone()),
386 projects_api: projects_api::ProjectsApiClient::new(configuration.clone()),
387 provider_billing_api: provider_billing_api::ProviderBillingApiClient::new(configuration.clone()),
388 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient::new(configuration.clone()),
389 provider_clients_api: provider_clients_api::ProviderClientsApiClient::new(configuration.clone()),
390 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient::new(configuration.clone()),
391 provider_users_api: provider_users_api::ProviderUsersApiClient::new(configuration.clone()),
392 providers_api: providers_api::ProvidersApiClient::new(configuration.clone()),
393 push_api: push_api::PushApiClient::new(configuration.clone()),
394 reports_api: reports_api::ReportsApiClient::new(configuration.clone()),
395 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient::new(configuration.clone()),
396 secrets_api: secrets_api::SecretsApiClient::new(configuration.clone()),
397 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient::new(configuration.clone()),
398 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient::new(configuration.clone()),
399 security_task_api: security_task_api::SecurityTaskApiClient::new(configuration.clone()),
400 self_hosted_account_billing_api: self_hosted_account_billing_api::SelfHostedAccountBillingApiClient::new(configuration.clone()),
401 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient::new(configuration.clone()),
402 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient::new(configuration.clone()),
403 sends_api: sends_api::SendsApiClient::new(configuration.clone()),
404 service_accounts_api: service_accounts_api::ServiceAccountsApiClient::new(configuration.clone()),
405 settings_api: settings_api::SettingsApiClient::new(configuration.clone()),
406 slack_integration_api: slack_integration_api::SlackIntegrationApiClient::new(configuration.clone()),
407 stripe_api: stripe_api::StripeApiClient::new(configuration.clone()),
408 sync_api: sync_api::SyncApiClient::new(configuration.clone()),
409 tax_api: tax_api::TaxApiClient::new(configuration.clone()),
410 trash_api: trash_api::TrashApiClient::new(configuration.clone()),
411 two_factor_api: two_factor_api::TwoFactorApiClient::new(configuration.clone()),
412 users_api: users_api::UsersApiClient::new(configuration.clone()),
413 web_authn_api: web_authn_api::WebAuthnApiClient::new(configuration.clone()),
414 })
415 }
416
417 #[cfg(feature = "mockall")]
418 pub fn new_mocked(func: impl FnOnce(&mut ApiClientMock)) -> Self {
419 let mut mock = ApiClientMock {
420 access_policies_api: access_policies_api::MockAccessPoliciesApi::new(),
421 account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi::new(),
422 accounts_api: accounts_api::MockAccountsApi::new(),
423 accounts_billing_api: accounts_billing_api::MockAccountsBillingApi::new(),
424 accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi::new(),
425 auth_requests_api: auth_requests_api::MockAuthRequestsApi::new(),
426 ciphers_api: ciphers_api::MockCiphersApi::new(),
427 collections_api: collections_api::MockCollectionsApi::new(),
428 config_api: config_api::MockConfigApi::new(),
429 counts_api: counts_api::MockCountsApi::new(),
430 devices_api: devices_api::MockDevicesApi::new(),
431 emergency_access_api: emergency_access_api::MockEmergencyAccessApi::new(),
432 events_api: events_api::MockEventsApi::new(),
433 folders_api: folders_api::MockFoldersApi::new(),
434 groups_api: groups_api::MockGroupsApi::new(),
435 hibp_api: hibp_api::MockHibpApi::new(),
436 import_ciphers_api: import_ciphers_api::MockImportCiphersApi::new(),
437 info_api: info_api::MockInfoApi::new(),
438 installations_api: installations_api::MockInstallationsApi::new(),
439 invoices_api: invoices_api::MockInvoicesApi::new(),
440 licenses_api: licenses_api::MockLicensesApi::new(),
441 misc_api: misc_api::MockMiscApi::new(),
442 notifications_api: notifications_api::MockNotificationsApi::new(),
443 organization_auth_requests_api: organization_auth_requests_api::MockOrganizationAuthRequestsApi::new(),
444 organization_billing_api: organization_billing_api::MockOrganizationBillingApi::new(),
445 organization_billing_v_next_api: organization_billing_v_next_api::MockOrganizationBillingVNextApi::new(),
446 organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi::new(),
447 organization_domain_api: organization_domain_api::MockOrganizationDomainApi::new(),
448 organization_export_api: organization_export_api::MockOrganizationExportApi::new(),
449 organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi::new(),
450 organization_integration_configuration_api: organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi::new(),
451 organization_reports_api: organization_reports_api::MockOrganizationReportsApi::new(),
452 organization_sponsorships_api: organization_sponsorships_api::MockOrganizationSponsorshipsApi::new(),
453 organization_users_api: organization_users_api::MockOrganizationUsersApi::new(),
454 organizations_api: organizations_api::MockOrganizationsApi::new(),
455 phishing_domains_api: phishing_domains_api::MockPhishingDomainsApi::new(),
456 plans_api: plans_api::MockPlansApi::new(),
457 policies_api: policies_api::MockPoliciesApi::new(),
458 projects_api: projects_api::MockProjectsApi::new(),
459 provider_billing_api: provider_billing_api::MockProviderBillingApi::new(),
460 provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi::new(),
461 provider_clients_api: provider_clients_api::MockProviderClientsApi::new(),
462 provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi::new(),
463 provider_users_api: provider_users_api::MockProviderUsersApi::new(),
464 providers_api: providers_api::MockProvidersApi::new(),
465 push_api: push_api::MockPushApi::new(),
466 reports_api: reports_api::MockReportsApi::new(),
467 request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi::new(),
468 secrets_api: secrets_api::MockSecretsApi::new(),
469 secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi::new(),
470 secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi::new(),
471 security_task_api: security_task_api::MockSecurityTaskApi::new(),
472 self_hosted_account_billing_api: self_hosted_account_billing_api::MockSelfHostedAccountBillingApi::new(),
473 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi::new(),
474 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi::new(),
475 sends_api: sends_api::MockSendsApi::new(),
476 service_accounts_api: service_accounts_api::MockServiceAccountsApi::new(),
477 settings_api: settings_api::MockSettingsApi::new(),
478 slack_integration_api: slack_integration_api::MockSlackIntegrationApi::new(),
479 stripe_api: stripe_api::MockStripeApi::new(),
480 sync_api: sync_api::MockSyncApi::new(),
481 tax_api: tax_api::MockTaxApi::new(),
482 trash_api: trash_api::MockTrashApi::new(),
483 two_factor_api: two_factor_api::MockTwoFactorApi::new(),
484 users_api: users_api::MockUsersApi::new(),
485 web_authn_api: web_authn_api::MockWebAuthnApi::new(),
486 };
487 func(&mut mock);
488 Self::Mock(mock)
489 }
490}
491
492impl ApiClient {
493 pub fn access_policies_api(&self) -> &dyn access_policies_api::AccessPoliciesApi {
494 match self {
495 ApiClient::Real(real) => &real.access_policies_api,
496 #[cfg(feature = "mockall")]
497 ApiClient::Mock(mock) => &mock.access_policies_api,
498 }
499 }
500 pub fn account_billing_v_next_api(
501 &self,
502 ) -> &dyn account_billing_v_next_api::AccountBillingVNextApi {
503 match self {
504 ApiClient::Real(real) => &real.account_billing_v_next_api,
505 #[cfg(feature = "mockall")]
506 ApiClient::Mock(mock) => &mock.account_billing_v_next_api,
507 }
508 }
509 pub fn accounts_api(&self) -> &dyn accounts_api::AccountsApi {
510 match self {
511 ApiClient::Real(real) => &real.accounts_api,
512 #[cfg(feature = "mockall")]
513 ApiClient::Mock(mock) => &mock.accounts_api,
514 }
515 }
516 pub fn accounts_billing_api(&self) -> &dyn accounts_billing_api::AccountsBillingApi {
517 match self {
518 ApiClient::Real(real) => &real.accounts_billing_api,
519 #[cfg(feature = "mockall")]
520 ApiClient::Mock(mock) => &mock.accounts_billing_api,
521 }
522 }
523 pub fn accounts_key_management_api(
524 &self,
525 ) -> &dyn accounts_key_management_api::AccountsKeyManagementApi {
526 match self {
527 ApiClient::Real(real) => &real.accounts_key_management_api,
528 #[cfg(feature = "mockall")]
529 ApiClient::Mock(mock) => &mock.accounts_key_management_api,
530 }
531 }
532 pub fn auth_requests_api(&self) -> &dyn auth_requests_api::AuthRequestsApi {
533 match self {
534 ApiClient::Real(real) => &real.auth_requests_api,
535 #[cfg(feature = "mockall")]
536 ApiClient::Mock(mock) => &mock.auth_requests_api,
537 }
538 }
539 pub fn ciphers_api(&self) -> &dyn ciphers_api::CiphersApi {
540 match self {
541 ApiClient::Real(real) => &real.ciphers_api,
542 #[cfg(feature = "mockall")]
543 ApiClient::Mock(mock) => &mock.ciphers_api,
544 }
545 }
546 pub fn collections_api(&self) -> &dyn collections_api::CollectionsApi {
547 match self {
548 ApiClient::Real(real) => &real.collections_api,
549 #[cfg(feature = "mockall")]
550 ApiClient::Mock(mock) => &mock.collections_api,
551 }
552 }
553 pub fn config_api(&self) -> &dyn config_api::ConfigApi {
554 match self {
555 ApiClient::Real(real) => &real.config_api,
556 #[cfg(feature = "mockall")]
557 ApiClient::Mock(mock) => &mock.config_api,
558 }
559 }
560 pub fn counts_api(&self) -> &dyn counts_api::CountsApi {
561 match self {
562 ApiClient::Real(real) => &real.counts_api,
563 #[cfg(feature = "mockall")]
564 ApiClient::Mock(mock) => &mock.counts_api,
565 }
566 }
567 pub fn devices_api(&self) -> &dyn devices_api::DevicesApi {
568 match self {
569 ApiClient::Real(real) => &real.devices_api,
570 #[cfg(feature = "mockall")]
571 ApiClient::Mock(mock) => &mock.devices_api,
572 }
573 }
574 pub fn emergency_access_api(&self) -> &dyn emergency_access_api::EmergencyAccessApi {
575 match self {
576 ApiClient::Real(real) => &real.emergency_access_api,
577 #[cfg(feature = "mockall")]
578 ApiClient::Mock(mock) => &mock.emergency_access_api,
579 }
580 }
581 pub fn events_api(&self) -> &dyn events_api::EventsApi {
582 match self {
583 ApiClient::Real(real) => &real.events_api,
584 #[cfg(feature = "mockall")]
585 ApiClient::Mock(mock) => &mock.events_api,
586 }
587 }
588 pub fn folders_api(&self) -> &dyn folders_api::FoldersApi {
589 match self {
590 ApiClient::Real(real) => &real.folders_api,
591 #[cfg(feature = "mockall")]
592 ApiClient::Mock(mock) => &mock.folders_api,
593 }
594 }
595 pub fn groups_api(&self) -> &dyn groups_api::GroupsApi {
596 match self {
597 ApiClient::Real(real) => &real.groups_api,
598 #[cfg(feature = "mockall")]
599 ApiClient::Mock(mock) => &mock.groups_api,
600 }
601 }
602 pub fn hibp_api(&self) -> &dyn hibp_api::HibpApi {
603 match self {
604 ApiClient::Real(real) => &real.hibp_api,
605 #[cfg(feature = "mockall")]
606 ApiClient::Mock(mock) => &mock.hibp_api,
607 }
608 }
609 pub fn import_ciphers_api(&self) -> &dyn import_ciphers_api::ImportCiphersApi {
610 match self {
611 ApiClient::Real(real) => &real.import_ciphers_api,
612 #[cfg(feature = "mockall")]
613 ApiClient::Mock(mock) => &mock.import_ciphers_api,
614 }
615 }
616 pub fn info_api(&self) -> &dyn info_api::InfoApi {
617 match self {
618 ApiClient::Real(real) => &real.info_api,
619 #[cfg(feature = "mockall")]
620 ApiClient::Mock(mock) => &mock.info_api,
621 }
622 }
623 pub fn installations_api(&self) -> &dyn installations_api::InstallationsApi {
624 match self {
625 ApiClient::Real(real) => &real.installations_api,
626 #[cfg(feature = "mockall")]
627 ApiClient::Mock(mock) => &mock.installations_api,
628 }
629 }
630 pub fn invoices_api(&self) -> &dyn invoices_api::InvoicesApi {
631 match self {
632 ApiClient::Real(real) => &real.invoices_api,
633 #[cfg(feature = "mockall")]
634 ApiClient::Mock(mock) => &mock.invoices_api,
635 }
636 }
637 pub fn licenses_api(&self) -> &dyn licenses_api::LicensesApi {
638 match self {
639 ApiClient::Real(real) => &real.licenses_api,
640 #[cfg(feature = "mockall")]
641 ApiClient::Mock(mock) => &mock.licenses_api,
642 }
643 }
644 pub fn misc_api(&self) -> &dyn misc_api::MiscApi {
645 match self {
646 ApiClient::Real(real) => &real.misc_api,
647 #[cfg(feature = "mockall")]
648 ApiClient::Mock(mock) => &mock.misc_api,
649 }
650 }
651 pub fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi {
652 match self {
653 ApiClient::Real(real) => &real.notifications_api,
654 #[cfg(feature = "mockall")]
655 ApiClient::Mock(mock) => &mock.notifications_api,
656 }
657 }
658 pub fn organization_auth_requests_api(
659 &self,
660 ) -> &dyn organization_auth_requests_api::OrganizationAuthRequestsApi {
661 match self {
662 ApiClient::Real(real) => &real.organization_auth_requests_api,
663 #[cfg(feature = "mockall")]
664 ApiClient::Mock(mock) => &mock.organization_auth_requests_api,
665 }
666 }
667 pub fn organization_billing_api(
668 &self,
669 ) -> &dyn organization_billing_api::OrganizationBillingApi {
670 match self {
671 ApiClient::Real(real) => &real.organization_billing_api,
672 #[cfg(feature = "mockall")]
673 ApiClient::Mock(mock) => &mock.organization_billing_api,
674 }
675 }
676 pub fn organization_billing_v_next_api(
677 &self,
678 ) -> &dyn organization_billing_v_next_api::OrganizationBillingVNextApi {
679 match self {
680 ApiClient::Real(real) => &real.organization_billing_v_next_api,
681 #[cfg(feature = "mockall")]
682 ApiClient::Mock(mock) => &mock.organization_billing_v_next_api,
683 }
684 }
685 pub fn organization_connections_api(
686 &self,
687 ) -> &dyn organization_connections_api::OrganizationConnectionsApi {
688 match self {
689 ApiClient::Real(real) => &real.organization_connections_api,
690 #[cfg(feature = "mockall")]
691 ApiClient::Mock(mock) => &mock.organization_connections_api,
692 }
693 }
694 pub fn organization_domain_api(&self) -> &dyn organization_domain_api::OrganizationDomainApi {
695 match self {
696 ApiClient::Real(real) => &real.organization_domain_api,
697 #[cfg(feature = "mockall")]
698 ApiClient::Mock(mock) => &mock.organization_domain_api,
699 }
700 }
701 pub fn organization_export_api(&self) -> &dyn organization_export_api::OrganizationExportApi {
702 match self {
703 ApiClient::Real(real) => &real.organization_export_api,
704 #[cfg(feature = "mockall")]
705 ApiClient::Mock(mock) => &mock.organization_export_api,
706 }
707 }
708 pub fn organization_integration_api(
709 &self,
710 ) -> &dyn organization_integration_api::OrganizationIntegrationApi {
711 match self {
712 ApiClient::Real(real) => &real.organization_integration_api,
713 #[cfg(feature = "mockall")]
714 ApiClient::Mock(mock) => &mock.organization_integration_api,
715 }
716 }
717 pub fn organization_integration_configuration_api(
718 &self,
719 ) -> &dyn organization_integration_configuration_api::OrganizationIntegrationConfigurationApi
720 {
721 match self {
722 ApiClient::Real(real) => &real.organization_integration_configuration_api,
723 #[cfg(feature = "mockall")]
724 ApiClient::Mock(mock) => &mock.organization_integration_configuration_api,
725 }
726 }
727 pub fn organization_reports_api(
728 &self,
729 ) -> &dyn organization_reports_api::OrganizationReportsApi {
730 match self {
731 ApiClient::Real(real) => &real.organization_reports_api,
732 #[cfg(feature = "mockall")]
733 ApiClient::Mock(mock) => &mock.organization_reports_api,
734 }
735 }
736 pub fn organization_sponsorships_api(
737 &self,
738 ) -> &dyn organization_sponsorships_api::OrganizationSponsorshipsApi {
739 match self {
740 ApiClient::Real(real) => &real.organization_sponsorships_api,
741 #[cfg(feature = "mockall")]
742 ApiClient::Mock(mock) => &mock.organization_sponsorships_api,
743 }
744 }
745 pub fn organization_users_api(&self) -> &dyn organization_users_api::OrganizationUsersApi {
746 match self {
747 ApiClient::Real(real) => &real.organization_users_api,
748 #[cfg(feature = "mockall")]
749 ApiClient::Mock(mock) => &mock.organization_users_api,
750 }
751 }
752 pub fn organizations_api(&self) -> &dyn organizations_api::OrganizationsApi {
753 match self {
754 ApiClient::Real(real) => &real.organizations_api,
755 #[cfg(feature = "mockall")]
756 ApiClient::Mock(mock) => &mock.organizations_api,
757 }
758 }
759 pub fn phishing_domains_api(&self) -> &dyn phishing_domains_api::PhishingDomainsApi {
760 match self {
761 ApiClient::Real(real) => &real.phishing_domains_api,
762 #[cfg(feature = "mockall")]
763 ApiClient::Mock(mock) => &mock.phishing_domains_api,
764 }
765 }
766 pub fn plans_api(&self) -> &dyn plans_api::PlansApi {
767 match self {
768 ApiClient::Real(real) => &real.plans_api,
769 #[cfg(feature = "mockall")]
770 ApiClient::Mock(mock) => &mock.plans_api,
771 }
772 }
773 pub fn policies_api(&self) -> &dyn policies_api::PoliciesApi {
774 match self {
775 ApiClient::Real(real) => &real.policies_api,
776 #[cfg(feature = "mockall")]
777 ApiClient::Mock(mock) => &mock.policies_api,
778 }
779 }
780 pub fn projects_api(&self) -> &dyn projects_api::ProjectsApi {
781 match self {
782 ApiClient::Real(real) => &real.projects_api,
783 #[cfg(feature = "mockall")]
784 ApiClient::Mock(mock) => &mock.projects_api,
785 }
786 }
787 pub fn provider_billing_api(&self) -> &dyn provider_billing_api::ProviderBillingApi {
788 match self {
789 ApiClient::Real(real) => &real.provider_billing_api,
790 #[cfg(feature = "mockall")]
791 ApiClient::Mock(mock) => &mock.provider_billing_api,
792 }
793 }
794 pub fn provider_billing_v_next_api(
795 &self,
796 ) -> &dyn provider_billing_v_next_api::ProviderBillingVNextApi {
797 match self {
798 ApiClient::Real(real) => &real.provider_billing_v_next_api,
799 #[cfg(feature = "mockall")]
800 ApiClient::Mock(mock) => &mock.provider_billing_v_next_api,
801 }
802 }
803 pub fn provider_clients_api(&self) -> &dyn provider_clients_api::ProviderClientsApi {
804 match self {
805 ApiClient::Real(real) => &real.provider_clients_api,
806 #[cfg(feature = "mockall")]
807 ApiClient::Mock(mock) => &mock.provider_clients_api,
808 }
809 }
810 pub fn provider_organizations_api(
811 &self,
812 ) -> &dyn provider_organizations_api::ProviderOrganizationsApi {
813 match self {
814 ApiClient::Real(real) => &real.provider_organizations_api,
815 #[cfg(feature = "mockall")]
816 ApiClient::Mock(mock) => &mock.provider_organizations_api,
817 }
818 }
819 pub fn provider_users_api(&self) -> &dyn provider_users_api::ProviderUsersApi {
820 match self {
821 ApiClient::Real(real) => &real.provider_users_api,
822 #[cfg(feature = "mockall")]
823 ApiClient::Mock(mock) => &mock.provider_users_api,
824 }
825 }
826 pub fn providers_api(&self) -> &dyn providers_api::ProvidersApi {
827 match self {
828 ApiClient::Real(real) => &real.providers_api,
829 #[cfg(feature = "mockall")]
830 ApiClient::Mock(mock) => &mock.providers_api,
831 }
832 }
833 pub fn push_api(&self) -> &dyn push_api::PushApi {
834 match self {
835 ApiClient::Real(real) => &real.push_api,
836 #[cfg(feature = "mockall")]
837 ApiClient::Mock(mock) => &mock.push_api,
838 }
839 }
840 pub fn reports_api(&self) -> &dyn reports_api::ReportsApi {
841 match self {
842 ApiClient::Real(real) => &real.reports_api,
843 #[cfg(feature = "mockall")]
844 ApiClient::Mock(mock) => &mock.reports_api,
845 }
846 }
847 pub fn request_sm_access_api(&self) -> &dyn request_sm_access_api::RequestSmAccessApi {
848 match self {
849 ApiClient::Real(real) => &real.request_sm_access_api,
850 #[cfg(feature = "mockall")]
851 ApiClient::Mock(mock) => &mock.request_sm_access_api,
852 }
853 }
854 pub fn secrets_api(&self) -> &dyn secrets_api::SecretsApi {
855 match self {
856 ApiClient::Real(real) => &real.secrets_api,
857 #[cfg(feature = "mockall")]
858 ApiClient::Mock(mock) => &mock.secrets_api,
859 }
860 }
861 pub fn secrets_manager_events_api(
862 &self,
863 ) -> &dyn secrets_manager_events_api::SecretsManagerEventsApi {
864 match self {
865 ApiClient::Real(real) => &real.secrets_manager_events_api,
866 #[cfg(feature = "mockall")]
867 ApiClient::Mock(mock) => &mock.secrets_manager_events_api,
868 }
869 }
870 pub fn secrets_manager_porting_api(
871 &self,
872 ) -> &dyn secrets_manager_porting_api::SecretsManagerPortingApi {
873 match self {
874 ApiClient::Real(real) => &real.secrets_manager_porting_api,
875 #[cfg(feature = "mockall")]
876 ApiClient::Mock(mock) => &mock.secrets_manager_porting_api,
877 }
878 }
879 pub fn security_task_api(&self) -> &dyn security_task_api::SecurityTaskApi {
880 match self {
881 ApiClient::Real(real) => &real.security_task_api,
882 #[cfg(feature = "mockall")]
883 ApiClient::Mock(mock) => &mock.security_task_api,
884 }
885 }
886 pub fn self_hosted_account_billing_api(
887 &self,
888 ) -> &dyn self_hosted_account_billing_api::SelfHostedAccountBillingApi {
889 match self {
890 ApiClient::Real(real) => &real.self_hosted_account_billing_api,
891 #[cfg(feature = "mockall")]
892 ApiClient::Mock(mock) => &mock.self_hosted_account_billing_api,
893 }
894 }
895 pub fn self_hosted_organization_licenses_api(
896 &self,
897 ) -> &dyn self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApi {
898 match self {
899 ApiClient::Real(real) => &real.self_hosted_organization_licenses_api,
900 #[cfg(feature = "mockall")]
901 ApiClient::Mock(mock) => &mock.self_hosted_organization_licenses_api,
902 }
903 }
904 pub fn self_hosted_organization_sponsorships_api(
905 &self,
906 ) -> &dyn self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApi {
907 match self {
908 ApiClient::Real(real) => &real.self_hosted_organization_sponsorships_api,
909 #[cfg(feature = "mockall")]
910 ApiClient::Mock(mock) => &mock.self_hosted_organization_sponsorships_api,
911 }
912 }
913 pub fn sends_api(&self) -> &dyn sends_api::SendsApi {
914 match self {
915 ApiClient::Real(real) => &real.sends_api,
916 #[cfg(feature = "mockall")]
917 ApiClient::Mock(mock) => &mock.sends_api,
918 }
919 }
920 pub fn service_accounts_api(&self) -> &dyn service_accounts_api::ServiceAccountsApi {
921 match self {
922 ApiClient::Real(real) => &real.service_accounts_api,
923 #[cfg(feature = "mockall")]
924 ApiClient::Mock(mock) => &mock.service_accounts_api,
925 }
926 }
927 pub fn settings_api(&self) -> &dyn settings_api::SettingsApi {
928 match self {
929 ApiClient::Real(real) => &real.settings_api,
930 #[cfg(feature = "mockall")]
931 ApiClient::Mock(mock) => &mock.settings_api,
932 }
933 }
934 pub fn slack_integration_api(&self) -> &dyn slack_integration_api::SlackIntegrationApi {
935 match self {
936 ApiClient::Real(real) => &real.slack_integration_api,
937 #[cfg(feature = "mockall")]
938 ApiClient::Mock(mock) => &mock.slack_integration_api,
939 }
940 }
941 pub fn stripe_api(&self) -> &dyn stripe_api::StripeApi {
942 match self {
943 ApiClient::Real(real) => &real.stripe_api,
944 #[cfg(feature = "mockall")]
945 ApiClient::Mock(mock) => &mock.stripe_api,
946 }
947 }
948 pub fn sync_api(&self) -> &dyn sync_api::SyncApi {
949 match self {
950 ApiClient::Real(real) => &real.sync_api,
951 #[cfg(feature = "mockall")]
952 ApiClient::Mock(mock) => &mock.sync_api,
953 }
954 }
955 pub fn tax_api(&self) -> &dyn tax_api::TaxApi {
956 match self {
957 ApiClient::Real(real) => &real.tax_api,
958 #[cfg(feature = "mockall")]
959 ApiClient::Mock(mock) => &mock.tax_api,
960 }
961 }
962 pub fn trash_api(&self) -> &dyn trash_api::TrashApi {
963 match self {
964 ApiClient::Real(real) => &real.trash_api,
965 #[cfg(feature = "mockall")]
966 ApiClient::Mock(mock) => &mock.trash_api,
967 }
968 }
969 pub fn two_factor_api(&self) -> &dyn two_factor_api::TwoFactorApi {
970 match self {
971 ApiClient::Real(real) => &real.two_factor_api,
972 #[cfg(feature = "mockall")]
973 ApiClient::Mock(mock) => &mock.two_factor_api,
974 }
975 }
976 pub fn users_api(&self) -> &dyn users_api::UsersApi {
977 match self {
978 ApiClient::Real(real) => &real.users_api,
979 #[cfg(feature = "mockall")]
980 ApiClient::Mock(mock) => &mock.users_api,
981 }
982 }
983 pub fn web_authn_api(&self) -> &dyn web_authn_api::WebAuthnApi {
984 match self {
985 ApiClient::Real(real) => &real.web_authn_api,
986 #[cfg(feature = "mockall")]
987 ApiClient::Mock(mock) => &mock.web_authn_api,
988 }
989 }
990}