chore: rename Client* to *Client

Author: tangowithfoxtrot

crates/bitwarden-core/src/auth/client_auth.rs

@@ -25,11 +25,11 @@ use crate::auth::{
 };
 use crate::{auth::renew::renew_token, error::Result, Client};
 
-pub struct ClientAuth<'a> {
+pub struct AuthClient<'a> {
     pub(crate) client: &'a crate::Client,
 }
 
-impl<'a> ClientAuth<'a> {
+impl<'a> AuthClient<'a> {
     pub async fn renew_token(&self) -> Result<()> {
         renew_token(&self.client.internal).await
     }
@@ -44,7 +44,7 @@ impl<'a> ClientAuth<'a> {
 }
 
 #[cfg(feature = "internal")]
-impl<'a> ClientAuth<'a> {
+impl<'a> AuthClient<'a> {
     pub fn password_strength(
         &self,
         password: String,
@@ -142,7 +142,7 @@ impl<'a> ClientAuth<'a> {
 }
 
 #[cfg(feature = "internal")]
-impl<'a> ClientAuth<'a> {
+impl<'a> AuthClient<'a> {
     pub async fn login_device(
         &self,
         email: String,
@@ -170,8 +170,8 @@ fn trust_device(client: &Client) -> Result<TrustDeviceResponse> {
 }
 
 impl<'a> Client {
-    pub fn auth(&'a self) -> ClientAuth<'a> {
-        ClientAuth { client: self }
+    pub fn auth(&'a self) -> AuthClient<'a> {
+        AuthClient { client: self }
     }
 }
 

crates/bitwarden-core/src/mobile/client_crypto.rs

@@ -13,11 +13,11 @@ use crate::{
     },
 };
 
-pub struct ClientCrypto<'a> {
+pub struct CryptoClient<'a> {
     pub(crate) client: &'a crate::Client,
 }
 
-impl<'a> ClientCrypto<'a> {
+impl<'a> CryptoClient<'a> {
     pub async fn initialize_user_crypto(
         &self,
         req: InitUserCryptoRequest,
@@ -59,7 +59,7 @@ impl<'a> ClientCrypto<'a> {
 }
 
 impl<'a> Client {
-    pub fn crypto(&'a self) -> ClientCrypto<'a> {
-        ClientCrypto { client: self }
+    pub fn crypto(&'a self) -> CryptoClient<'a> {
+        CryptoClient { client: self }
     }
 }

crates/bitwarden-core/src/mobile/mod.rs

@@ -4,5 +4,5 @@ pub mod kdf;
 mod client_crypto;
 mod client_kdf;
 
-pub use client_crypto::ClientCrypto;
+pub use client_crypto::CryptoClient;
 pub use client_kdf::ClientKdf;

crates/bitwarden-core/src/platform/client_platform.rs

@@ -5,11 +5,11 @@ use super::{
 };
 use crate::{error::Result, Client};
 
-pub struct ClientPlatform<'a> {
+pub struct PlatformClient<'a> {
     pub(crate) client: &'a Client,
 }
 
-impl<'a> ClientPlatform<'a> {
+impl<'a> PlatformClient<'a> {
     pub fn fingerprint(&self, input: &FingerprintRequest) -> Result<FingerprintResponse> {
         generate_fingerprint(input)
     }
@@ -27,7 +27,7 @@ impl<'a> ClientPlatform<'a> {
 }
 
 impl<'a> Client {
-    pub fn platform(&'a self) -> ClientPlatform<'a> {
-        ClientPlatform { client: self }
+    pub fn platform(&'a self) -> PlatformClient<'a> {
+        PlatformClient { client: self }
     }
 }

crates/bitwarden-exporters/src/client_exporter.rs

@@ -6,11 +6,11 @@ use crate::{
     ExportError, ExportFormat,
 };
 
-pub struct ClientExporters<'a> {
+pub struct ExporterClients<'a> {
     client: &'a Client,
 }
 
-impl<'a> ClientExporters<'a> {
+impl<'a> ExporterClients<'a> {
     fn new(client: &'a Client) -> Self {
         Self { client }
     }
@@ -34,12 +34,12 @@ impl<'a> ClientExporters<'a> {
     }
 }
 
-pub trait ClientExportersExt<'a> {
-    fn exporters(&'a self) -> ClientExporters<'a>;
+pub trait ExporterClientsExt<'a> {
+    fn exporters(&'a self) -> ExporterClients<'a>;
 }
 
-impl<'a> ClientExportersExt<'a> for Client {
-    fn exporters(&'a self) -> ClientExporters<'a> {
-        ClientExporters::new(self)
+impl<'a> ExporterClientsExt<'a> for Client {
+    fn exporters(&'a self) -> ExporterClients<'a> {
+        ExporterClients::new(self)
     }
 }

crates/bitwarden-exporters/src/lib.rs

@@ -12,7 +12,7 @@ mod csv;
 mod encrypted_json;
 mod json;
 mod models;
-pub use client_exporter::{ClientExporters, ClientExportersExt};
+pub use client_exporter::{ExporterClients, ExporterClientsExt};
 mod error;
 mod export;
 pub use error::ExportError;

crates/bitwarden-generators/src/client_generator.rs

@@ -6,11 +6,11 @@ use crate::{
     UsernameGeneratorRequest,
 };
 
-pub struct ClientGenerator<'a> {
+pub struct GeneratorClient<'a> {
     client: &'a Client,
 }
 
-impl<'a> ClientGenerator<'a> {
+impl<'a> GeneratorClient<'a> {
     fn new(client: &'a Client) -> Self {
         Self { client }
     }
@@ -23,7 +23,7 @@ impl<'a> ClientGenerator<'a> {
     ///
     /// ```
     /// use bitwarden_core::Client;
-    /// use bitwarden_generators::{ClientGeneratorExt, PassphraseError, PasswordGeneratorRequest};
+    /// use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
     ///
     /// async fn test() -> Result<(), PassphraseError> {
     ///     let input = PasswordGeneratorRequest {
@@ -53,7 +53,7 @@ impl<'a> ClientGenerator<'a> {
     ///
     /// ```
     /// use bitwarden_core::Client;
-    /// use bitwarden_generators::{ClientGeneratorExt, PassphraseError, PassphraseGeneratorRequest};
+    /// use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
     ///
     /// async fn test() -> Result<(), PassphraseError> {
     ///     let input = PassphraseGeneratorRequest {
@@ -78,7 +78,7 @@ impl<'a> ClientGenerator<'a> {
     ///
     /// ```
     /// use bitwarden_core::Client;
-    /// use bitwarden_generators::{ClientGeneratorExt, UsernameError, UsernameGeneratorRequest};
+    /// use bitwarden_generators::{GeneratorClientsExt, UsernameError, UsernameGeneratorRequest};
     ///
     /// async fn test() -> Result<(), UsernameError> {
     ///     let input = UsernameGeneratorRequest::Word {
@@ -95,12 +95,12 @@ impl<'a> ClientGenerator<'a> {
     }
 }
 
-pub trait ClientGeneratorExt<'a> {
-    fn generator(&'a self) -> ClientGenerator<'a>;
+pub trait GeneratorClientsExt<'a> {
+    fn generator(&'a self) -> GeneratorClient<'a>;
 }
 
-impl<'a> ClientGeneratorExt<'a> for Client {
-    fn generator(&'a self) -> ClientGenerator<'a> {
-        ClientGenerator::new(self)
+impl<'a> GeneratorClientsExt<'a> for Client {
+    fn generator(&'a self) -> GeneratorClient<'a> {
+        GeneratorClient::new(self)
     }
 }

crates/bitwarden-generators/src/lib.rs

@@ -1,6 +1,6 @@
 mod client_generator;
 mod username_forwarders;
-pub use client_generator::{ClientGenerator, ClientGeneratorExt};
+pub use client_generator::{GeneratorClient, GeneratorClientsExt};
 pub(crate) mod passphrase;
 pub use passphrase::{PassphraseError, PassphraseGeneratorRequest};
 pub(crate) mod password;

crates/bitwarden-send/src/client_sends.rs

@@ -5,11 +5,11 @@ use bitwarden_crypto::{EncString, KeyDecryptable, KeyEncryptable};
 
 use crate::{Send, SendListView, SendView};
 
-pub struct ClientSends<'a> {
+pub struct SendClients<'a> {
     client: &'a Client,
 }
 
-impl<'a> ClientSends<'a> {
+impl<'a> SendClients<'a> {
     fn new(client: &'a Client) -> Self {
         Self { client }
     }
@@ -84,12 +84,12 @@ impl<'a> ClientSends<'a> {
     }
 }
 
-pub trait ClientSendsExt<'a> {
-    fn sends(&'a self) -> ClientSends<'a>;
+pub trait SendClientsExt<'a> {
+    fn sends(&'a self) -> SendClients<'a>;
 }
 
-impl<'a> ClientSendsExt<'a> for Client {
-    fn sends(&'a self) -> ClientSends<'a> {
-        ClientSends::new(self)
+impl<'a> SendClientsExt<'a> for Client {
+    fn sends(&'a self) -> SendClients<'a> {
+        SendClients::new(self)
     }
 }

crates/bitwarden-send/src/lib.rs

@@ -6,6 +6,6 @@ mod uniffi_support;
 mod error;
 pub use error::SendParseError;
 mod client_sends;
-pub use client_sends::{ClientSends, ClientSendsExt};
+pub use client_sends::{SendClients, SendClientsExt};
 mod send;
 pub use send::{Send, SendListView, SendView};

crates/bitwarden-uniffi/src/auth/mod.rs

@@ -12,10 +12,10 @@ use bitwarden_crypto::{AsymmetricEncString, EncString, HashPurpose, Kdf, TrustDe
 use crate::{error::Result, Client};
 
 #[derive(uniffi::Object)]
-pub struct ClientAuth(pub(crate) Arc<Client>);
+pub struct AuthClient(pub(crate) Arc<Client>);
 
 #[uniffi::export(async_runtime = "tokio")]
-impl ClientAuth {
+impl AuthClient {
     /// **API Draft:** Calculate Password Strength
     pub fn password_strength(
         &self,
@@ -94,7 +94,7 @@ impl ClientAuth {
 
     /// Validate the user password
     ///
-    /// To retrieve the user's password hash, use [`ClientAuth::hash_password`] with
+    /// To retrieve the user's password hash, use [`AuthClient::hash_password`] with
     /// `HashPurpose::LocalAuthentication` during login and persist it. If the login method has no
     /// password, use the email OTP.
     pub fn validate_password(&self, password: String, password_hash: String) -> Result<bool> {

crates/bitwarden-uniffi/src/crypto.rs

@@ -12,10 +12,10 @@ use bitwarden_crypto::{AsymmetricEncString, EncString};
 use crate::{error::Result, Client};
 
 #[derive(uniffi::Object)]
-pub struct ClientCrypto(pub(crate) Arc<Client>);
+pub struct CryptoClient(pub(crate) Arc<Client>);
 
 #[uniffi::export(async_runtime = "tokio")]
-impl ClientCrypto {
+impl CryptoClient {
     /// Initialization method for the user crypto. Needs to be called before any other crypto
     /// operations.
     pub async fn initialize_user_crypto(&self, req: InitUserCryptoRequest) -> Result<()> {

crates/bitwarden-uniffi/src/lib.rs

@@ -2,7 +2,7 @@ uniffi::setup_scaffolding!();
 
 use std::sync::Arc;
 
-use auth::ClientAuth;
+use auth::AuthClient;
 use bitwarden_core::ClientSettings;
 
 pub mod auth;
@@ -16,11 +16,11 @@ pub mod vault;
 #[cfg(target_os = "android")]
 mod android_support;
 
-use crypto::ClientCrypto;
+use crypto::CryptoClient;
 use error::Result;
-use platform::ClientPlatform;
-use tool::{ClientExporters, ClientGenerators, ClientSends};
-use vault::ClientVault;
+use platform::PlatformClient;
+use tool::{ExporterClients, GeneratorClients, SendClients};
+use vault::VaultClient;
 
 #[derive(uniffi::Object)]
 pub struct Client(bitwarden_core::Client);
@@ -39,37 +39,37 @@ impl Client {
     }
 
     /// Crypto operations
-    pub fn crypto(self: Arc<Self>) -> Arc<ClientCrypto> {
-        Arc::new(ClientCrypto(self))
+    pub fn crypto(self: Arc<Self>) -> Arc<CryptoClient> {
+        Arc::new(CryptoClient(self))
     }
 
     /// Vault item operations
-    pub fn vault(self: Arc<Self>) -> Arc<ClientVault> {
-        Arc::new(ClientVault(self))
+    pub fn vault(self: Arc<Self>) -> Arc<VaultClient> {
+        Arc::new(VaultClient(self))
     }
 
-    pub fn platform(self: Arc<Self>) -> Arc<ClientPlatform> {
-        Arc::new(ClientPlatform(self))
+    pub fn platform(self: Arc<Self>) -> Arc<PlatformClient> {
+        Arc::new(PlatformClient(self))
     }
 
     /// Generator operations
-    pub fn generators(self: Arc<Self>) -> Arc<ClientGenerators> {
-        Arc::new(ClientGenerators(self))
+    pub fn generators(self: Arc<Self>) -> Arc<GeneratorClients> {
+        Arc::new(GeneratorClients(self))
     }
 
     /// Exporters
-    pub fn exporters(self: Arc<Self>) -> Arc<ClientExporters> {
-        Arc::new(ClientExporters(self))
+    pub fn exporters(self: Arc<Self>) -> Arc<ExporterClients> {
+        Arc::new(ExporterClients(self))
     }
 
     /// Sends operations
-    pub fn sends(self: Arc<Self>) -> Arc<ClientSends> {
-        Arc::new(ClientSends(self))
+    pub fn sends(self: Arc<Self>) -> Arc<SendClients> {
+        Arc::new(SendClients(self))
     }
 
     /// Auth operations
-    pub fn auth(self: Arc<Self>) -> Arc<ClientAuth> {
-        Arc::new(ClientAuth(self))
+    pub fn auth(self: Arc<Self>) -> Arc<AuthClient> {
+        Arc::new(AuthClient(self))
     }
 
     /// Test method, echoes back the input

crates/bitwarden-uniffi/src/platform/mod.rs

@@ -7,10 +7,10 @@ use crate::{error::Result, Client};
 mod fido2;
 
 #[derive(uniffi::Object)]
-pub struct ClientPlatform(pub(crate) Arc<Client>);
+pub struct PlatformClient(pub(crate) Arc<Client>);
 
 #[uniffi::export]
-impl ClientPlatform {
+impl PlatformClient {
     /// Fingerprint (public key)
     pub fn fingerprint(&self, req: FingerprintRequest) -> Result<String> {
         Ok(self.0 .0.platform().fingerprint(&req)?.fingerprint)