diff --git a/stun-agent/README.md b/stun-agent/README.md
index 47bc1d9..7fa93c6 100644
--- a/stun-agent/README.md
+++ b/stun-agent/README.md
@@ -65,7 +65,7 @@ implementation could have been realized as follows:
 
 ```rust
 fn handle_data(in_bytes: &[u8])
--> Result<Vec<StuntClientEvent>, (StunAgentError, Vec<StuntClientEvent>)> {
+-> Result<Vec<StunClientEvent>, (StunAgentError, Vec<StunClientEvent>)> {
 // Implementation
 }
 ```
@@ -195,7 +195,7 @@ assert_eq!(events.len(), 1);
 let mut iter = events.iter();
 
 // Next event already contains the buffer that needs to be send to the server.
-let StuntClientEvent::OutputPacket(buffer) = iter
+let StunClientEvent::OutputPacket(buffer) = iter
     .next()
     .expect("Expected event")
 else {
@@ -227,7 +227,7 @@ let events = client.events();
 assert_eq!(events.len(), 2);
 let mut iter = events.iter();
 // Next event already contains the buffer that needs to be send to the server.
-let StuntClientEvent::OutputPacket(buffer) = iter
+let StunClientEvent::OutputPacket(buffer) = iter
     .next()
     .expect("Expected event")
 else {
@@ -235,7 +235,7 @@ else {
 };
 // Next event indicates that the user must set a timeout for the transaction
 // identified by the transaction_id.
-let StuntClientEvent::RestransmissionTimeOut((id, duration)) = iter
+let StunClientEvent::RestransmissionTimeOut((id, duration)) = iter
     .next()
     .expect("Expected event")
 else {
@@ -260,13 +260,13 @@ assert_eq!(events.len(), 2);
 let mut iter = events.iter();
 
 // Next event contains the buffer that needs to be retransmitted.
-let StuntClientEvent::OutputPacket(buffer) = iter
+let StunClientEvent::OutputPacket(buffer) = iter
     .next()
     .expect("Expected event")
 else {
         panic!("Expected OutputBuffer event");
 };
-let StuntClientEvent::RestransmissionTimeOut((id, duration)) = iter
+let StunClientEvent::RestransmissionTimeOut((id, duration)) = iter
     .next()
     .expect("Expected event")
 else {
@@ -305,7 +305,7 @@ the client to generate events that can be pulled by the controller.
  assert_eq!(events.len(), 1);
 
  let mut iter = events.iter();
- let StuntClientEvent::StunMessageReceived(msg) = iter
+ let StunClientEvent::StunMessageReceived(msg) = iter
      .next()
      .expect("Expected event")
  else {
diff --git a/stun-agent/src/client.rs b/stun-agent/src/client.rs
index 12b42ec..4b4a1d2 100644
--- a/stun-agent/src/client.rs
+++ b/stun-agent/src/client.rs
@@ -1,4 +1,4 @@
-use crate::events::{StunTransactionError, StuntClientEvent, TransactionEventHandler};
+use crate::events::{StunClientEvent, StunTransactionError, TransactionEventHandler};
 use crate::fingerprint::{add_fingerprint_attribute, validate_fingerprint};
 use crate::integrity::IntegrityError;
 use crate::lt_cred_mech::LongTermCredentialClient;
@@ -279,8 +279,8 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// timers, or additional events. This foundational concept is illustrated in the following API:
 ///
 /// ```no_run
-/// # use stun_agent::StuntClientEvent;
-/// # fn handle_data(in_bytes: &[u8]) -> Vec<StuntClientEvent> { vec![] }
+/// # use stun_agent::StunClientEvent;
+/// # fn handle_data(in_bytes: &[u8]) -> Vec<StunClientEvent> { vec![] }
 /// # fn perform_action() -> Vec<u8> { vec![] }
 /// # let in_bytes = [];
 /// let events = handle_data(&in_bytes);
@@ -293,10 +293,10 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// generate further events for the controller. This implementation could have been realized as follows:
 ///
 /// ```no_run
-/// # use stun_agent::StuntClientEvent;
+/// # use stun_agent::StunClientEvent;
 /// # use stun_agent::StunAgentError;
 /// fn handle_data(in_bytes: &[u8])
-///     -> Result<Vec<StuntClientEvent>, (StunAgentError, Vec<StuntClientEvent>)> {
+///     -> Result<Vec<StunClientEvent>, (StunAgentError, Vec<StunClientEvent>)> {
 ///    // Implementation
 /// #   Ok(vec![])
 /// }
@@ -308,10 +308,10 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// success outcomes and the errors and resulting events in case of failure:
 ///
 /// ```no_run
-/// # use stun_agent::StuntClientEvent;
+/// # use stun_agent::StunClientEvent;
 /// # use stun_agent::StunAgentError;
-/// # fn handle_data(in_bytes: &[u8]) -> Result<Vec<StuntClientEvent>, (StunAgentError, Vec<StuntClientEvent>)> { Ok(vec![]) }
-/// # fn handle_events(events: Vec<StuntClientEvent>) {}
+/// # fn handle_data(in_bytes: &[u8]) -> Result<Vec<StunClientEvent>, (StunAgentError, Vec<StunClientEvent>)> { Ok(vec![]) }
+/// # fn handle_events(events: Vec<StunClientEvent>) {}
 /// # fn handle_error(error: StunAgentError) {}
 /// # let in_bytes = [];
 /// let response = handle_data(&in_bytes);
@@ -398,7 +398,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// is not received within the designated timeout period, the client generates a timeout event, marking
 /// the transaction as failed. Timeouts are also employed to manage re-transmissions of requests sent
 /// over unreliable transports. When the client needs to set a timeout for a re-transmission, it generates
-/// a [`RestransmissionTimeOut`](`crate::StuntClientEvent::RestransmissionTimeOut`) event, which is then
+/// a [`RestransmissionTimeOut`](`crate::StunClientEvent::RestransmissionTimeOut`) event, which is then
 /// notified to the controller when the events are pulled.
 ///
 /// If multiple timeouts are scheduled, the client will only notify the controller of the most recent
@@ -420,7 +420,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// BINDING indication to a STUN server.
 ///
 /// ```rust
-/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StuntClientEvent, TransportReliability};
+/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StunClientEvent, TransportReliability};
 /// # use stun_rs::methods::BINDING;
 /// # use std::time::Instant;
 ///
@@ -462,7 +462,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// let mut iter = events.iter();
 ///
 /// // Next event already contains the buffer that needs to be send to the server.
-/// let StuntClientEvent::OutputPacket(buffer) = iter
+/// let StunClientEvent::OutputPacket(buffer) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
@@ -475,7 +475,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// The response must arrive before the timeout is reached, otherwise the client will generate a timeout event
 /// and will mark the transaction as failed.
 /// ```rust
-/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StuntClientEvent, TransportReliability};
+/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StunClientEvent, TransportReliability};
 /// # use stun_rs::methods::BINDING;
 /// # use std::time::Instant;
 /// # let mut client = StunClienteBuilder::new(TransportReliability::Unreliable(RttConfig::default()))
@@ -499,7 +499,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// assert_eq!(events.len(), 2);
 /// let mut iter = events.iter();
 /// // Next event already contains the buffer that needs to be send to the server.
-/// let StuntClientEvent::OutputPacket(buffer) = iter
+/// let StunClientEvent::OutputPacket(buffer) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
@@ -507,7 +507,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// };
 /// // Next event indicates that the user must set a timeout for the transaction
 /// // identified by the transaction_id.
-/// let StuntClientEvent::RestransmissionTimeOut((id, duration)) = iter
+/// let StunClientEvent::RestransmissionTimeOut((id, duration)) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
@@ -532,13 +532,13 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// let mut iter = events.iter();
 ///
 /// // Next event contains the buffer that needs to be retransmitted.
-/// let StuntClientEvent::OutputPacket(buffer) = iter
+/// let StunClientEvent::OutputPacket(buffer) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
 ///         panic!("Expected OutputBuffer event");
 /// };
-/// let StuntClientEvent::RestransmissionTimeOut((id, duration)) = iter
+/// let StunClientEvent::RestransmissionTimeOut((id, duration)) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
@@ -553,14 +553,14 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// not set a different value, the default timeout is 39500 ms for both, reliable and not
 /// reliable transports. If the client has not received a response after that time, the client
 /// will consider the transaction to have timed out, and an event of type
-/// [`TransactionFailed`](crate::StuntClientEvent::TransactionFailed) will be generated the
+/// [`TransactionFailed`](crate::StunClientEvent::TransactionFailed) will be generated the
 /// next time that events were pulled with the error
 /// [`TimedOut`](crate::StunTransactionError::TimedOut) for the transaction.
 ///
 /// To finish, the next example shows how to handle buffers received from the server. Raw buffers will
 /// be processed by the client to generate events that can be pulled by the controller.
 ///```rust
-/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StuntClientEvent, TransportReliability};
+/// # use stun_agent::{RttConfig, StunAttributes, StunClienteBuilder, StunClientEvent, TransportReliability};
 /// # use stun_rs::methods::BINDING;
 /// # use std::time::Instant;
 /// # use stun_rs::MessageClass::Indication;
@@ -585,7 +585,7 @@ impl From<TransportReliability> for StunRttCalcuator {
 /// assert_eq!(events.len(), 1);
 ///
 /// let mut iter = events.iter();
-/// let StuntClientEvent::StunMessageReceived(msg) = iter
+/// let StunClientEvent::StunMessageReceived(msg) = iter
 ///     .next()
 ///     .expect("Expected event")
 /// else {
@@ -774,11 +774,11 @@ impl StunClient {
         self.transactions.insert(*msg.transaction_id(), transaction);
 
         let mut events = self.transaction_events.init();
-        events.push(StuntClientEvent::OutputPacket(packet));
+        events.push(StunClientEvent::OutputPacket(packet));
 
         // Add the most recent timout event if any
         if let Some((id, left)) = self.timeouts.next_timeout(instant) {
-            events.push(StuntClientEvent::RestransmissionTimeOut((id, left)));
+            events.push(StunClientEvent::RestransmissionTimeOut((id, left)));
         }
 
         Ok(*msg.transaction_id())
@@ -810,7 +810,7 @@ impl StunClient {
         })?;
 
         let mut events = self.transaction_events.init();
-        events.push(StuntClientEvent::OutputPacket(packet));
+        events.push(StunClientEvent::OutputPacket(packet));
 
         Ok(*msg.transaction_id())
     }
@@ -893,7 +893,7 @@ impl StunClient {
             }
             None => {
                 // Notify the user about the received message
-                events.push(StuntClientEvent::StunMessageReceived(msg));
+                events.push(StunClientEvent::StunMessageReceived(msg));
             }
         }
 
@@ -921,19 +921,19 @@ impl StunClient {
                         transaction.instant = None;
                         self.timeouts.add(instant, rto, transaction_id);
                         debug!("set timeout {:?} for transaction {:?}", rto, transaction_id);
-                        events.push(StuntClientEvent::OutputPacket(transaction.packet.clone()));
+                        events.push(StunClientEvent::OutputPacket(transaction.packet.clone()));
                     }
                     None => {
                         let protection_violated = self.mechanism.as_mut().is_some_and(|m| {
                             m.signal_protection_violated_on_timeout(&transaction_id)
                         });
                         let event = if protection_violated {
-                            StuntClientEvent::TransactionFailed((
+                            StunClientEvent::TransactionFailed((
                                 transaction_id,
                                 StunTransactionError::ProtectionViolated,
                             ))
                         } else {
-                            StuntClientEvent::TransactionFailed((
+                            StunClientEvent::TransactionFailed((
                                 transaction_id,
                                 StunTransactionError::TimedOut,
                             ))
@@ -952,7 +952,7 @@ impl StunClient {
 
         // Add the most recent timout event if any
         if let Some((id, left)) = self.timeouts.next_timeout(instant) {
-            events.push(StuntClientEvent::RestransmissionTimeOut((id, left)));
+            events.push(StunClientEvent::RestransmissionTimeOut((id, left)));
         }
     }
 
@@ -963,7 +963,7 @@ impl StunClient {
     /// Therefore, the user should call this method to retrieve the events as
     /// soon as an operation is completed. Otherwise, the events may be lost
     /// if a new operation is performed.
-    pub fn events(&mut self) -> Vec<StuntClientEvent> {
+    pub fn events(&mut self) -> Vec<StunClientEvent> {
         self.transaction_events.events()
     }
 }
@@ -971,14 +971,14 @@ impl StunClient {
 fn process_integrity_error(
     error: IntegrityError,
     transaction_id: &TransactionId,
-) -> Result<Option<StuntClientEvent>, StunAgentError> {
+) -> Result<Option<StunClientEvent>, StunAgentError> {
     match error {
-        IntegrityError::ProtectionViolated => Ok(Some(StuntClientEvent::TransactionFailed((
+        IntegrityError::ProtectionViolated => Ok(Some(StunClientEvent::TransactionFailed((
             *transaction_id,
             StunTransactionError::ProtectionViolated,
         )))),
-        IntegrityError::Retry => Ok(Some(StuntClientEvent::Retry(*transaction_id))),
-        IntegrityError::NotRetryable => Ok(Some(StuntClientEvent::TransactionFailed((
+        IntegrityError::Retry => Ok(Some(StunClientEvent::Retry(*transaction_id))),
+        IntegrityError::NotRetryable => Ok(Some(StunClientEvent::TransactionFailed((
             *transaction_id,
             StunTransactionError::DoNotRetry,
         )))),
diff --git a/stun-agent/src/events.rs b/stun-agent/src/events.rs
index 3b53505..f09b8d4 100644
--- a/stun-agent/src/events.rs
+++ b/stun-agent/src/events.rs
@@ -5,7 +5,7 @@ use stun_rs::{StunMessage, TransactionId};
 
 /// Stun client events
 #[derive(Debug)]
-pub enum StuntClientEvent {
+pub enum StunClientEvent {
     /// Notification used by the STUN client to send a STUN packet to the server
     OutputPacket(StunPacket),
     /// This event sets a timeout for a transaction identified by the [`TransactionId`].
@@ -40,7 +40,7 @@ pub enum StunTransactionError {
 
 #[derive(Debug, Default)]
 pub struct TransactionEventHandler {
-    events: Vec<StuntClientEvent>,
+    events: Vec<StunClientEvent>,
 }
 
 impl TransactionEventHandler {
@@ -51,7 +51,7 @@ impl TransactionEventHandler {
         }
     }
 
-    pub fn events(&mut self) -> Vec<StuntClientEvent> {
+    pub fn events(&mut self) -> Vec<StunClientEvent> {
         std::mem::take(&mut self.events)
     }
 }
@@ -59,11 +59,11 @@ impl TransactionEventHandler {
 #[derive(Debug)]
 pub struct TransactionEvents<'a> {
     handler: &'a mut TransactionEventHandler,
-    events: Vec<StuntClientEvent>,
+    events: Vec<StunClientEvent>,
 }
 
 impl TransactionEvents<'_> {
-    pub fn push(&mut self, event: StuntClientEvent) {
+    pub fn push(&mut self, event: StunClientEvent) {
         self.events.push(event);
     }
 }
@@ -108,8 +108,8 @@ mod stun_event_tests {
         {
             let mut events = handler.init();
 
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
         }
 
         // Drop the events must commit the events
@@ -141,16 +141,16 @@ mod stun_event_tests {
         let mut handler = TransactionEventHandler::default();
         {
             let mut events = handler.init();
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
         }
 
         {
             // Init another transaction when there must be one event
             // that was not consumed previously, that event will be dropped
             let mut events = handler.init();
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
-            events.push(StuntClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
+            events.push(StunClientEvent::Retry(TransactionId::default()));
         }
 
         // There must be only three events
diff --git a/stun-agent/src/lib.rs b/stun-agent/src/lib.rs
index 110665b..aa8054c 100644
--- a/stun-agent/src/lib.rs
+++ b/stun-agent/src/lib.rs
@@ -42,7 +42,7 @@ pub use crate::client::StunClient;
 pub use crate::client::StunClienteBuilder;
 pub use crate::client::TransportReliability;
 pub use crate::events::StunTransactionError;
-pub use crate::events::StuntClientEvent;
+pub use crate::events::StunClientEvent;
 pub use crate::message::StunAttributes;
 
 /// Describes the error that can occur during the STUN agent operation.
diff --git a/stun-agent/tests/stun_client.rs b/stun-agent/tests/stun_client.rs
index 686a6a2..4841a1d 100644
--- a/stun-agent/tests/stun_client.rs
+++ b/stun-agent/tests/stun_client.rs
@@ -1,7 +1,7 @@
 use std::time::{Duration, Instant};
 use stun_agent::{
     CredentialMechanism, RttConfig, StunAgentError, StunAttributes, StunClient, StunClienteBuilder,
-    StuntClientEvent, TransportReliability,
+    StunClientEvent, TransportReliability,
 };
 use stun_rs::attributes::stun::Software;
 use stun_rs::methods::BINDING;
@@ -92,11 +92,11 @@ fn test_stun_client_send_request() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -171,10 +171,10 @@ fn test_stun_client_allow_send_request_after_max_request_error() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -228,7 +228,7 @@ fn test_stun_client_send_indication() {
         .expect("Failed to send indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     // No more events
@@ -281,7 +281,7 @@ fn test_stun_client_send_indications_after_send_max_requests() {
     assert_eq!(events.len(), 1);
 
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     // No more events
@@ -364,7 +364,7 @@ fn test_stun_client_recv_indication() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(msg.method(), BINDING);
@@ -410,10 +410,10 @@ fn test_stun_client_transaction_finished_sucess_response() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -434,7 +434,7 @@ fn test_stun_client_transaction_finished_sucess_response() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected TransactionFinished event");
     };
     // No more events
diff --git a/stun-agent/tests/stun_client_fingerprint.rs b/stun-agent/tests/stun_client_fingerprint.rs
index 62febd4..71b48a0 100644
--- a/stun-agent/tests/stun_client_fingerprint.rs
+++ b/stun-agent/tests/stun_client_fingerprint.rs
@@ -1,5 +1,5 @@
 use stun_agent::{
-    RttConfig, StunAgentError, StunAttributes, StunClient, StunClienteBuilder, StuntClientEvent,
+    RttConfig, StunAgentError, StunAttributes, StunClient, StunClienteBuilder, StunClientEvent,
     TransportReliability,
 };
 use stun_rs::{
@@ -24,7 +24,7 @@ fn check_fingerprint_paramaters(
 ) {
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let decoder = MessageDecoderBuilder::default().build();
@@ -39,7 +39,7 @@ fn check_fingerprint_paramaters(
     assert_eq!(transaction_id, msg.transaction_id());
 
     if class == MessageClass::Request {
-        let StuntClientEvent::RestransmissionTimeOut((id, _)) =
+        let StunClientEvent::RestransmissionTimeOut((id, _)) =
             iter.next().expect("Expected event")
         else {
             panic!("Expected RestransmissionTimeOut event");
diff --git a/stun-agent/tests/stun_client_lt_cred_mech.rs b/stun-agent/tests/stun_client_lt_cred_mech.rs
index e008678..874f25a 100644
--- a/stun-agent/tests/stun_client_lt_cred_mech.rs
+++ b/stun-agent/tests/stun_client_lt_cred_mech.rs
@@ -3,7 +3,7 @@ use std::slice::Iter;
 use std::time::Duration;
 use stun_agent::{
     CredentialMechanism, Integrity, RttConfig, StunAgentError, StunAttributes, StunClient,
-    StunClienteBuilder, StunTransactionError, StuntClientEvent, TransportReliability,
+    StunClienteBuilder, StunTransactionError, StunClientEvent, TransportReliability,
 };
 use stun_rs::attributes::stun::nonce_cookie::StunSecurityFeatures;
 use stun_rs::attributes::stun::{
@@ -130,7 +130,7 @@ fn create_decoder(key: Option<HMACKey>) -> MessageDecoder {
 fn check_first_request(client: &mut StunClient, transaction_id: &TransactionId) {
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let decoder = create_decoder(None);
@@ -139,7 +139,7 @@ fn check_first_request(client: &mut StunClient, transaction_id: &TransactionId)
     assert!(msg.attributes().is_empty());
 
     assert_eq!(transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -225,7 +225,7 @@ fn check_request_from_unauthenticated_error(
 ) {
     let events = client.events();
     let mut events_iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let decoder = create_decoder(None);
@@ -238,7 +238,7 @@ fn check_request_from_unauthenticated_error(
     assert!(attr_iter.next().is_none());
 
     assert_eq!(transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) =
+    let StunClientEvent::RestransmissionTimeOut((id, _)) =
         events_iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -266,7 +266,7 @@ fn check_request_from_stale_nonce_error(
 ) {
     let events = client.events();
     let mut events_iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let decoder = create_decoder(None);
@@ -287,7 +287,7 @@ fn check_request_from_stale_nonce_error(
     }
 
     assert_eq!(transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) =
+    let StunClientEvent::RestransmissionTimeOut((id, _)) =
         events_iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -316,7 +316,7 @@ fn check_subsequent_request(
 ) {
     let events = client.events();
     let mut events_iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = events_iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let decoder = create_decoder(None);
@@ -339,7 +339,7 @@ fn check_subsequent_request(
     assert!(attr_iter.next().is_none());
 
     assert_eq!(transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) =
+    let StunClientEvent::RestransmissionTimeOut((id, _)) =
         events_iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -536,7 +536,7 @@ fn test_stun_client_authenticate_unreliable() {
         .expect("Failed to receive buffer");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::Retry(id) = iter.next().expect("Expected event") else {
+    let StunClientEvent::Retry(id) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(&transaction_id, id);
@@ -569,7 +569,7 @@ fn test_stun_client_authenticate_unreliable() {
 
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(&transaction_id, msg.transaction_id());
@@ -618,7 +618,7 @@ fn test_stun_client_stale_nonce_unreliable() {
         .expect("Failed to receive buffer");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::Retry(id) = iter.next().expect("Expected event") else {
+    let StunClientEvent::Retry(id) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(&transaction_id, id);
@@ -647,7 +647,7 @@ fn test_stun_client_stale_nonce_unreliable() {
         .expect("Failed to receive buffer");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::Retry(id) = iter.next().expect("Expected event") else {
+    let StunClientEvent::Retry(id) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(&transaction_id, id);
@@ -688,7 +688,7 @@ fn test_timeout(reliability: TransportReliability) {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -734,7 +734,7 @@ fn test_stun_client_protection_violated() {
         .expect("Failed to receive buffer");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::Retry(id) = iter.next().expect("Expected event") else {
+    let StunClientEvent::Retry(id) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     assert_eq!(&transaction_id, id);
@@ -778,7 +778,7 @@ fn test_stun_client_protection_violated() {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -816,7 +816,7 @@ fn test_stun_client_not_retryable_error() {
 
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
diff --git a/stun-agent/tests/stun_client_rtos.rs b/stun-agent/tests/stun_client_rtos.rs
index f4e912f..25231d0 100644
--- a/stun-agent/tests/stun_client_rtos.rs
+++ b/stun-agent/tests/stun_client_rtos.rs
@@ -2,7 +2,7 @@ use log::info;
 use std::time::{Duration, Instant};
 use stun_agent::{
     RttConfig, StunAgentError, StunAttributes, StunClient, StunClienteBuilder,
-    StunTransactionError, StuntClientEvent, TransportReliability,
+    StunTransactionError, StunClientEvent, TransportReliability,
 };
 use stun_rs::methods::BINDING;
 use stun_rs::MessageClass::SuccessResponse;
@@ -36,10 +36,10 @@ fn test_stun_client_no_reliable_first_rto() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((_, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((_, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -64,12 +64,12 @@ fn test_rto_after_duration(
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(buffer).expect("Failed to decode message");
     assert_eq!(msg_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, timeout)) =
+    let StunClientEvent::RestransmissionTimeOut((id, timeout)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -88,12 +88,12 @@ fn test_all_rtos(client: &mut StunClient, decoder: &MessageDecoder) {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(buffer).expect("Failed to decode message");
     let msg_id = msg.transaction_id();
-    let StuntClientEvent::RestransmissionTimeOut((id, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((id, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -167,7 +167,7 @@ fn test_all_rtos(client: &mut StunClient, decoder: &MessageDecoder) {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -207,12 +207,12 @@ fn test_stun_client_no_reliable_skip_intermediate_rtos_on_delayed_call() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(buffer) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(buffer).expect("Failed to decode message");
     let msg_id = msg.transaction_id();
-    let StuntClientEvent::RestransmissionTimeOut((id, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((id, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -249,10 +249,10 @@ fn test_stun_client_no_reliable_rtt() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((id, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((id, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -278,7 +278,7 @@ fn test_stun_client_no_reliable_rtt() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected TransactionFinished event");
     };
     assert_eq!(msg.transaction_id(), id);
@@ -291,10 +291,10 @@ fn test_stun_client_no_reliable_rtt() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((_, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((_, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -320,10 +320,10 @@ fn test_stun_client_no_reliable_reset_rtt_after_10_mins() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((id, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((id, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -349,7 +349,7 @@ fn test_stun_client_no_reliable_reset_rtt_after_10_mins() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected TransactionFinished event");
     };
     assert_eq!(msg.transaction_id(), id);
@@ -363,10 +363,10 @@ fn test_stun_client_no_reliable_reset_rtt_after_10_mins() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((id, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((id, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -391,7 +391,7 @@ fn test_stun_client_no_reliable_reset_rtt_after_10_mins() {
     // consume the events
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(msg) = iter.next().expect("Expected event") else {
         panic!("Expected TransactionFinished event");
     };
     assert_eq!(msg.transaction_id(), id);
@@ -406,10 +406,10 @@ fn test_stun_client_no_reliable_reset_rtt_after_10_mins() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((_, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((_, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -435,10 +435,10 @@ fn test_stun_client_reliable_rtt() {
         .expect("Failed to create indication");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(_) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
-    let StuntClientEvent::RestransmissionTimeOut((_, duration)) =
+    let StunClientEvent::RestransmissionTimeOut((_, duration)) =
         iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
@@ -451,7 +451,7 @@ fn test_stun_client_reliable_rtt() {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((_, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((_, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
diff --git a/stun-agent/tests/stun_client_st_cred_mech.rs b/stun-agent/tests/stun_client_st_cred_mech.rs
index 129e3d2..c8c1b30 100644
--- a/stun-agent/tests/stun_client_st_cred_mech.rs
+++ b/stun-agent/tests/stun_client_st_cred_mech.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 use stun_agent::{
     CredentialMechanism, Integrity, RttConfig, StunAgentError, StunAttributes, StunClienteBuilder,
-    StunTransactionError, StuntClientEvent, TransportReliability,
+    StunTransactionError, StunClientEvent, TransportReliability,
 };
 use stun_rs::attributes::stun::{MessageIntegrity, MessageIntegritySha256, UserName};
 use stun_rs::methods::BINDING;
@@ -109,13 +109,13 @@ fn test_stun_client_send_request_unreliable() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(None, msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -150,7 +150,7 @@ fn test_stun_client_send_indication_unreliable() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
@@ -190,13 +190,13 @@ fn test_stun_client_send_request_unreliable_with_integrity() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(Some(Integrity::MessageIntegrity), msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -232,7 +232,7 @@ fn test_stun_client_send_indication_unreliable_with_integrity() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
@@ -323,13 +323,13 @@ fn test_stun_client_recv_request_unreliable_corrupted_integrity() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(Some(Integrity::MessageIntegrity), msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -365,7 +365,7 @@ fn test_stun_client_recv_request_unreliable_corrupted_integrity() {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -398,13 +398,13 @@ fn test_stun_client_recv_request_reliable_corrupted_integrity() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(Some(Integrity::MessageIntegrity), msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -438,7 +438,7 @@ fn test_stun_client_recv_request_reliable_corrupted_integrity() {
     // Because this is a reliable transport, there must be a protection violated event
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -467,13 +467,13 @@ fn test_timeout(reliability: TransportReliability) {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(Some(Integrity::MessageIntegrity), msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -488,7 +488,7 @@ fn test_timeout(reliability: TransportReliability) {
     client.on_timeout(instant);
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
+    let StunClientEvent::TransactionFailed((id, error)) = iter.next().expect("Expected event")
     else {
         panic!("Expected TransactionFailed event");
     };
@@ -525,13 +525,13 @@ fn test_stun_client_picks_cred_mech() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     check_attributes(None, msg.attributes());
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };
@@ -558,7 +558,7 @@ fn test_stun_client_picks_cred_mech() {
         .expect("Message should be accepted");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::StunMessageReceived(resp) = iter.next().expect("Expected event") else {
+    let StunClientEvent::StunMessageReceived(resp) = iter.next().expect("Expected event") else {
         panic!("Expected StunMessageReceived event");
     };
     // The timeout should be set for the first message
@@ -573,12 +573,12 @@ fn test_stun_client_picks_cred_mech() {
         .expect("Failed to create request");
     let events = client.events();
     let mut iter = events.iter();
-    let StuntClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
+    let StunClientEvent::OutputPacket(packet) = iter.next().expect("Expected event") else {
         panic!("Expected OutputBuffer event");
     };
     let (msg, _) = decoder.decode(packet).expect("Failed to decode message");
     assert_eq!(&transaction_id, msg.transaction_id());
-    let StuntClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
+    let StunClientEvent::RestransmissionTimeOut((id, _)) = iter.next().expect("Expected event")
     else {
         panic!("Expected RestransmissionTimeOut event");
     };