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 teams_integration_api;
178pub mod trash_api;
179pub mod two_factor_api;
180pub mod users_api;
181pub mod web_authn_api;
182
183pub mod configuration;
184
185use std::sync::Arc;
186
187#[allow(clippy::large_enum_variant, private_interfaces)]
188pub enum ApiClient {
189 Real(ApiClientReal),
190 #[cfg(feature = "mockall")]
191 Mock(ApiClientMock),
192}
193
194struct ApiClientReal {
195 access_policies_api: access_policies_api::AccessPoliciesApiClient,
196 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient,
197 accounts_api: accounts_api::AccountsApiClient,
198 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient,
199 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient,
200 auth_requests_api: auth_requests_api::AuthRequestsApiClient,
201 ciphers_api: ciphers_api::CiphersApiClient,
202 collections_api: collections_api::CollectionsApiClient,
203 config_api: config_api::ConfigApiClient,
204 counts_api: counts_api::CountsApiClient,
205 devices_api: devices_api::DevicesApiClient,
206 emergency_access_api: emergency_access_api::EmergencyAccessApiClient,
207 events_api: events_api::EventsApiClient,
208 folders_api: folders_api::FoldersApiClient,
209 groups_api: groups_api::GroupsApiClient,
210 hibp_api: hibp_api::HibpApiClient,
211 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient,
212 info_api: info_api::InfoApiClient,
213 installations_api: installations_api::InstallationsApiClient,
214 invoices_api: invoices_api::InvoicesApiClient,
215 licenses_api: licenses_api::LicensesApiClient,
216 misc_api: misc_api::MiscApiClient,
217 notifications_api: notifications_api::NotificationsApiClient,
218 organization_auth_requests_api:
219 organization_auth_requests_api::OrganizationAuthRequestsApiClient,
220 organization_billing_api: organization_billing_api::OrganizationBillingApiClient,
221 organization_billing_v_next_api:
222 organization_billing_v_next_api::OrganizationBillingVNextApiClient,
223 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient,
224 organization_domain_api: organization_domain_api::OrganizationDomainApiClient,
225 organization_export_api: organization_export_api::OrganizationExportApiClient,
226 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient,
227 organization_integration_configuration_api:
228 organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient,
229 organization_reports_api: organization_reports_api::OrganizationReportsApiClient,
230 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient,
231 organization_users_api: organization_users_api::OrganizationUsersApiClient,
232 organizations_api: organizations_api::OrganizationsApiClient,
233 phishing_domains_api: phishing_domains_api::PhishingDomainsApiClient,
234 plans_api: plans_api::PlansApiClient,
235 policies_api: policies_api::PoliciesApiClient,
236 projects_api: projects_api::ProjectsApiClient,
237 provider_billing_api: provider_billing_api::ProviderBillingApiClient,
238 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient,
239 provider_clients_api: provider_clients_api::ProviderClientsApiClient,
240 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient,
241 provider_users_api: provider_users_api::ProviderUsersApiClient,
242 providers_api: providers_api::ProvidersApiClient,
243 push_api: push_api::PushApiClient,
244 reports_api: reports_api::ReportsApiClient,
245 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient,
246 secrets_api: secrets_api::SecretsApiClient,
247 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient,
248 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient,
249 security_task_api: security_task_api::SecurityTaskApiClient,
250 self_hosted_account_billing_api:
251 self_hosted_account_billing_api::SelfHostedAccountBillingApiClient,
252 self_hosted_organization_licenses_api:
253 self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient,
254 self_hosted_organization_sponsorships_api:
255 self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient,
256 sends_api: sends_api::SendsApiClient,
257 service_accounts_api: service_accounts_api::ServiceAccountsApiClient,
258 settings_api: settings_api::SettingsApiClient,
259 slack_integration_api: slack_integration_api::SlackIntegrationApiClient,
260 stripe_api: stripe_api::StripeApiClient,
261 sync_api: sync_api::SyncApiClient,
262 tax_api: tax_api::TaxApiClient,
263 teams_integration_api: teams_integration_api::TeamsIntegrationApiClient,
264 trash_api: trash_api::TrashApiClient,
265 two_factor_api: two_factor_api::TwoFactorApiClient,
266 users_api: users_api::UsersApiClient,
267 web_authn_api: web_authn_api::WebAuthnApiClient,
268}
269
270#[cfg(feature = "mockall")]
271pub struct ApiClientMock {
272 pub access_policies_api: access_policies_api::MockAccessPoliciesApi,
273 pub account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi,
274 pub accounts_api: accounts_api::MockAccountsApi,
275 pub accounts_billing_api: accounts_billing_api::MockAccountsBillingApi,
276 pub accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi,
277 pub auth_requests_api: auth_requests_api::MockAuthRequestsApi,
278 pub ciphers_api: ciphers_api::MockCiphersApi,
279 pub collections_api: collections_api::MockCollectionsApi,
280 pub config_api: config_api::MockConfigApi,
281 pub counts_api: counts_api::MockCountsApi,
282 pub devices_api: devices_api::MockDevicesApi,
283 pub emergency_access_api: emergency_access_api::MockEmergencyAccessApi,
284 pub events_api: events_api::MockEventsApi,
285 pub folders_api: folders_api::MockFoldersApi,
286 pub groups_api: groups_api::MockGroupsApi,
287 pub hibp_api: hibp_api::MockHibpApi,
288 pub import_ciphers_api: import_ciphers_api::MockImportCiphersApi,
289 pub info_api: info_api::MockInfoApi,
290 pub installations_api: installations_api::MockInstallationsApi,
291 pub invoices_api: invoices_api::MockInvoicesApi,
292 pub licenses_api: licenses_api::MockLicensesApi,
293 pub misc_api: misc_api::MockMiscApi,
294 pub notifications_api: notifications_api::MockNotificationsApi,
295 pub organization_auth_requests_api:
296 organization_auth_requests_api::MockOrganizationAuthRequestsApi,
297 pub organization_billing_api: organization_billing_api::MockOrganizationBillingApi,
298 pub organization_billing_v_next_api:
299 organization_billing_v_next_api::MockOrganizationBillingVNextApi,
300 pub organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi,
301 pub organization_domain_api: organization_domain_api::MockOrganizationDomainApi,
302 pub organization_export_api: organization_export_api::MockOrganizationExportApi,
303 pub organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi,
304 pub organization_integration_configuration_api:
305 organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi,
306 pub organization_reports_api: organization_reports_api::MockOrganizationReportsApi,
307 pub organization_sponsorships_api:
308 organization_sponsorships_api::MockOrganizationSponsorshipsApi,
309 pub organization_users_api: organization_users_api::MockOrganizationUsersApi,
310 pub organizations_api: organizations_api::MockOrganizationsApi,
311 pub phishing_domains_api: phishing_domains_api::MockPhishingDomainsApi,
312 pub plans_api: plans_api::MockPlansApi,
313 pub policies_api: policies_api::MockPoliciesApi,
314 pub projects_api: projects_api::MockProjectsApi,
315 pub provider_billing_api: provider_billing_api::MockProviderBillingApi,
316 pub provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi,
317 pub provider_clients_api: provider_clients_api::MockProviderClientsApi,
318 pub provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi,
319 pub provider_users_api: provider_users_api::MockProviderUsersApi,
320 pub providers_api: providers_api::MockProvidersApi,
321 pub push_api: push_api::MockPushApi,
322 pub reports_api: reports_api::MockReportsApi,
323 pub request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi,
324 pub secrets_api: secrets_api::MockSecretsApi,
325 pub secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi,
326 pub secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi,
327 pub security_task_api: security_task_api::MockSecurityTaskApi,
328 pub self_hosted_account_billing_api:
329 self_hosted_account_billing_api::MockSelfHostedAccountBillingApi,
330 pub self_hosted_organization_licenses_api:
331 self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi,
332 pub self_hosted_organization_sponsorships_api:
333 self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi,
334 pub sends_api: sends_api::MockSendsApi,
335 pub service_accounts_api: service_accounts_api::MockServiceAccountsApi,
336 pub settings_api: settings_api::MockSettingsApi,
337 pub slack_integration_api: slack_integration_api::MockSlackIntegrationApi,
338 pub stripe_api: stripe_api::MockStripeApi,
339 pub sync_api: sync_api::MockSyncApi,
340 pub tax_api: tax_api::MockTaxApi,
341 pub teams_integration_api: teams_integration_api::MockTeamsIntegrationApi,
342 pub trash_api: trash_api::MockTrashApi,
343 pub two_factor_api: two_factor_api::MockTwoFactorApi,
344 pub users_api: users_api::MockUsersApi,
345 pub web_authn_api: web_authn_api::MockWebAuthnApi,
346}
347
348impl ApiClient {
349 pub fn new(configuration: &Arc<configuration::Configuration>) -> Self {
350 Self::Real(ApiClientReal {
351 access_policies_api: access_policies_api::AccessPoliciesApiClient::new(configuration.clone()),
352 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient::new(configuration.clone()),
353 accounts_api: accounts_api::AccountsApiClient::new(configuration.clone()),
354 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient::new(configuration.clone()),
355 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient::new(configuration.clone()),
356 auth_requests_api: auth_requests_api::AuthRequestsApiClient::new(configuration.clone()),
357 ciphers_api: ciphers_api::CiphersApiClient::new(configuration.clone()),
358 collections_api: collections_api::CollectionsApiClient::new(configuration.clone()),
359 config_api: config_api::ConfigApiClient::new(configuration.clone()),
360 counts_api: counts_api::CountsApiClient::new(configuration.clone()),
361 devices_api: devices_api::DevicesApiClient::new(configuration.clone()),
362 emergency_access_api: emergency_access_api::EmergencyAccessApiClient::new(configuration.clone()),
363 events_api: events_api::EventsApiClient::new(configuration.clone()),
364 folders_api: folders_api::FoldersApiClient::new(configuration.clone()),
365 groups_api: groups_api::GroupsApiClient::new(configuration.clone()),
366 hibp_api: hibp_api::HibpApiClient::new(configuration.clone()),
367 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient::new(configuration.clone()),
368 info_api: info_api::InfoApiClient::new(configuration.clone()),
369 installations_api: installations_api::InstallationsApiClient::new(configuration.clone()),
370 invoices_api: invoices_api::InvoicesApiClient::new(configuration.clone()),
371 licenses_api: licenses_api::LicensesApiClient::new(configuration.clone()),
372 misc_api: misc_api::MiscApiClient::new(configuration.clone()),
373 notifications_api: notifications_api::NotificationsApiClient::new(configuration.clone()),
374 organization_auth_requests_api: organization_auth_requests_api::OrganizationAuthRequestsApiClient::new(configuration.clone()),
375 organization_billing_api: organization_billing_api::OrganizationBillingApiClient::new(configuration.clone()),
376 organization_billing_v_next_api: organization_billing_v_next_api::OrganizationBillingVNextApiClient::new(configuration.clone()),
377 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient::new(configuration.clone()),
378 organization_domain_api: organization_domain_api::OrganizationDomainApiClient::new(configuration.clone()),
379 organization_export_api: organization_export_api::OrganizationExportApiClient::new(configuration.clone()),
380 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient::new(configuration.clone()),
381 organization_integration_configuration_api: organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient::new(configuration.clone()),
382 organization_reports_api: organization_reports_api::OrganizationReportsApiClient::new(configuration.clone()),
383 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient::new(configuration.clone()),
384 organization_users_api: organization_users_api::OrganizationUsersApiClient::new(configuration.clone()),
385 organizations_api: organizations_api::OrganizationsApiClient::new(configuration.clone()),
386 phishing_domains_api: phishing_domains_api::PhishingDomainsApiClient::new(configuration.clone()),
387 plans_api: plans_api::PlansApiClient::new(configuration.clone()),
388 policies_api: policies_api::PoliciesApiClient::new(configuration.clone()),
389 projects_api: projects_api::ProjectsApiClient::new(configuration.clone()),
390 provider_billing_api: provider_billing_api::ProviderBillingApiClient::new(configuration.clone()),
391 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient::new(configuration.clone()),
392 provider_clients_api: provider_clients_api::ProviderClientsApiClient::new(configuration.clone()),
393 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient::new(configuration.clone()),
394 provider_users_api: provider_users_api::ProviderUsersApiClient::new(configuration.clone()),
395 providers_api: providers_api::ProvidersApiClient::new(configuration.clone()),
396 push_api: push_api::PushApiClient::new(configuration.clone()),
397 reports_api: reports_api::ReportsApiClient::new(configuration.clone()),
398 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient::new(configuration.clone()),
399 secrets_api: secrets_api::SecretsApiClient::new(configuration.clone()),
400 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient::new(configuration.clone()),
401 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient::new(configuration.clone()),
402 security_task_api: security_task_api::SecurityTaskApiClient::new(configuration.clone()),
403 self_hosted_account_billing_api: self_hosted_account_billing_api::SelfHostedAccountBillingApiClient::new(configuration.clone()),
404 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient::new(configuration.clone()),
405 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient::new(configuration.clone()),
406 sends_api: sends_api::SendsApiClient::new(configuration.clone()),
407 service_accounts_api: service_accounts_api::ServiceAccountsApiClient::new(configuration.clone()),
408 settings_api: settings_api::SettingsApiClient::new(configuration.clone()),
409 slack_integration_api: slack_integration_api::SlackIntegrationApiClient::new(configuration.clone()),
410 stripe_api: stripe_api::StripeApiClient::new(configuration.clone()),
411 sync_api: sync_api::SyncApiClient::new(configuration.clone()),
412 tax_api: tax_api::TaxApiClient::new(configuration.clone()),
413 teams_integration_api: teams_integration_api::TeamsIntegrationApiClient::new(configuration.clone()),
414 trash_api: trash_api::TrashApiClient::new(configuration.clone()),
415 two_factor_api: two_factor_api::TwoFactorApiClient::new(configuration.clone()),
416 users_api: users_api::UsersApiClient::new(configuration.clone()),
417 web_authn_api: web_authn_api::WebAuthnApiClient::new(configuration.clone()),
418 })
419 }
420
421 #[cfg(feature = "mockall")]
422 pub fn new_mocked(func: impl FnOnce(&mut ApiClientMock)) -> Self {
423 let mut mock = ApiClientMock {
424 access_policies_api: access_policies_api::MockAccessPoliciesApi::new(),
425 account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi::new(),
426 accounts_api: accounts_api::MockAccountsApi::new(),
427 accounts_billing_api: accounts_billing_api::MockAccountsBillingApi::new(),
428 accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi::new(),
429 auth_requests_api: auth_requests_api::MockAuthRequestsApi::new(),
430 ciphers_api: ciphers_api::MockCiphersApi::new(),
431 collections_api: collections_api::MockCollectionsApi::new(),
432 config_api: config_api::MockConfigApi::new(),
433 counts_api: counts_api::MockCountsApi::new(),
434 devices_api: devices_api::MockDevicesApi::new(),
435 emergency_access_api: emergency_access_api::MockEmergencyAccessApi::new(),
436 events_api: events_api::MockEventsApi::new(),
437 folders_api: folders_api::MockFoldersApi::new(),
438 groups_api: groups_api::MockGroupsApi::new(),
439 hibp_api: hibp_api::MockHibpApi::new(),
440 import_ciphers_api: import_ciphers_api::MockImportCiphersApi::new(),
441 info_api: info_api::MockInfoApi::new(),
442 installations_api: installations_api::MockInstallationsApi::new(),
443 invoices_api: invoices_api::MockInvoicesApi::new(),
444 licenses_api: licenses_api::MockLicensesApi::new(),
445 misc_api: misc_api::MockMiscApi::new(),
446 notifications_api: notifications_api::MockNotificationsApi::new(),
447 organization_auth_requests_api: organization_auth_requests_api::MockOrganizationAuthRequestsApi::new(),
448 organization_billing_api: organization_billing_api::MockOrganizationBillingApi::new(),
449 organization_billing_v_next_api: organization_billing_v_next_api::MockOrganizationBillingVNextApi::new(),
450 organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi::new(),
451 organization_domain_api: organization_domain_api::MockOrganizationDomainApi::new(),
452 organization_export_api: organization_export_api::MockOrganizationExportApi::new(),
453 organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi::new(),
454 organization_integration_configuration_api: organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi::new(),
455 organization_reports_api: organization_reports_api::MockOrganizationReportsApi::new(),
456 organization_sponsorships_api: organization_sponsorships_api::MockOrganizationSponsorshipsApi::new(),
457 organization_users_api: organization_users_api::MockOrganizationUsersApi::new(),
458 organizations_api: organizations_api::MockOrganizationsApi::new(),
459 phishing_domains_api: phishing_domains_api::MockPhishingDomainsApi::new(),
460 plans_api: plans_api::MockPlansApi::new(),
461 policies_api: policies_api::MockPoliciesApi::new(),
462 projects_api: projects_api::MockProjectsApi::new(),
463 provider_billing_api: provider_billing_api::MockProviderBillingApi::new(),
464 provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi::new(),
465 provider_clients_api: provider_clients_api::MockProviderClientsApi::new(),
466 provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi::new(),
467 provider_users_api: provider_users_api::MockProviderUsersApi::new(),
468 providers_api: providers_api::MockProvidersApi::new(),
469 push_api: push_api::MockPushApi::new(),
470 reports_api: reports_api::MockReportsApi::new(),
471 request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi::new(),
472 secrets_api: secrets_api::MockSecretsApi::new(),
473 secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi::new(),
474 secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi::new(),
475 security_task_api: security_task_api::MockSecurityTaskApi::new(),
476 self_hosted_account_billing_api: self_hosted_account_billing_api::MockSelfHostedAccountBillingApi::new(),
477 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi::new(),
478 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi::new(),
479 sends_api: sends_api::MockSendsApi::new(),
480 service_accounts_api: service_accounts_api::MockServiceAccountsApi::new(),
481 settings_api: settings_api::MockSettingsApi::new(),
482 slack_integration_api: slack_integration_api::MockSlackIntegrationApi::new(),
483 stripe_api: stripe_api::MockStripeApi::new(),
484 sync_api: sync_api::MockSyncApi::new(),
485 tax_api: tax_api::MockTaxApi::new(),
486 teams_integration_api: teams_integration_api::MockTeamsIntegrationApi::new(),
487 trash_api: trash_api::MockTrashApi::new(),
488 two_factor_api: two_factor_api::MockTwoFactorApi::new(),
489 users_api: users_api::MockUsersApi::new(),
490 web_authn_api: web_authn_api::MockWebAuthnApi::new(),
491 };
492 func(&mut mock);
493 Self::Mock(mock)
494 }
495}
496
497impl ApiClient {
498 pub fn access_policies_api(&self) -> &dyn access_policies_api::AccessPoliciesApi {
499 match self {
500 ApiClient::Real(real) => &real.access_policies_api,
501 #[cfg(feature = "mockall")]
502 ApiClient::Mock(mock) => &mock.access_policies_api,
503 }
504 }
505 pub fn account_billing_v_next_api(
506 &self,
507 ) -> &dyn account_billing_v_next_api::AccountBillingVNextApi {
508 match self {
509 ApiClient::Real(real) => &real.account_billing_v_next_api,
510 #[cfg(feature = "mockall")]
511 ApiClient::Mock(mock) => &mock.account_billing_v_next_api,
512 }
513 }
514 pub fn accounts_api(&self) -> &dyn accounts_api::AccountsApi {
515 match self {
516 ApiClient::Real(real) => &real.accounts_api,
517 #[cfg(feature = "mockall")]
518 ApiClient::Mock(mock) => &mock.accounts_api,
519 }
520 }
521 pub fn accounts_billing_api(&self) -> &dyn accounts_billing_api::AccountsBillingApi {
522 match self {
523 ApiClient::Real(real) => &real.accounts_billing_api,
524 #[cfg(feature = "mockall")]
525 ApiClient::Mock(mock) => &mock.accounts_billing_api,
526 }
527 }
528 pub fn accounts_key_management_api(
529 &self,
530 ) -> &dyn accounts_key_management_api::AccountsKeyManagementApi {
531 match self {
532 ApiClient::Real(real) => &real.accounts_key_management_api,
533 #[cfg(feature = "mockall")]
534 ApiClient::Mock(mock) => &mock.accounts_key_management_api,
535 }
536 }
537 pub fn auth_requests_api(&self) -> &dyn auth_requests_api::AuthRequestsApi {
538 match self {
539 ApiClient::Real(real) => &real.auth_requests_api,
540 #[cfg(feature = "mockall")]
541 ApiClient::Mock(mock) => &mock.auth_requests_api,
542 }
543 }
544 pub fn ciphers_api(&self) -> &dyn ciphers_api::CiphersApi {
545 match self {
546 ApiClient::Real(real) => &real.ciphers_api,
547 #[cfg(feature = "mockall")]
548 ApiClient::Mock(mock) => &mock.ciphers_api,
549 }
550 }
551 pub fn collections_api(&self) -> &dyn collections_api::CollectionsApi {
552 match self {
553 ApiClient::Real(real) => &real.collections_api,
554 #[cfg(feature = "mockall")]
555 ApiClient::Mock(mock) => &mock.collections_api,
556 }
557 }
558 pub fn config_api(&self) -> &dyn config_api::ConfigApi {
559 match self {
560 ApiClient::Real(real) => &real.config_api,
561 #[cfg(feature = "mockall")]
562 ApiClient::Mock(mock) => &mock.config_api,
563 }
564 }
565 pub fn counts_api(&self) -> &dyn counts_api::CountsApi {
566 match self {
567 ApiClient::Real(real) => &real.counts_api,
568 #[cfg(feature = "mockall")]
569 ApiClient::Mock(mock) => &mock.counts_api,
570 }
571 }
572 pub fn devices_api(&self) -> &dyn devices_api::DevicesApi {
573 match self {
574 ApiClient::Real(real) => &real.devices_api,
575 #[cfg(feature = "mockall")]
576 ApiClient::Mock(mock) => &mock.devices_api,
577 }
578 }
579 pub fn emergency_access_api(&self) -> &dyn emergency_access_api::EmergencyAccessApi {
580 match self {
581 ApiClient::Real(real) => &real.emergency_access_api,
582 #[cfg(feature = "mockall")]
583 ApiClient::Mock(mock) => &mock.emergency_access_api,
584 }
585 }
586 pub fn events_api(&self) -> &dyn events_api::EventsApi {
587 match self {
588 ApiClient::Real(real) => &real.events_api,
589 #[cfg(feature = "mockall")]
590 ApiClient::Mock(mock) => &mock.events_api,
591 }
592 }
593 pub fn folders_api(&self) -> &dyn folders_api::FoldersApi {
594 match self {
595 ApiClient::Real(real) => &real.folders_api,
596 #[cfg(feature = "mockall")]
597 ApiClient::Mock(mock) => &mock.folders_api,
598 }
599 }
600 pub fn groups_api(&self) -> &dyn groups_api::GroupsApi {
601 match self {
602 ApiClient::Real(real) => &real.groups_api,
603 #[cfg(feature = "mockall")]
604 ApiClient::Mock(mock) => &mock.groups_api,
605 }
606 }
607 pub fn hibp_api(&self) -> &dyn hibp_api::HibpApi {
608 match self {
609 ApiClient::Real(real) => &real.hibp_api,
610 #[cfg(feature = "mockall")]
611 ApiClient::Mock(mock) => &mock.hibp_api,
612 }
613 }
614 pub fn import_ciphers_api(&self) -> &dyn import_ciphers_api::ImportCiphersApi {
615 match self {
616 ApiClient::Real(real) => &real.import_ciphers_api,
617 #[cfg(feature = "mockall")]
618 ApiClient::Mock(mock) => &mock.import_ciphers_api,
619 }
620 }
621 pub fn info_api(&self) -> &dyn info_api::InfoApi {
622 match self {
623 ApiClient::Real(real) => &real.info_api,
624 #[cfg(feature = "mockall")]
625 ApiClient::Mock(mock) => &mock.info_api,
626 }
627 }
628 pub fn installations_api(&self) -> &dyn installations_api::InstallationsApi {
629 match self {
630 ApiClient::Real(real) => &real.installations_api,
631 #[cfg(feature = "mockall")]
632 ApiClient::Mock(mock) => &mock.installations_api,
633 }
634 }
635 pub fn invoices_api(&self) -> &dyn invoices_api::InvoicesApi {
636 match self {
637 ApiClient::Real(real) => &real.invoices_api,
638 #[cfg(feature = "mockall")]
639 ApiClient::Mock(mock) => &mock.invoices_api,
640 }
641 }
642 pub fn licenses_api(&self) -> &dyn licenses_api::LicensesApi {
643 match self {
644 ApiClient::Real(real) => &real.licenses_api,
645 #[cfg(feature = "mockall")]
646 ApiClient::Mock(mock) => &mock.licenses_api,
647 }
648 }
649 pub fn misc_api(&self) -> &dyn misc_api::MiscApi {
650 match self {
651 ApiClient::Real(real) => &real.misc_api,
652 #[cfg(feature = "mockall")]
653 ApiClient::Mock(mock) => &mock.misc_api,
654 }
655 }
656 pub fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi {
657 match self {
658 ApiClient::Real(real) => &real.notifications_api,
659 #[cfg(feature = "mockall")]
660 ApiClient::Mock(mock) => &mock.notifications_api,
661 }
662 }
663 pub fn organization_auth_requests_api(
664 &self,
665 ) -> &dyn organization_auth_requests_api::OrganizationAuthRequestsApi {
666 match self {
667 ApiClient::Real(real) => &real.organization_auth_requests_api,
668 #[cfg(feature = "mockall")]
669 ApiClient::Mock(mock) => &mock.organization_auth_requests_api,
670 }
671 }
672 pub fn organization_billing_api(
673 &self,
674 ) -> &dyn organization_billing_api::OrganizationBillingApi {
675 match self {
676 ApiClient::Real(real) => &real.organization_billing_api,
677 #[cfg(feature = "mockall")]
678 ApiClient::Mock(mock) => &mock.organization_billing_api,
679 }
680 }
681 pub fn organization_billing_v_next_api(
682 &self,
683 ) -> &dyn organization_billing_v_next_api::OrganizationBillingVNextApi {
684 match self {
685 ApiClient::Real(real) => &real.organization_billing_v_next_api,
686 #[cfg(feature = "mockall")]
687 ApiClient::Mock(mock) => &mock.organization_billing_v_next_api,
688 }
689 }
690 pub fn organization_connections_api(
691 &self,
692 ) -> &dyn organization_connections_api::OrganizationConnectionsApi {
693 match self {
694 ApiClient::Real(real) => &real.organization_connections_api,
695 #[cfg(feature = "mockall")]
696 ApiClient::Mock(mock) => &mock.organization_connections_api,
697 }
698 }
699 pub fn organization_domain_api(&self) -> &dyn organization_domain_api::OrganizationDomainApi {
700 match self {
701 ApiClient::Real(real) => &real.organization_domain_api,
702 #[cfg(feature = "mockall")]
703 ApiClient::Mock(mock) => &mock.organization_domain_api,
704 }
705 }
706 pub fn organization_export_api(&self) -> &dyn organization_export_api::OrganizationExportApi {
707 match self {
708 ApiClient::Real(real) => &real.organization_export_api,
709 #[cfg(feature = "mockall")]
710 ApiClient::Mock(mock) => &mock.organization_export_api,
711 }
712 }
713 pub fn organization_integration_api(
714 &self,
715 ) -> &dyn organization_integration_api::OrganizationIntegrationApi {
716 match self {
717 ApiClient::Real(real) => &real.organization_integration_api,
718 #[cfg(feature = "mockall")]
719 ApiClient::Mock(mock) => &mock.organization_integration_api,
720 }
721 }
722 pub fn organization_integration_configuration_api(
723 &self,
724 ) -> &dyn organization_integration_configuration_api::OrganizationIntegrationConfigurationApi
725 {
726 match self {
727 ApiClient::Real(real) => &real.organization_integration_configuration_api,
728 #[cfg(feature = "mockall")]
729 ApiClient::Mock(mock) => &mock.organization_integration_configuration_api,
730 }
731 }
732 pub fn organization_reports_api(
733 &self,
734 ) -> &dyn organization_reports_api::OrganizationReportsApi {
735 match self {
736 ApiClient::Real(real) => &real.organization_reports_api,
737 #[cfg(feature = "mockall")]
738 ApiClient::Mock(mock) => &mock.organization_reports_api,
739 }
740 }
741 pub fn organization_sponsorships_api(
742 &self,
743 ) -> &dyn organization_sponsorships_api::OrganizationSponsorshipsApi {
744 match self {
745 ApiClient::Real(real) => &real.organization_sponsorships_api,
746 #[cfg(feature = "mockall")]
747 ApiClient::Mock(mock) => &mock.organization_sponsorships_api,
748 }
749 }
750 pub fn organization_users_api(&self) -> &dyn organization_users_api::OrganizationUsersApi {
751 match self {
752 ApiClient::Real(real) => &real.organization_users_api,
753 #[cfg(feature = "mockall")]
754 ApiClient::Mock(mock) => &mock.organization_users_api,
755 }
756 }
757 pub fn organizations_api(&self) -> &dyn organizations_api::OrganizationsApi {
758 match self {
759 ApiClient::Real(real) => &real.organizations_api,
760 #[cfg(feature = "mockall")]
761 ApiClient::Mock(mock) => &mock.organizations_api,
762 }
763 }
764 pub fn phishing_domains_api(&self) -> &dyn phishing_domains_api::PhishingDomainsApi {
765 match self {
766 ApiClient::Real(real) => &real.phishing_domains_api,
767 #[cfg(feature = "mockall")]
768 ApiClient::Mock(mock) => &mock.phishing_domains_api,
769 }
770 }
771 pub fn plans_api(&self) -> &dyn plans_api::PlansApi {
772 match self {
773 ApiClient::Real(real) => &real.plans_api,
774 #[cfg(feature = "mockall")]
775 ApiClient::Mock(mock) => &mock.plans_api,
776 }
777 }
778 pub fn policies_api(&self) -> &dyn policies_api::PoliciesApi {
779 match self {
780 ApiClient::Real(real) => &real.policies_api,
781 #[cfg(feature = "mockall")]
782 ApiClient::Mock(mock) => &mock.policies_api,
783 }
784 }
785 pub fn projects_api(&self) -> &dyn projects_api::ProjectsApi {
786 match self {
787 ApiClient::Real(real) => &real.projects_api,
788 #[cfg(feature = "mockall")]
789 ApiClient::Mock(mock) => &mock.projects_api,
790 }
791 }
792 pub fn provider_billing_api(&self) -> &dyn provider_billing_api::ProviderBillingApi {
793 match self {
794 ApiClient::Real(real) => &real.provider_billing_api,
795 #[cfg(feature = "mockall")]
796 ApiClient::Mock(mock) => &mock.provider_billing_api,
797 }
798 }
799 pub fn provider_billing_v_next_api(
800 &self,
801 ) -> &dyn provider_billing_v_next_api::ProviderBillingVNextApi {
802 match self {
803 ApiClient::Real(real) => &real.provider_billing_v_next_api,
804 #[cfg(feature = "mockall")]
805 ApiClient::Mock(mock) => &mock.provider_billing_v_next_api,
806 }
807 }
808 pub fn provider_clients_api(&self) -> &dyn provider_clients_api::ProviderClientsApi {
809 match self {
810 ApiClient::Real(real) => &real.provider_clients_api,
811 #[cfg(feature = "mockall")]
812 ApiClient::Mock(mock) => &mock.provider_clients_api,
813 }
814 }
815 pub fn provider_organizations_api(
816 &self,
817 ) -> &dyn provider_organizations_api::ProviderOrganizationsApi {
818 match self {
819 ApiClient::Real(real) => &real.provider_organizations_api,
820 #[cfg(feature = "mockall")]
821 ApiClient::Mock(mock) => &mock.provider_organizations_api,
822 }
823 }
824 pub fn provider_users_api(&self) -> &dyn provider_users_api::ProviderUsersApi {
825 match self {
826 ApiClient::Real(real) => &real.provider_users_api,
827 #[cfg(feature = "mockall")]
828 ApiClient::Mock(mock) => &mock.provider_users_api,
829 }
830 }
831 pub fn providers_api(&self) -> &dyn providers_api::ProvidersApi {
832 match self {
833 ApiClient::Real(real) => &real.providers_api,
834 #[cfg(feature = "mockall")]
835 ApiClient::Mock(mock) => &mock.providers_api,
836 }
837 }
838 pub fn push_api(&self) -> &dyn push_api::PushApi {
839 match self {
840 ApiClient::Real(real) => &real.push_api,
841 #[cfg(feature = "mockall")]
842 ApiClient::Mock(mock) => &mock.push_api,
843 }
844 }
845 pub fn reports_api(&self) -> &dyn reports_api::ReportsApi {
846 match self {
847 ApiClient::Real(real) => &real.reports_api,
848 #[cfg(feature = "mockall")]
849 ApiClient::Mock(mock) => &mock.reports_api,
850 }
851 }
852 pub fn request_sm_access_api(&self) -> &dyn request_sm_access_api::RequestSmAccessApi {
853 match self {
854 ApiClient::Real(real) => &real.request_sm_access_api,
855 #[cfg(feature = "mockall")]
856 ApiClient::Mock(mock) => &mock.request_sm_access_api,
857 }
858 }
859 pub fn secrets_api(&self) -> &dyn secrets_api::SecretsApi {
860 match self {
861 ApiClient::Real(real) => &real.secrets_api,
862 #[cfg(feature = "mockall")]
863 ApiClient::Mock(mock) => &mock.secrets_api,
864 }
865 }
866 pub fn secrets_manager_events_api(
867 &self,
868 ) -> &dyn secrets_manager_events_api::SecretsManagerEventsApi {
869 match self {
870 ApiClient::Real(real) => &real.secrets_manager_events_api,
871 #[cfg(feature = "mockall")]
872 ApiClient::Mock(mock) => &mock.secrets_manager_events_api,
873 }
874 }
875 pub fn secrets_manager_porting_api(
876 &self,
877 ) -> &dyn secrets_manager_porting_api::SecretsManagerPortingApi {
878 match self {
879 ApiClient::Real(real) => &real.secrets_manager_porting_api,
880 #[cfg(feature = "mockall")]
881 ApiClient::Mock(mock) => &mock.secrets_manager_porting_api,
882 }
883 }
884 pub fn security_task_api(&self) -> &dyn security_task_api::SecurityTaskApi {
885 match self {
886 ApiClient::Real(real) => &real.security_task_api,
887 #[cfg(feature = "mockall")]
888 ApiClient::Mock(mock) => &mock.security_task_api,
889 }
890 }
891 pub fn self_hosted_account_billing_api(
892 &self,
893 ) -> &dyn self_hosted_account_billing_api::SelfHostedAccountBillingApi {
894 match self {
895 ApiClient::Real(real) => &real.self_hosted_account_billing_api,
896 #[cfg(feature = "mockall")]
897 ApiClient::Mock(mock) => &mock.self_hosted_account_billing_api,
898 }
899 }
900 pub fn self_hosted_organization_licenses_api(
901 &self,
902 ) -> &dyn self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApi {
903 match self {
904 ApiClient::Real(real) => &real.self_hosted_organization_licenses_api,
905 #[cfg(feature = "mockall")]
906 ApiClient::Mock(mock) => &mock.self_hosted_organization_licenses_api,
907 }
908 }
909 pub fn self_hosted_organization_sponsorships_api(
910 &self,
911 ) -> &dyn self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApi {
912 match self {
913 ApiClient::Real(real) => &real.self_hosted_organization_sponsorships_api,
914 #[cfg(feature = "mockall")]
915 ApiClient::Mock(mock) => &mock.self_hosted_organization_sponsorships_api,
916 }
917 }
918 pub fn sends_api(&self) -> &dyn sends_api::SendsApi {
919 match self {
920 ApiClient::Real(real) => &real.sends_api,
921 #[cfg(feature = "mockall")]
922 ApiClient::Mock(mock) => &mock.sends_api,
923 }
924 }
925 pub fn service_accounts_api(&self) -> &dyn service_accounts_api::ServiceAccountsApi {
926 match self {
927 ApiClient::Real(real) => &real.service_accounts_api,
928 #[cfg(feature = "mockall")]
929 ApiClient::Mock(mock) => &mock.service_accounts_api,
930 }
931 }
932 pub fn settings_api(&self) -> &dyn settings_api::SettingsApi {
933 match self {
934 ApiClient::Real(real) => &real.settings_api,
935 #[cfg(feature = "mockall")]
936 ApiClient::Mock(mock) => &mock.settings_api,
937 }
938 }
939 pub fn slack_integration_api(&self) -> &dyn slack_integration_api::SlackIntegrationApi {
940 match self {
941 ApiClient::Real(real) => &real.slack_integration_api,
942 #[cfg(feature = "mockall")]
943 ApiClient::Mock(mock) => &mock.slack_integration_api,
944 }
945 }
946 pub fn stripe_api(&self) -> &dyn stripe_api::StripeApi {
947 match self {
948 ApiClient::Real(real) => &real.stripe_api,
949 #[cfg(feature = "mockall")]
950 ApiClient::Mock(mock) => &mock.stripe_api,
951 }
952 }
953 pub fn sync_api(&self) -> &dyn sync_api::SyncApi {
954 match self {
955 ApiClient::Real(real) => &real.sync_api,
956 #[cfg(feature = "mockall")]
957 ApiClient::Mock(mock) => &mock.sync_api,
958 }
959 }
960 pub fn tax_api(&self) -> &dyn tax_api::TaxApi {
961 match self {
962 ApiClient::Real(real) => &real.tax_api,
963 #[cfg(feature = "mockall")]
964 ApiClient::Mock(mock) => &mock.tax_api,
965 }
966 }
967 pub fn teams_integration_api(&self) -> &dyn teams_integration_api::TeamsIntegrationApi {
968 match self {
969 ApiClient::Real(real) => &real.teams_integration_api,
970 #[cfg(feature = "mockall")]
971 ApiClient::Mock(mock) => &mock.teams_integration_api,
972 }
973 }
974 pub fn trash_api(&self) -> &dyn trash_api::TrashApi {
975 match self {
976 ApiClient::Real(real) => &real.trash_api,
977 #[cfg(feature = "mockall")]
978 ApiClient::Mock(mock) => &mock.trash_api,
979 }
980 }
981 pub fn two_factor_api(&self) -> &dyn two_factor_api::TwoFactorApi {
982 match self {
983 ApiClient::Real(real) => &real.two_factor_api,
984 #[cfg(feature = "mockall")]
985 ApiClient::Mock(mock) => &mock.two_factor_api,
986 }
987 }
988 pub fn users_api(&self) -> &dyn users_api::UsersApi {
989 match self {
990 ApiClient::Real(real) => &real.users_api,
991 #[cfg(feature = "mockall")]
992 ApiClient::Mock(mock) => &mock.users_api,
993 }
994 }
995 pub fn web_authn_api(&self) -> &dyn web_authn_api::WebAuthnApi {
996 match self {
997 ApiClient::Real(real) => &real.web_authn_api,
998 #[cfg(feature = "mockall")]
999 ApiClient::Mock(mock) => &mock.web_authn_api,
1000 }
1001 }
1002}