sq: DRY entity names in module paths.

26 files changed, 193 insertions, 193 deletions

diff --git a/sq/src/commands/autocrypt.rs b/sq/src/commands/autocrypt.rs
index 748e71ea..129f438e 100644
--- a/sq/src/commands/autocrypt.rs
+++ b/sq/src/commands/autocrypt.rs
@@ -14,12 +14,11 @@ use crate::{
     sq_cli,
 };
 
-use sq_cli::autocrypt::{AutocryptSubcommands, AutocryptCommand};
-
-pub fn dispatch(config: Config, c: &AutocryptCommand) -> Result<()> {
+pub fn dispatch(config: Config, c: &sq_cli::autocrypt::Command) -> Result<()> {
+    use sq_cli::autocrypt::Subcommands::*;
 
     match &c.subcommand {
-        AutocryptSubcommands::Decode(command) => {
+        Decode(command) => {
             let input = open_or_stdin(command.io.input.as_deref())?;
             let mut output = config.create_or_stdout_pgp(
                 command.io.output.as_deref(),
@@ -34,7 +33,7 @@ pub fn dispatch(config: Config, c: &AutocryptCommand) -> Result<()> {
             }
             output.finalize()?;
         }
-        AutocryptSubcommands::EncodeSender(command) => {
+        EncodeSender(command) => {
             let input = open_or_stdin(command.io.input.as_deref())?;
             let mut output =
                 config.create_or_stdout_safe(command.io.output.as_deref())?;
diff --git a/sq/src/commands/certify.rs b/sq/src/commands/certify.rs
index ff790b7d..d3121dd8 100644
--- a/sq/src/commands/certify.rs
+++ b/sq/src/commands/certify.rs
@@ -18,9 +18,9 @@ use crate::SECONDS_IN_YEAR;
 use crate::commands::get_certification_keys;
 use crate::commands::GetKeysOptions;
 
-use crate::sq_cli::certify::CertifyCommand;
+use crate::sq_cli::certify;
 
-pub fn certify(config: Config, c: CertifyCommand)
+pub fn certify(config: Config, c: certify::Command)
     -> Result<()>
 {
     let certifier = c.certifier;
diff --git a/sq/src/commands/inspect.rs b/sq/src/commands/inspect.rs
index 57069c65..ca10e6ef 100644
--- a/sq/src/commands/inspect.rs
+++ b/sq/src/commands/inspect.rs
@@ -17,9 +17,9 @@ use super::dump::Convert;
 use crate::SECONDS_IN_YEAR;
 use crate::SECONDS_IN_DAY;
 
-use crate::sq_cli::inspect::InspectCommand;
+use crate::sq_cli::inspect;
 
-pub fn inspect(c: InspectCommand, policy: &dyn Policy, output: &mut dyn io::Write)
+pub fn inspect(c: inspect::Command, policy: &dyn Policy, output: &mut dyn io::Write)
                -> Result<()> {
     let print_certifications = c.certifications;
 
diff --git a/sq/src/commands/key.rs b/sq/src/commands/key.rs
index 7c07f242..2be2a0f7 100644
--- a/sq/src/commands/key.rs
+++ b/sq/src/commands/key.rs
@@ -24,18 +24,10 @@ use crate::SECONDS_IN_YEAR;
 use crate::parse_duration;
 use crate::decrypt_key;
 
-use crate::sq_cli::key::KeyCommand;
-use crate::sq_cli::key::KeyGenerateCommand;
-use crate::sq_cli::key::KeyPasswordCommand;
-use crate::sq_cli::key::KeyUseridCommand;
-use crate::sq_cli::key::KeyUseridAddCommand;
-use crate::sq_cli::key::KeyUseridStripCommand;
-use crate::sq_cli::key::KeyExtractCertCommand;
-use crate::sq_cli::key::KeyAdoptCommand;
-use crate::sq_cli::key::KeyAttestCertificationsCommand;
-use crate::sq_cli::key::KeySubcommands::*;
-
-pub fn dispatch(config: Config, command: KeyCommand) -> Result<()> {
+use crate::sq_cli;
+
+pub fn dispatch(config: Config, command: sq_cli::key::Command) -> Result<()> {
+    use sq_cli::key::Subcommands::*;
     match command.subcommand {
         Generate(c) => generate(config, c)?,
         Password(c) => password(config, c)?,
@@ -47,7 +39,10 @@ pub fn dispatch(config: Config, command: KeyCommand) -> Result<()> {
     Ok(())
 }
 
-fn generate(config: Config, command: KeyGenerateCommand) -> Result<()> {
+fn generate(
+    config: Config,
+    command: sq_cli::key::GenerateCommand,
+) -> Result<()> {
     let mut builder = CertBuilder::new();
 
     // User ID
@@ -91,7 +86,7 @@ fn generate(config: Config, command: KeyGenerateCommand) -> Result<()> {
     }
 
     // Cipher Suite
-    use crate::sq_cli::key::KeyCipherSuite::*;
+    use sq_cli::key::CipherSuite::*;
     match command.cipher_suite {
         Rsa3k => {
             builder = builder.set_cipher_suite(CipherSuite::RSA3k);
@@ -130,7 +125,7 @@ fn generate(config: Config, command: KeyGenerateCommand) -> Result<()> {
     }
 
     // Encryption Capability
-    use crate::sq_cli::key::KeyEncryptPurpose::*;
+    use sq_cli::key::EncryptPurpose::*;
     match (command.can_encrypt, command.cannot_encrypt) {
         (Some(Universal), false) | (None, false) => {
             builder = builder.add_subkey(KeyFlags::empty()
@@ -228,7 +223,10 @@ fn generate(config: Config, command: KeyGenerateCommand) -> Result<()> {
     Ok(())
 }
 
-fn password(config: Config, command: KeyPasswordCommand) -> Result<()> {
+fn password(
+    config: Config,
+    command: sq_cli::key::PasswordCommand,
+) -> Result<()> {
     let input = open_or_stdin(command.io.input.as_deref())?;
     let key = Cert::from_reader(input)?;
 
@@ -296,7 +294,10 @@ fn password(config: Config, command: KeyPasswordCommand) -> Result<()> {
     Ok(())
 }
 
-fn extract_cert(config: Config, command: KeyExtractCertCommand) -> Result<()> {
+fn extract_cert(
+    config: Config,
+    command: sq_cli::key::ExtractCertCommand,
+) -> Result<()> {
     let input = open_or_stdin(command.io.input.as_deref())?;
     let mut output = config.create_or_stdout_safe(command.io.output.as_deref())?;
 
@@ -309,16 +310,16 @@ fn extract_cert(config: Config, command: KeyExtractCertCommand) -> Result<()> {
     Ok(())
 }
 
-fn userid(config: Config, command: KeyUseridCommand) -> Result<()> {
+fn userid(config: Config, command: sq_cli::key::UseridCommand) -> Result<()> {
     match command {
-        KeyUseridCommand::Add(c) => userid_add(config, c)?,
-        KeyUseridCommand::Strip(c) => userid_strip(config, c)?,
+        sq_cli::key::UseridCommand::Add(c) => userid_add(config, c)?,
+        sq_cli::key::UseridCommand::Strip(c) => userid_strip(config, c)?,
     }
 
     Ok(())
 }
 
-fn userid_add(config: Config, command: KeyUseridAddCommand) -> Result<()> {
+fn userid_add(config: Config, command: sq_cli::key::UseridAddCommand) -> Result<()> {
     let input = open_or_stdin(command.io.input.as_deref())?;
     let key = Cert::from_reader(input)?;
 
@@ -462,7 +463,10 @@ fn userid_add(config: Config, command: KeyUseridAddCommand) -> Result<()> {
     Ok(())
 }
 
-fn userid_strip(config: Config, command: KeyUseridStripCommand) -> Result<()> {
+fn userid_strip(
+    config: Config,
+    command: sq_cli::key::UseridStripCommand,
+) -> Result<()> {
     let input = open_or_stdin(command.io.input.as_deref())?;
     let key = Cert::from_reader(input)?;
 
@@ -511,7 +515,7 @@ signatures on other User IDs to make the key valid again.",
     Ok(())
 }
 
-fn adopt(config: Config, command: KeyAdoptCommand) -> Result<()> {
+fn adopt(config: Config, command: sq_cli::key::AdoptCommand) -> Result<()> {
     let input = open_or_stdin(command.certificate.as_deref())?;
     let cert = Cert::from_reader(input)?;
     let mut wanted: Vec<(KeyHandle,
@@ -714,8 +718,10 @@ fn adopt(config: Config, command: KeyAdoptCommand) -> Result<()> {
     Ok(())
 }
 
-fn attest_certifications(config: Config, command: KeyAttestCertificationsCommand)
-                         -> Result<()> {
+fn attest_certifications(
+    config: Config,
+    command: sq_cli::key::AttestCertificationsCommand,
+) -> Result<()> {
     // Attest to all certifications?
     let all = !command.none; // All is the default.
 
diff --git a/sq/src/commands/keyring.rs b/sq/src/commands/keyring.rs
index c707a5e0..88875550 100644
--- a/sq/src/commands/keyring.rs
+++ b/sq/src/commands/keyring.rs
@@ -33,10 +33,10 @@ use crate::{
     output::KeyringListItem,
 };
 
-use crate::sq_cli::keyring::KeyringCommand;
-use crate::sq_cli::keyring::KeyringSubcommands::*;
+use crate::sq_cli::keyring;
 
-pub fn dispatch(config: Config, c: KeyringCommand) -> Result<()> {
+pub fn dispatch(config: Config, c: keyring::Command) -> Result<()> {
+    use crate::sq_cli::keyring::Subcommands::*;
     match c.subcommand {
         Filter(command) => {
             let any_uid_predicates =
diff --git a/sq/src/commands/mod.rs b/sq/src/commands/mod.rs
index d82b2dca..5a82a61f 100644
--- a/sq/src/commands/mod.rs
+++ b/sq/src/commands/mod.rs
@@ -36,9 +36,9 @@ use crate::{
     Config,
 };
 
-use crate::sq_cli::encrypt::EncryptCompressionMode;
-use crate::sq_cli::encrypt::EncryptEncryptionMode;
-use crate::sq_cli::packet::PacketJoinCommand;
+use crate::sq_cli::encrypt::CompressionMode;
+use crate::sq_cli::encrypt::EncryptionMode;
+use crate::sq_cli::packet;
 
 #[cfg(feature = "autocrypt")]
 pub mod autocrypt;
@@ -313,8 +313,8 @@ pub struct EncryptOpts<'a> {
     pub npasswords: usize,
     pub recipients: &'a [openpgp::Cert],
     pub signers: Vec<openpgp::Cert>,
-    pub mode: EncryptEncryptionMode,
-    pub compression: EncryptCompressionMode,
+    pub mode: EncryptionMode,
+    pub compression: CompressionMode,
     pub time: Option<SystemTime>,
     pub use_expired_subkey: bool,
 }
@@ -337,13 +337,13 @@ pub fn encrypt(opts: EncryptOpts) -> Result<()> {
     }
 
     let mode = match opts.mode {
-        EncryptEncryptionMode::Rest => {
+        EncryptionMode::Rest => {
             KeyFlags::empty().set_storage_encryption()
         }
-        EncryptEncryptionMode::Transport => {
+        EncryptionMode::Transport => {
             KeyFlags::empty().set_transport_encryption()
         }
-        EncryptEncryptionMode::All => KeyFlags::empty()
+        EncryptionMode::All => KeyFlags::empty()
             .set_storage_encryption()
             .set_transport_encryption(),
     };
@@ -402,13 +402,13 @@ pub fn encrypt(opts: EncryptOpts) -> Result<()> {
         .context("Failed to create encryptor")?;
 
     match opts.compression {
-        EncryptCompressionMode::None => (),
-        EncryptCompressionMode::Pad => sink = Padder::new(sink).build()?,
-        EncryptCompressionMode::Zip => sink =
+        CompressionMode::None => (),
+        CompressionMode::Pad => sink = Padder::new(sink).build()?,
+        CompressionMode::Zip => sink =
             Compressor::new(sink).algo(CompressionAlgorithm::Zip).build()?,
-        EncryptCompressionMode::Zlib => sink =
+        CompressionMode::Zlib => sink =
             Compressor::new(sink).algo(CompressionAlgorithm::Zlib).build()?,
-        EncryptCompressionMode::Bzip2 => sink =
+        CompressionMode::Bzip2 => sink =
             Compressor::new(sink).algo(CompressionAlgorithm::BZip2).build()?,
     }
 
@@ -683,7 +683,7 @@ pub fn split(input: &mut (dyn io::Read + Sync + Send), prefix: &str)
 }
 
 /// Joins the given files.
-pub fn join(config: Config, c: PacketJoinCommand) -> Result<()> {
+pub fn join(config: Config, c: packet::JoinCommand) -> Result<()> {
     // Either we know what kind of armor we want to produce, or we
     // need to detect it using the first packet we see.
     let kind = c.kind.into();
diff --git a/sq/src/commands/net.rs b/sq/src/commands/net.rs
index 92c939fe..4b5e6b2e 100644
--- a/sq/src/commands/net.rs
+++ b/sq/src/commands/net.rs
@@ -30,12 +30,9 @@ use crate::{
     output::WkdUrlVariant,
 };
 
-use crate::sq_cli::keyserver::KeyserverCommand;
-use crate::sq_cli::keyserver::KeyserverSubcommands;
-use crate::sq_cli::wkd::WkdCommand;
-use crate::sq_cli::wkd::WkdSubcommands;
+use crate::sq_cli;
 
-pub fn dispatch_keyserver(config: Config, c: KeyserverCommand) -> Result<()> {
+pub fn dispatch_keyserver(config: Config, c: sq_cli::keyserver::Command) -> Result<()> {
     let network_policy = c.network_policy.into();
     let mut ks = if let Some(uri) = c.server {
         KeyServer::new(network_policy, &uri)
@@ -48,8 +45,9 @@ pub fn dispatch_keyserver(config: Config, c: KeyserverCommand) -> Result<()> {
         .enable_time()
         .build()?;
 
+    use crate::sq_cli::keyserver::Subcommands::*;
     match c.subcommand {
-         KeyserverSubcommands::Get(c) => {
+         Get(c) => {
             let query = c.query;
 
             let handle = query.parse::<KeyHandle>();
@@ -78,7 +76,7 @@ pub fn dispatch_keyserver(config: Config, c: KeyserverCommand) -> Result<()> {
                      or an email address: {:?}", query));
             }
         },
-        KeyserverSubcommands::Send(c) => {
+        Send(c) => {
             let mut input = open_or_stdin(c.input.as_deref())?;
             let cert = Cert::from_reader(&mut input).
                 context("Malformed key")?;
@@ -91,7 +89,7 @@ pub fn dispatch_keyserver(config: Config, c: KeyserverCommand) -> Result<()> {
     Ok(())
 }
 
-pub fn dispatch_wkd(config: Config, c: WkdCommand) -> Result<()> {
+pub fn dispatch_wkd(config: Config, c: sq_cli::wkd::Command) -> Result<()> {
     let network_policy: net::Policy = c.network_policy.into();
 
     let rt = tokio::runtime::Builder::new_current_thread()
@@ -99,8 +97,9 @@ pub fn dispatch_wkd(config: Config, c: WkdCommand) -> Result<()> {
         .enable_time()
         .build()?;
 
+    use crate::sq_cli::wkd::Subcommands::*;
     match c.subcommand {
-        WkdSubcommands::Url(c) => {
+        Url(c) => {
             let wkd_url = wkd::Url::from(&c.email_address)?;
             let advanced = wkd_url.to_url(None)?.to_string();
             let direct = wkd_url.to_url(wkd::Variant::Direct)?.to_string();
@@ -108,7 +107,7 @@ pub fn dispatch_wkd(config: Config, c: WkdCommand) -> Result<()> {
                                        WkdUrlVariant::Advanced, advanced, direct)?;
             output.write(config.output_format, &mut std::io::stdout())?;
         },
-        WkdSubcommands::DirectUrl(c) => {
+        DirectUrl(c) => {
             let wkd_url = wkd::Url::from(&c.email_address)?;
             let advanced = wkd_url.to_url(None)?.to_string();
             let direct = wkd_url.to_url(wkd::Variant::Direct)?.to_string();
@@ -116,7 +115,7 @@ pub fn dispatch_wkd(config: Config, c: WkdCommand) -> Result<()> {
                                        WkdUrlVariant::Direct, advanced, direct)?;
             output.write(config.output_format, &mut std::io::stdout())?;
         },
-        WkdSubcommands::Get(c) => {
+        Get(c) => {
             // Check that the policy allows https.
             network_policy.assert(net::Policy::Encrypted)?;
 
@@ -138,7 +137,7 @@ pub fn dispatch_wkd(config: Config, c: WkdCommand) -> Result<()> {
                 config.create_or_stdout_safe(c.output.as_deref())?;
             serialize_keyring(&mut output, &certs, c.binary)?;
         },
-        WkdSubcommands::Generate(c) => {
+        Generate(c) => {
             let domain = c.domain;
             let skip = c.skip;
             let f = open_or_stdin(c.input.as_deref())?;
diff --git a/sq/src/commands/revoke.rs b/sq/src/commands/revoke.rs
index dd530025..a4f3bbf3 100644
--- a/sq/src/commands/revoke.rs
+++ b/sq/src/commands/revoke.rs
@@ -44,22 +44,18 @@ impl RevocationTarget {
     }
 }
 
-use crate::sq_cli::revoke::RevokeCommand;
-use crate::sq_cli::revoke::RevokeSubcommands;
-use crate::sq_cli::revoke::RevokeCertificateCommand;
-use crate::sq_cli::revoke::RevokeSubkeyCommand;
-use crate::sq_cli::revoke::RevokeUseridCommand;
+use crate::sq_cli::revoke;
 
-pub fn dispatch(config: Config, c: RevokeCommand) -> Result<()> {
+pub fn dispatch(config: Config, c: revoke::Command) -> Result<()> {
 
     match c.subcommand {
-        RevokeSubcommands::Certificate(c) => revoke_certificate(config, c),
-        RevokeSubcommands::Subkey(c) => revoke_subkey(config, c),
-        RevokeSubcommands::Userid(c) => revoke_userid(config, c),
+        revoke::Subcommands::Certificate(c) => revoke_certificate(config, c),
+        revoke::Subcommands::Subkey(c) => revoke_subkey(config, c),
+        revoke::Subcommands::Userid(c) => revoke_userid(config, c),
     }
 }
 
-pub fn revoke_certificate(config: Config, c: RevokeCertificateCommand) -> Result<()> {
+pub fn revoke_certificate(config: Config, c: revoke::CertificateCommand) -> Result<()> {
     let revocation_target = RevocationTarget::Certificate;
 
     let cert = read_cert(c.input.as_deref())?;
@@ -86,7 +82,7 @@ pub fn revoke_certificate(config: Config, c: RevokeCertificateCommand) -> Result
     Ok(())
 }
 
-pub fn revoke_subkey(config: Config, c: RevokeSubkeyCommand) -> Result<()> {
+pub fn revoke_subkey(config: Config, c: revoke::SubkeyCommand) -> Result<()> {
     let revocation_target = {
         let kh: KeyHandle = c.subkey
             .parse()
@@ -121,7 +117,7 @@ pub fn revoke_subkey(config: Config, c: RevokeSubkeyCommand) -> Result<()> {
     Ok(())
 }
 
-pub fn revoke_userid(config: Config, c: RevokeUseridCommand) -> Result<()> {
+pub fn revoke_userid(config: Config, c: revoke::UseridCommand) -> Result<()> {
     let revocation_target = RevocationTarget::UserID(c.userid);
 
     let cert = read_cert(c.input.as_deref())?;
diff --git a/sq/src/sq.rs b/sq/src/sq.rs
index 48f7fe0b..db0a0c79 100644
--- a/sq/src/sq.rs
+++ b/sq/src/sq.rs
@@ -29,7 +29,7 @@ use crate::openpgp::cert::prelude::*;
 use crate::openpgp::policy::StandardPolicy as P;
 
 use clap::FromArgMatches;
-use crate::sq_cli::packet::PacketSubcommands;
+use crate::sq_cli::packet;
 use sq_cli::SqSubcommands;
 
 mod sq_cli;
@@ -625,7 +625,7 @@ fn main() -> Result<()> {
         },
 
         SqSubcommands::Packet(command) => match command.subcommand {
-            PacketSubcommands::Dump(command) => {
+            packet::Subcommands::Dump(command) => {
                 let mut input = open_or_stdin(command.io.input.as_deref())?;
                 let mut output = config.create_or_stdout_unsafe(
                     command.io.output.as_deref(),
@@ -638,7 +638,7 @@ fn main() -> Result<()> {
                                session_key.as_ref(), width)?;
             },
 
-            PacketSubcommands::Decrypt(command) => {
+            packet::Subcommands::Decrypt(command) => {
                 let mut input = open_or_stdin(command.io.input.as_deref())?;
                 let mut output = config.create_or_stdout_pgp(
                     command.io.output.as_deref(),
@@ -658,7 +658,7 @@ fn main() -> Result<()> {
                 output.finalize()?;
             },
 
-            PacketSubcommands::Split(command) => {
+            packet::Subcommands::Split(command) => {
                 let mut input = open_or_stdin(command.input.as_deref())?;
                 let prefix =
                 // The prefix is either specified explicitly...
@@ -675,7 +675,7 @@ fn main() -> Result<()> {
                             + "-");
                 commands::split(&mut input, &prefix)?;
             },
-            PacketSubcommands::Join(command) => commands::join(config, command)?,
+            packet::Subcommands::Join(command) => commands::join(config, command)?,
         },
 
         SqSubcommands::Keyserver(command) => {
diff --git a/sq/src/sq_cli/armor.rs b/sq/src/sq_cli/armor.rs
index 8df72e6f..096f9b58 100644
--- a/sq/src/sq_cli/armor.rs
+++ b/sq/src/sq_cli/armor.rs
@@ -29,7 +29,7 @@ $ sq armor binary-juliet.pgp
 $ sq armor binary-message.pgp
 "
     )]
-pub struct ArmorCommand {
+pub struct Command {
     #[clap(flatten)]
     pub io: IoArgs,
     #[clap(
diff --git a/sq/src/sq_cli/autocrypt.rs b/sq/src/sq_cli/autocrypt.rs
index 8b37d08f..c6ec1817 100644
--- a/sq/src/sq_cli/autocrypt.rs
+++ b/sq/src/sq_cli/autocrypt.rs
@@ -18,16 +18,16 @@ See https://autocrypt.org/
     subcommand_required = true,
     arg_required_else_help = true
 )]
-pub struct AutocryptCommand {
+pub struct Command {
     #[clap(subcommand)]
-    pub subcommand: AutocryptSubcommands,
+    pub subcommand: Subcommands,
 }
 
 #[derive(Debug, Subcommand)]
-pub enum AutocryptSubcommands {
-    Decode(AutocryptDecodeCommand),
+pub enum Subcommands {
+    Decode(DecodeCommand),
 
-    EncodeSender(AutocryptEncodeSenderCommand),
+    EncodeSender(EncodeSenderCommand),
 }
 
 #[derive(Debug, Args)]
@@ -46,7 +46,7 @@ The converse operation is \"sq autocrypt encode-sender\".
 $ sq autocrypt decode autocrypt.eml
 "
 )]
-pub struct AutocryptDecodeCommand {
+pub struct DecodeCommand {
     #[clap(flatten)]
     pub io: IoArgs,
     #[clap(short = 'B', long, help = "Emits binary data")]
@@ -80,7 +80,7 @@ $ sq autocrypt encode-sender --email juliet@example.org juliet.pgp
 $ sq autocrypt encode-sender --prefer-encrypt mutual juliet.pgp
 "
 )]
-pub struct AutocryptEncodeSenderCommand {
+pub struct EncodeSenderCommand {
     #[clap(flatten)]
     pub io: IoArgs,
     // TODO the help message looks like "primary userid" might be the default
diff --git a/sq/src/sq_cli/certify.rs b/sq/src/sq_cli/certify.rs
index e886d2cf..d00a752e 100644
--- a/sq/src/sq_cli/certify.rs
+++ b/sq/src/sq_cli/certify.rs
@@ -26,7 +26,7 @@ $ sq certify juliet.pgp romeo.pgp \"<romeo@example.org>\"
 ",
 )]
 #[clap(group(ArgGroup::new("expiration-group").args(&["expires", "expires-in"])))]
-pub struct CertifyCommand {
+pub struct Command {
     #[clap(
         short,
         long,
diff --git a/sq/src/sq_cli/dearmor.rs b/sq/src/sq_cli/dearmor.rs
index 704681a0..8222eac7 100644
--- a/sq/src/sq_cli/dearmor.rs
+++ b/sq/src/sq_cli/dearmor.rs
@@ -27,7 +27,7 @@ $ sq dearmor ascii-juliet.pgp
 $ sq dearmor ascii-message.pgp
 ",
     )]
-pub struct DearmorCommand {
+pub struct Command {