Call TPKs Certificates, update identifiers, documentation.

  - Fixes #387.

3 files changed, 100 insertions, 100 deletions

diff --git a/guide/src/chapter_01.md b/guide/src/chapter_01.md
index cc31f3a2..c4f8b7ac 100644
--- a/guide/src/chapter_01.md
+++ b/guide/src/chapter_01.md
@@ -36,21 +36,21 @@ fn main() {
 }
 #
 # /// Generates an signing-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_signing_subkey()
 #         .generate()?;
 #
 #     // Save the revocation certificate somewhere.
 #
-#     Ok(tpk)
+#     Ok(cert)
 # }
 #
 # /// Signs the given message.
-# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
+# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::Cert)
 #            -> openpgp::Result<()> {
-#     // Get the keypair to do the signing from the TPK.
+#     // Get the keypair to do the signing from the Cert.
 #     let key : key::UnspecifiedSecret
 #         = tsk.keys_valid().signing_capable().nth(0).unwrap().2.clone().try_into()?;
 #     let keypair = key.into_keypair()?;
@@ -75,15 +75,15 @@ fn main() {
 # }
 #
 # /// Verifies the given message.
-# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::TPK)
+# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::Cert)
 #           -> openpgp::Result<()> {
 #     // Make a helper that that feeds the sender's public key to the
 #     // verifier.
 #     let helper = Helper {
-#         tpk: sender,
+#         cert: sender,
 #     };
 #
-#     // Now, create a verifier with a helper using the given TPKs.
+#     // Now, create a verifier with a helper using the given Certs.
 #     let mut verifier = Verifier::from_bytes(signed_message, helper, None)?;
 #
 #     // Verify the data.
@@ -93,14 +93,14 @@ fn main() {
 # }
 #
 # struct Helper<'a> {
-#     tpk: &'a openpgp::TPK,
+#     cert: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
-#         Ok(vec![self.tpk.clone()])
+#         Ok(vec![self.cert.clone()])
 #     }
 #
 #     fn check(&mut self, structure: &MessageStructure)
@@ -149,10 +149,10 @@ fn main() {
 # Key generation
 
 First, we need to generate a new key.  This key shall have one user
-id, and one signing-capable subkey.  We use the [`TPKBuilder`] to
+id, and one signing-capable subkey.  We use the [`CertBuilder`] to
 create it:
 
-[`TPKBuilder`]: ../../sequoia_openpgp/tpk/struct.TPKBuilder.html
+[`CertBuilder`]: ../../sequoia_openpgp/cert/struct.CertBuilder.html
 
 ```rust
 # use std::io::{self, Write};
@@ -182,21 +182,21 @@ create it:
 # }
 #
 /// Generates an signing-capable key.
-fn generate() -> openpgp::Result<openpgp::TPK> {
-    let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+fn generate() -> openpgp::Result<openpgp::Cert> {
+    let (cert, _revocation) = openpgp::cert::CertBuilder::new()
         .add_userid("someone@example.org")
         .add_signing_subkey()
         .generate()?;
 
     // Save the revocation certificate somewhere.
 
-    Ok(tpk)
+    Ok(cert)
 }
 #
 # /// Signs the given message.
-# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
+# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::Cert)
 #            -> openpgp::Result<()> {
-#     // Get the keypair to do the signing from the TPK.
+#     // Get the keypair to do the signing from the Cert.
 #     let key : key::UnspecifiedSecret
 #         = tsk.keys_valid().signing_capable().nth(0).unwrap().2.clone().try_into()?;
 #     let keypair = key.into_keypair()?;
@@ -221,15 +221,15 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 # }
 #
 # /// Verifies the given message.
-# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::TPK)
+# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::Cert)
 #           -> openpgp::Result<()> {
 #     // Make a helper that that feeds the sender's public key to the
 #     // verifier.
 #     let helper = Helper {
-#         tpk: sender,
+#         cert: sender,
 #     };
 #
-#     // Now, create a verifier with a helper using the given TPKs.
+#     // Now, create a verifier with a helper using the given Certs.
 #     let mut verifier = Verifier::from_bytes(signed_message, helper, None)?;
 #
 #     // Verify the data.
@@ -239,14 +239,14 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 # }
 #
 # struct Helper<'a> {
-#     tpk: &'a openpgp::TPK,
+#     cert: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
-#         Ok(vec![self.tpk.clone()])
+#         Ok(vec![self.cert.clone()])
 #     }
 #
 #     fn check(&mut self, structure: &MessageStructure)
@@ -328,21 +328,21 @@ implements [`io::Write`], and we simply write the plaintext to it.
 # }
 #
 # /// Generates an signing-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_signing_subkey()
 #         .generate()?;
 #
 #     // Save the revocation certificate somewhere.
 #
-#     Ok(tpk)
+#     Ok(cert)
 # }
 #
 /// Signs the given message.
-fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
+fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::Cert)
            -> openpgp::Result<()> {
-    // Get the keypair to do the signing from the TPK.
+    // Get the keypair to do the signing from the Cert.
     let key : key::UnspecifiedSecret
         = tsk.keys_valid().signing_capable().nth(0).unwrap().2.clone().try_into()?;
     let keypair = key.into_keypair()?;
@@ -367,15 +367,15 @@ fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
 }
 #
 # /// Verifies the given message.
-# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::TPK)
+# fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::Cert)
 #           -> openpgp::Result<()> {
 #     // Make a helper that that feeds the sender's public key to the
 #     // verifier.
 #     let helper = Helper {
-#         tpk: sender,
+#         cert: sender,
 #     };
 #
-#     // Now, create a verifier with a helper using the given TPKs.
+#     // Now, create a verifier with a helper using the given Certs.
 #     let mut verifier = Verifier::from_bytes(signed_message, helper, None)?;
 #
 #     // Verify the data.
@@ -385,14 +385,14 @@ fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
 # }
 #
 # struct Helper<'a> {
-#     tpk: &'a openpgp::TPK,
+#     cert: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
-#         Ok(vec![self.tpk.clone()])
+#         Ok(vec![self.cert.clone()])
 #     }
 #
 #     fn check(&mut self, structure: &MessageStructure)
@@ -485,21 +485,21 @@ Verified data can be read from this using [`io::Read`].
 # }
 # 
 # /// Generates an signing-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_signing_subkey()
 #         .generate()?;
 # 
 #     // Save the revocation certificate somewhere.
 # 
-#     Ok(tpk)
+#     Ok(cert)
 # }
 # 
 # /// Signs the given message.
-# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::TPK)
+# fn sign(sink: &mut Write, plaintext: &str, tsk: &openpgp::Cert)
 #            -> openpgp::Result<()> {
-#     // Get the keypair to do the signing from the TPK.
+#     // Get the keypair to do the signing from the Cert.
 #     let key : key::UnspecifiedSecret
 #         = tsk.keys_valid().signing_capable().nth(0).unwrap().2.clone().try_into()?;
 #     let keypair = key.into_keypair()?;
@@ -524,15 +524,15 @@ Verified data can be read from this using [`io::Read`].
 # }
 # 
 /// Verifies the given message.
-fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::TPK)
+fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::Cert)
           -> openpgp::Result<()> {
     // Make a helper that that feeds the sender's public key to the
     // verifier.
     let helper = Helper {
-        tpk: sender,
+        cert: sender,
     };
 
-    // Now, create a verifier with a helper using the given TPKs.
+    // Now, create a verifier with a helper using the given Certs.
     let mut verifier = Verifier::from_bytes(signed_message, helper, None)?;
 
     // Verify the data.
@@ -542,14 +542,14 @@ fn verify(sink: &mut Write, signed_message: &[u8], sender: &openpgp::TPK)
 }
 
 struct Helper<'a> {
-    tpk: &'a openpgp::TPK,
+    cert: &'a openpgp::Cert,
 }
 
 impl<'a> VerificationHelper for Helper<'a> {
     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-                       -> openpgp::Result<Vec<openpgp::TPK>> {
+                       -> openpgp::Result<Vec<openpgp::Cert>> {
         // Return public keys for signature verification here.
-        Ok(vec![self.tpk.clone()])
+        Ok(vec![self.cert.clone()])
     }
 
     fn check(&mut self, structure: &MessageStructure)
diff --git a/guide/src/chapter_02.md b/guide/src/chapter_02.md
index 7ebf4461..89df3321 100644
--- a/guide/src/chapter_02.md
+++ b/guide/src/chapter_02.md
@@ -35,19 +35,19 @@ fn main() {
 }
 #
 # /// Generates an encryption-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_encryption_subkey()
 #         .generate()?;
 #
 #     // Save the revocation certificate somewhere.
 #
-#     Ok(tpk)
+#     Ok(cert)
 # }
 #
 # /// Encrypts the given message.
-# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
+# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #    // Build a vector of recipients to hand to Encryptor.
 #    let mut recipients =
@@ -83,7 +83,7 @@ fn main() {
 # }
 #
 # /// Decrypts the given message.
-# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
+# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #     // Make a helper that that feeds the recipient's secret key to the
 #     // decryptor.
@@ -91,7 +91,7 @@ fn main() {
 #         secret: recipient,
 #     };
 #
-#     // Now, create a decryptor with a helper using the given TPKs.
+#     // Now, create a decryptor with a helper using the given Certs.
 #     let mut decryptor = Decryptor::from_bytes(ciphertext, helper, None)?;
 #
 #     // Decrypt the data.
@@ -101,12 +101,12 @@ fn main() {
 # }
 #
 # struct Helper<'a> {
-#     secret: &'a openpgp::TPK,
+#     secret: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
 #         Ok(Vec::new())
 #     }
@@ -138,7 +138,7 @@ fn main() {
 #             .and_then(|(algo, session_key)| decrypt(algo, &session_key))
 #             .map(|_| None)
 #         // XXX: In production code, return the Fingerprint of the
-#         // recipient's TPK here
+#         // recipient's Cert here
 #     }
 # }
 ```
@@ -146,10 +146,10 @@ fn main() {
 # Key generation
 
 First, we need to generate a new key.  This key shall have one user
-id, and one encryption-capable subkey.  We use the [`TPKBuilder`] to
+id, and one encryption-capable subkey.  We use the [`CertBuilder`] to
 create it:
 
-[`TPKBuilder`]: ../../sequoia_openpgp/tpk/struct.TPKBuilder.html
+[`CertBuilder`]: ../../sequoia_openpgp/cert/struct.CertBuilder.html
 
 ```rust
 # use std::io::{self, Write};
@@ -178,19 +178,19 @@ create it:
 # }
 #
 /// Generates an encryption-capable key.
-fn generate() -> openpgp::Result<openpgp::TPK> {
-    let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+fn generate() -> openpgp::Result<openpgp::Cert> {
+    let (cert, _revocation) = openpgp::cert::CertBuilder::new()
         .add_userid("someone@example.org")
         .add_encryption_subkey()
         .generate()?;
 
     // Save the revocation certificate somewhere.
 
-    Ok(tpk)
+    Ok(cert)
 }
 #
 # /// Encrypts the given message.
-# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
+# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #    // Build a vector of recipients to hand to Encryptor.
 #    let mut recipients =
@@ -226,7 +226,7 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 # }
 #
 # /// Decrypts the given message.
-# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
+# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #     // Make a helper that that feeds the recipient's secret key to the
 #     // decryptor.
@@ -234,7 +234,7 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 #         secret: recipient,
 #     };
 #
-#     // Now, create a decryptor with a helper using the given TPKs.
+#     // Now, create a decryptor with a helper using the given Certs.
 #     let mut decryptor = Decryptor::from_bytes(ciphertext, helper, None)?;
 #
 #     // Decrypt the data.
@@ -244,12 +244,12 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 # }
 #
 # struct Helper<'a> {
-#     secret: &'a openpgp::TPK,
+#     secret: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
 #         Ok(Vec::new())
 #     }
@@ -281,7 +281,7 @@ fn generate() -> openpgp::Result<openpgp::TPK> {
 #             .and_then(|(algo, session_key)| decrypt(algo, &session_key))
 #             .map(|_| None)
 #         // XXX: In production code, return the Fingerprint of the
-#         // recipient's TPK here
+#         // recipient's Cert here
 #     }
 # }
 ```
@@ -321,19 +321,19 @@ implements [`io::Write`], and we simply write the plaintext to it.
 # }
 #
 # /// Generates an encryption-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_encryption_subkey()
 #         .generate()?;
 #
 #     // Save the revocation certificate somewhere.
 #
-#     Ok(tpk)
+#     Ok(cert)
 # }
 #
 /// Encrypts the given message.
-fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
+fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::Cert)
            -> openpgp::Result<()> {
     // Build a vector of recipients to hand to Encryptor.
     let mut recipients =
@@ -369,7 +369,7 @@ fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
 }
 #
 # /// Decrypts the given message.
-# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
+# fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #     // Make a helper that that feeds the recipient's secret key to the
 #     // decryptor.
@@ -377,7 +377,7 @@ fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
 #         secret: recipient,
 #     };
 #
-#     // Now, create a decryptor with a helper using the given TPKs.
+#     // Now, create a decryptor with a helper using the given Certs.
 #     let mut decryptor = Decryptor::from_bytes(ciphertext, helper, None)?;
 #
 #     // Decrypt the data.
@@ -387,12 +387,12 @@ fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
 # }
 #
 # struct Helper<'a> {
-#     secret: &'a openpgp::TPK,
+#     secret: &'a openpgp::Cert,
 # }
 #
 # impl<'a> VerificationHelper for Helper<'a> {
 #     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-#                        -> openpgp::Result<Vec<openpgp::TPK>> {
+#                        -> openpgp::Result<Vec<openpgp::Cert>> {
 #         // Return public keys for signature verification here.
 #         Ok(Vec::new())
 #     }
@@ -424,7 +424,7 @@ fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
 #             .and_then(|(algo, session_key)| decrypt(algo, &session_key))
 #             .map(|_| None)
 #         // XXX: In production code, return the Fingerprint of the
-#         // recipient's TPK here
+#         // recipient's Cert here
 #     }
 # }
 ```
@@ -478,19 +478,19 @@ Decrypted data can be read from this using [`io::Read`].
 # }
 #
 # /// Generates an encryption-capable key.
-# fn generate() -> openpgp::Result<openpgp::TPK> {
-#     let (tpk, _revocation) = openpgp::tpk::TPKBuilder::new()
+# fn generate() -> openpgp::Result<openpgp::Cert> {
+#     let (cert, _revocation) = openpgp::cert::CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_encryption_subkey()
 #         .generate()?;
 #
 #     // Save the revocation certificate somewhere.
 #
-#     Ok(tpk)
+#     Ok(cert)
 # }
 #
 # /// Encrypts the given message.
-# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::TPK)
+# fn encrypt(sink: &mut Write, plaintext: &str, recipient: &openpgp::Cert)
 #            -> openpgp::Result<()> {
 #    // Build a vector of recipients to hand to Encryptor.
 #    let mut recipients =
@@ -526,7 +526,7 @@ Decrypted data can be read from this using [`io::Read`].
 # }
 #
 /// Decrypts the given message.
-fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
+fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::Cert)
            -> openpgp::Result<()> {
     // Make a helper that that feeds the recipient's secret key to the
     // decryptor.
@@ -534,7 +534,7 @@ fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
         secret: recipient,
     };
 
-    // Now, create a decryptor with a helper using the given TPKs.
+    // Now, create a decryptor with a helper using the given Certs.
     let mut decryptor = Decryptor::from_bytes(ciphertext, helper, None)?;
 
     // Decrypt the data.
@@ -544,12 +544,12 @@ fn decrypt(sink: &mut Write, ciphertext: &[u8], recipient: &openpgp::TPK)
 }
 
 struct Helper<'a> {
-    secret: &'a openpgp::TPK,
+    secret: &'a openpgp::Cert,
 }
 
 impl<'a> VerificationHelper for Helper<'a> {
     fn get_public_keys(&mut self, _ids: &[openpgp::KeyHandle])
-                       -> openpgp::Result<Vec<openpgp::TPK>> {
+                       -> openpgp::Result<Vec<openpgp::Cert>> {
         // Return public keys for signature verification here.
         Ok(Vec::new())
     }
@@ -581,7 +581,7 @@ impl<'a> DecryptionHelper for Helper<'a> {
             .and_then(|(algo, session_key)| decrypt(algo, &session_key))
             .map(|_| None)
         // XXX: In production code, return the Fingerprint of the
-        // recipient's TPK here
+        // recipient's Cert here
     }
 }
 ```
diff --git a/guide/src/chapter_03.md b/guide/src/chapter_03.md
index 0d8e9996..b46fc5d7 100644
--- a/guide/src/chapter_03.md
+++ b/guide/src/chapter_03.md
@@ -2,18 +2,18 @@ Describes how to use some of Sequoia's parsers.
 
 Sequoia contains and exposes several parsers.  In this chapter, we
 will cover some of them, starting from a high level parser, the
-[`TPKParser`] that parses transferable public keys ([`TPK`]s), all
+[`CertParser`] that parses OpenPGP Certificates ([`Cert`]s), all
 down to the actual OpenPGP [`PacketParser`].
 
-[`TPKParser`]: ../../sequoia_openpgp/tpk/struct.TPKParser.html
-[`TPK`]: ../../sequoia_openpgp/struct.TPK.html
+[`CertParser`]: ../../sequoia_openpgp/cert/struct.CertParser.html
+[`Cert`]: ../../sequoia_openpgp/struct.Cert.html
 [`PacketParser`]: ../../sequoia_openpgp/parse/struct.PacketParser.html
 
-# Parsing TPKs
+# Parsing Certs
 
 First, we will start with a string that presumably contains a
-transferable public key, and feed it into the [`TPKParser`].  On
-success, we can use or examine the resulting [`TPK`]:
+OpenPGP Certificate, and feed it into the [`CertParser`].  On
+success, we can use or examine the resulting [`Cert`]:
 
 ```rust
 extern crate sequoia_openpgp as openpgp;
@@ -41,21 +41,21 @@ const KEY: &str =
      -----END PGP PUBLIC KEY BLOCK-----";
 
 fn main() {
-    let tpk = openpgp::TPK::from_bytes(KEY.as_bytes()).unwrap();
+    let cert = openpgp::Cert::from_bytes(KEY.as_bytes()).unwrap();
 
-    assert_eq!(tpk.fingerprint().to_string(),
+    assert_eq!(cert.fingerprint().to_string(),
                "C087 4478 A65C 540A 1F73  72B4 A22E AD61 4D11 744A");
 
     // Iterate over UserIDs.
-    assert_eq!(tpk.userids().count(), 1);
-    assert_eq!(tpk.userids().nth(0).unwrap().userid(),
+    assert_eq!(cert.userids().count(), 1);
+    assert_eq!(cert.userids().nth(0).unwrap().userid(),
                &"Ἀριστοτέλης".into());
 
     // Iterate over subkeys.
-    assert_eq!(tpk.subkeys().count(), 2);
-    assert_eq!(tpk.subkeys().nth(0).unwrap().key().fingerprint().to_string(),
+    assert_eq!(cert.subkeys().count(), 2);
+    assert_eq!(cert.subkeys().nth(0).unwrap().key().fingerprint().to_string(),
                "67A4 8753 A380 A6B3 B7DF  7DC5 E6C6 897A 4CEF 8924");
-    assert_eq!(tpk.subkeys().nth(1).unwrap().key().fingerprint().to_string(),
+    assert_eq!(cert.subkeys().nth(1).unwrap().key().fingerprint().to_string(),
                "185C DAA1 2723 0423 19E4  7F67 108F 2CAF 9034 356D");
 }
 ```
@@ -96,13 +96,13 @@ fn main() {
 
 [`PacketPile`]s are unstructured sequences of OpenPGP packets.  Packet
 piles can be inspected, manipulated, validated using a formal grammar
-and thereby turned into [`Message`]s or [`TPK`]s using
-[`Message::from_packet_pile`] or [`TPK::from_packet_pile`], or just
+and thereby turned into [`Message`]s or [`Cert`]s using
+[`Message::from_packet_pile`] or [`Cert::from_packet_pile`], or just
 turned into a vector of [`Packet`]s:
 
 [`PacketPile`]: ../../sequoia_openpgp/struct.PacketPile.html
 [`Packet`]: ../../sequoia_openpgp/enum.Packet.html
-[`TPK::from_packet_pile`]: ../../sequoia_openpgp/struct.TPK.html#method.from_packet_pile
+[`Cert::from_packet_pile`]: ../../sequoia_openpgp/struct.Cert.html#method.from_packet_pile
 [`Message::from_packet_pile`]: ../../sequoia_openpgp/struct.Message.html#method.from_packet_pile
 
 ```rust