bitwarden_api_api/apis/
mod.rs

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/// Internal use only
95/// A content type supported by this client.
96#[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}