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