diff --git a/src/chat.rs b/src/chat.rs
index a21bdb78d..01e324a10 100644
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -842,7 +842,13 @@ impl Chat {
             /* check if we want to encrypt this message.  If yes and circumstances change
             so that E2EE is no longer available at a later point (reset, changed settings),
             we might not send the message out at all */
-            if msg.param.get_int(Param::ForcePlaintext).unwrap_or_default() == 0 {
+            if msg
+                .param
+                .get_int(Param::ForcePlaintext)
+                .and_then::<ForcePlaintext, _>(num_traits::FromPrimitive::from_i32)
+                .unwrap_or_default()
+                == ForcePlaintext::Dont
+            {
                 let mut can_encrypt = true;
                 let mut all_mutual = context.get_config_bool(Config::E2eeEnabled).await;
 
diff --git a/src/mimefactory.rs b/src/mimefactory.rs
index 5d9304612..0e807f6f8 100644
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -237,13 +237,14 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                     return true;
                 }
 
-                let force_plaintext = self
+                let force_plaintext: ForcePlaintext = self
                     .msg
                     .param
                     .get_int(Param::ForcePlaintext)
+                    .and_then(num_traits::FromPrimitive::from_i32)
                     .unwrap_or_default();
 
-                if force_plaintext == 0 {
+                if force_plaintext == ForcePlaintext::Dont {
                     return self
                         .msg
                         .param
@@ -271,19 +272,20 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         }
     }
 
-    fn should_force_plaintext(&self) -> i32 {
+    fn should_force_plaintext(&self) -> ForcePlaintext {
         match &self.loaded {
             Loaded::Message { chat } => {
                 if chat.typ == Chattype::VerifiedGroup {
-                    0
+                    ForcePlaintext::Dont
                 } else {
                     self.msg
                         .param
                         .get_int(Param::ForcePlaintext)
+                        .and_then(num_traits::FromPrimitive::from_i32)
                         .unwrap_or_default()
                 }
             }
-            Loaded::MDN { .. } => ForcePlaintext::NoAutocryptHeader as i32,
+            Loaded::MDN { .. } => ForcePlaintext::NoAutocryptHeader,
         }
     }
 
@@ -499,7 +501,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
             Loaded::MDN { .. } => self.render_mdn().await?,
         };
 
-        if force_plaintext != ForcePlaintext::NoAutocryptHeader as i32 {
+        if force_plaintext != ForcePlaintext::NoAutocryptHeader {
             // unless determined otherwise we add the Autocrypt header
             let aheader = encrypt_helper.get_aheader().to_string();
             unprotected_headers.push(Header::new("Autocrypt".into(), aheader));
@@ -510,7 +512,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
         let peerstates = self.peerstates_for_recipients().await?;
         let should_encrypt =
             encrypt_helper.should_encrypt(self.context, e2ee_guaranteed, &peerstates)?;
-        let is_encrypted = should_encrypt && force_plaintext == 0;
+        let is_encrypted = should_encrypt && force_plaintext == ForcePlaintext::Dont;
 
         let rfc724_mid = match self.loaded {
             Loaded::Message { .. } => self.msg.rfc724_mid.clone(),
diff --git a/src/param.rs b/src/param.rs
index bb32af3de..8dacb0403 100644
--- a/src/param.rs
+++ b/src/param.rs
@@ -40,8 +40,7 @@ pub enum Param {
     /// 'c' nor 'e' are preset, the messages is only transport encrypted.
     ErroneousE2ee = b'e',
 
-    /// For Messages: force unencrypted message, either `ForcePlaintext::AddAutocryptHeader` (1),
-    /// `ForcePlaintext::NoAutocryptHeader` (2) or 0.
+    /// For Messages: force unencrypted message, a value from `ForcePlaintext` enum.
     ForcePlaintext = b'u',
 
     /// For Messages
@@ -132,10 +131,28 @@ pub enum Param {
 #[derive(PartialEq, Eq, Debug, Clone, Copy, FromPrimitive)]
 #[repr(u8)]
 pub enum ForcePlaintext {
+    /// Do not force plaintext
+    Dont = 0,
+
+    /// Force plaintext message with Autocrypt header
+    ///
+    /// Used for `vc-request` and `vg-request` messages in
+    /// Verified Contact Protocol and
+    /// Verified Group Protocol.
     AddAutocryptHeader = 1,
+
+    /// Force plaintext message without Autocrypt header
+    ///
+    /// Used for MDNs.
     NoAutocryptHeader = 2,
 }
 
+impl Default for ForcePlaintext {
+    fn default() -> Self {
+        Self::Dont
+    }
+}
+
 /// An object for handling key=value parameter lists.
 ///
 /// The structure is serialized by calling `to_string()` on it.