diff --git a/src/common.rs b/src/common.rs
index 24604e4..bd43687 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -1,6 +1,6 @@
 //! Common data types included in EPP Requests and Responses
 
-use std::fmt::Display;
+use std::{borrow::Cow, fmt::Display};
 
 use serde::{Deserialize, Serialize};
 
@@ -11,23 +11,23 @@ pub(crate) const EPP_XMLNS: &str = "urn:ietf:params:xml:ns:epp-1.0";
 /// Wraps String for easier serialization to and from values that are inner text
 /// for tags rather than attributes
 #[derive(Default, Serialize, Deserialize, Debug, PartialEq, Clone)]
-pub struct StringValue(String);
+pub struct StringValue<'a>(Cow<'a, str>);
 
-impl Display for StringValue {
+impl Display for StringValue<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 
-impl From<&str> for StringValue {
-    fn from(s: &str) -> Self {
-        Self(s.to_owned())
+impl<'a> From<&'a str> for StringValue<'a> {
+    fn from(s: &'a str) -> Self {
+        Self(s.into())
     }
 }
 
-impl From<String> for StringValue {
+impl From<String> for StringValue<'static> {
     fn from(s: String) -> Self {
-        Self(s)
+        Self(s.into())
     }
 }
 
@@ -42,17 +42,17 @@ impl Extension for NoExtension {
 /// The <option> type in EPP XML login requests
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename = "options")]
-pub struct Options {
+pub struct Options<'a> {
     /// The EPP version being used
-    pub version: StringValue,
+    pub version: StringValue<'a>,
     /// The language that will be used during EPP transactions
-    pub lang: StringValue,
+    pub lang: StringValue<'a>,
 }
 
-impl Options {
+impl<'a> Options<'a> {
     /// Creates an Options object with version and lang data
-    pub fn build(version: &str, lang: &str) -> Options {
-        Options {
+    pub fn build(version: &'a str, lang: &'a str) -> Self {
+        Self {
             version: version.into(),
             lang: lang.into(),
         }
@@ -62,21 +62,21 @@ impl Options {
 /// The <svcExtension> type in EPP XML
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename = "svcExtension")]
-pub struct ServiceExtension {
+pub struct ServiceExtension<'a> {
     /// The service extension URIs being represented by <extURI> in EPP XML
     #[serde(rename = "extURI")]
-    pub ext_uris: Option<Vec<StringValue>>,
+    pub ext_uris: Option<Vec<StringValue<'a>>>,
 }
 
 /// The <svcs> type in EPP XML
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
-pub struct Services {
+pub struct Services<'a> {
     /// The service URIs being used by this EPP session represented by <objURI> in EPP XML
     #[serde(rename = "objURI")]
-    pub obj_uris: Vec<StringValue>,
+    pub obj_uris: Vec<StringValue<'a>>,
     /// The <svcExtention> being used in this EPP session
     #[serde(rename = "svcExtension")]
-    pub svc_ext: Option<ServiceExtension>,
+    pub svc_ext: Option<ServiceExtension<'a>>,
 }
 
 /// The &lt;hostAddr&gt; types domain or host transactions
diff --git a/src/contact.rs b/src/contact.rs
index 3f323d0..33d7273 100644
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -33,16 +33,16 @@ impl std::ops::Deref for Country {
 
 /// The &lt;authInfo&gt; tag for domain and contact transactions
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct ContactAuthInfo {
+pub struct ContactAuthInfo<'a> {
     /// The &lt;pw&gt; tag under &lt;authInfo&gt;
     #[serde(rename = "contact:pw", alias = "pw")]
-    pub password: StringValue,
+    pub password: StringValue<'a>,
 }
 
-impl ContactAuthInfo {
+impl<'a> ContactAuthInfo<'a> {
     /// Creates a ContactAuthInfo instance with the given password
-    pub fn new(password: &str) -> ContactAuthInfo {
-        ContactAuthInfo {
+    pub fn new(password: &'a str) -> Self {
+        Self {
             password: password.into(),
         }
     }
@@ -76,36 +76,36 @@ impl Phone {
 
 /// The &lt;addr&gt; type on contact transactions
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Address {
+pub struct Address<'a> {
     /// The &lt;street&gt; tags under &lt;addr&gt;
     #[serde(rename = "contact:street", alias = "street")]
-    pub street: Vec<StringValue>,
+    pub street: Vec<StringValue<'a>>,
     /// The &lt;city&gt; tag under &lt;addr&gt;
     #[serde(rename = "contact:city", alias = "city")]
-    pub city: StringValue,
+    pub city: StringValue<'a>,
     /// The &lt;sp&gt; tag under &lt;addr&gt;
     #[serde(rename = "contact:sp", alias = "sp")]
-    pub province: StringValue,
+    pub province: StringValue<'a>,
     /// The &lt;pc&gt; tag under &lt;addr&gt;
     #[serde(rename = "contact:pc", alias = "pc")]
-    pub postal_code: StringValue,
+    pub postal_code: StringValue<'a>,
     /// The &lt;cc&gt; tag under &lt;addr&gt;
     #[serde(rename = "contact:cc", alias = "cc")]
     pub country: Country,
 }
 
-impl Address {
+impl<'a> Address<'a> {
     /// Creates a new Address instance
     pub fn new(
-        street: &[&str],
-        city: &str,
-        province: &str,
-        postal_code: &str,
+        street: &[&'a str],
+        city: &'a str,
+        province: &'a str,
+        postal_code: &'a str,
         country: Country,
-    ) -> Address {
+    ) -> Self {
         let street = street.iter().map(|&s| s.into()).collect();
 
-        Address {
+        Self {
             street,
             city: city.into(),
             province: province.into(),
@@ -117,25 +117,25 @@ impl Address {
 
 /// The &lt;postalInfo&gt; type on contact transactions
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct PostalInfo {
+pub struct PostalInfo<'a> {
     /// The 'type' attr on &lt;postalInfo&gt;
     #[serde(rename = "type")]
     pub info_type: String,
     /// The &lt;name&gt; tag under &lt;postalInfo&gt;
     #[serde(rename = "contact:name", alias = "name")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
     /// The &lt;org&gt; tag under &lt;postalInfo&gt;
     #[serde(rename = "contact:org", alias = "org")]
-    pub organization: StringValue,
+    pub organization: StringValue<'a>,
     /// The &lt;addr&gt; tag under &lt;postalInfo&gt;
     #[serde(rename = "contact:addr", alias = "addr")]
-    pub address: Address,
+    pub address: Address<'a>,
 }
 
-impl PostalInfo {
+impl<'a> PostalInfo<'a> {
     /// Creates a new PostalInfo instance
-    pub fn new(info_type: &str, name: &str, organization: &str, address: Address) -> PostalInfo {
-        PostalInfo {
+    pub fn new(info_type: &str, name: &'a str, organization: &'a str, address: Address<'a>) -> Self {
+        Self {
             info_type: info_type.to_string(),
             name: name.into(),
             organization: organization.into(),
diff --git a/src/contact/check.rs b/src/contact/check.rs
index f5bb7af..d48544b 100644
--- a/src/contact/check.rs
+++ b/src/contact/check.rs
@@ -6,35 +6,32 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for ContactCheck {}
+impl<'a> Transaction<NoExtension> for ContactCheck<'a> {}
 
 // Request
 
 /// Type that represents the &lt;check&gt; command for contact transactions
 #[derive(Serialize, Debug)]
-pub struct ContactList {
+pub struct ContactList<'a> {
     /// The XML namespace for the contact &lt;check&gt;
     #[serde(rename = "xmlns:contact")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The list of contact ids to check for availability
     #[serde(rename = "contact:id")]
-    pub contact_ids: Vec<StringValue>,
+    pub contact_ids: Vec<StringValue<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// The &lt;command&gt; type for contact check command
-pub struct ContactCheck {
+pub struct ContactCheck<'a> {
     /// The &lt;check&gt; tag for the contact check command
     #[serde(rename = "contact:check")]
-    list: ContactList,
+    list: ContactList<'a>,
 }
 
-impl ContactCheck {
-    pub fn new(contact_ids: &[&str]) -> Self {
-        let contact_ids = contact_ids
-            .iter()
-            .map(|&d| d.into())
-            .collect::<Vec<StringValue>>();
+impl<'a> ContactCheck<'a> {
+    pub fn new(contact_ids: &[&'a str]) -> Self {
+        let contact_ids = contact_ids.iter().map(|&d| d.into()).collect();
 
         Self {
             list: ContactList {
@@ -45,7 +42,7 @@ impl ContactCheck {
     }
 }
 
-impl Command for ContactCheck {
+impl<'a> Command for ContactCheck<'a> {
     type Response = ContactCheckResponse;
     const COMMAND: &'static str = "check";
 }
@@ -57,7 +54,7 @@ impl Command for ContactCheck {
 pub struct ContactAvailable {
     /// The text of the &lt;id&gt; tag
     #[serde(rename = "$value")]
-    pub id: StringValue,
+    pub id: StringValue<'static>,
     /// The avail attr on the &lt;id&gt; tag
     #[serde(rename = "avail")]
     pub available: u16,
@@ -70,7 +67,7 @@ pub struct ContactCheckResponseDataItem {
     #[serde(rename = "id")]
     pub contact: ContactAvailable,
     /// The reason for (un)availability
-    pub reason: Option<StringValue>,
+    pub reason: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;chkData&gt; tag for contact check response
diff --git a/src/contact/create.rs b/src/contact/create.rs
index b170ac1..540e7ab 100644
--- a/src/contact/create.rs
+++ b/src/contact/create.rs
@@ -5,9 +5,9 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for ContactCreate {}
+impl<'a> Transaction<NoExtension> for ContactCreate<'a> {}
 
-impl Command for ContactCreate {
+impl<'a> Command for ContactCreate<'a> {
     type Response = ContactCreateResponse;
     const COMMAND: &'static str = "create";
 }
@@ -16,16 +16,16 @@ impl Command for ContactCreate {
 
 /// Type for elements under the contact &lt;create&gt; tag
 #[derive(Serialize, Debug)]
-pub struct Contact {
+pub struct Contact<'a> {
     /// XML namespace for contact commands
     #[serde(rename = "xmlns:contact")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// Contact &lt;id&gt; tag
     #[serde(rename = "contact:id")]
-    id: StringValue,
+    id: StringValue<'a>,
     /// Contact &lt;postalInfo&gt; tag
     #[serde(rename = "contact:postalInfo")]
-    postal_info: PostalInfo,
+    postal_info: PostalInfo<'a>,
     /// Contact &lt;voice&gt; tag
     #[serde(rename = "contact:voice")]
     voice: Phone,
@@ -34,27 +34,27 @@ pub struct Contact {
     fax: Option<Phone>,
     /// Contact &lt;email&gt; tag
     #[serde(rename = "contact:email")]
-    email: StringValue,
+    email: StringValue<'a>,
     /// Contact &lt;authInfo&gt; tag
     #[serde(rename = "contact:authInfo")]
-    auth_info: ContactAuthInfo,
+    auth_info: ContactAuthInfo<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;create&gt; command for contacts
-pub struct ContactCreate {
+pub struct ContactCreate<'a> {
     /// Data for &lt;create&gt; command for contact
     #[serde(rename = "contact:create")]
-    pub contact: Contact,
+    pub contact: Contact<'a>,
 }
 
-impl ContactCreate {
+impl<'a> ContactCreate<'a> {
     pub fn new(
-        id: &str,
-        email: &str,
-        postal_info: PostalInfo,
+        id: &'a str,
+        email: &'a str,
+        postal_info: PostalInfo<'a>,
         voice: Phone,
-        auth_password: &str,
+        auth_password: &'a str,
     ) -> Self {
         Self {
             contact: Contact {
@@ -81,10 +81,10 @@ impl ContactCreate {
 #[derive(Deserialize, Debug)]
 pub struct ContactCreateData {
     /// The contact id
-    pub id: StringValue,
+    pub id: StringValue<'static>,
     #[serde(rename = "crDate")]
     /// The contact creation date
-    pub created_at: StringValue,
+    pub created_at: StringValue<'static>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for contact create response
diff --git a/src/contact/delete.rs b/src/contact/delete.rs
index 527979b..edb4988 100644
--- a/src/contact/delete.rs
+++ b/src/contact/delete.rs
@@ -5,34 +5,34 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::Serialize;
 
-impl Transaction<NoExtension> for ContactDelete {}
+impl<'a> Transaction<NoExtension> for ContactDelete<'a> {}
 
-impl Command for ContactDelete {
+impl<'a> Command for ContactDelete<'a> {
     type Response = ();
     const COMMAND: &'static str = "delete";
 }
 
 /// Type containing the data for the &lt;delete&gt; tag for contacts
 #[derive(Serialize, Debug)]
-pub struct ContactDeleteRequestData {
+pub struct ContactDeleteRequestData<'a> {
     /// XML namespace for the &lt;delete&gt; command for contacts
     #[serde(rename = "xmlns:contact")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The id of the contact to be deleted
     #[serde(rename = "contact:id")]
-    id: StringValue,
+    id: StringValue<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// The &lt;delete&gt; type for the contact delete EPP command
-pub struct ContactDelete {
+pub struct ContactDelete<'a> {
     #[serde(rename = "contact:delete")]
     /// The data for the &lt;delete&gt; tag for a contact delete command
-    contact: ContactDeleteRequestData,
+    contact: ContactDeleteRequestData<'a>,
 }
 
-impl ContactDelete {
-    pub fn new(id: &str) -> ContactDelete {
+impl<'a> ContactDelete<'a> {
+    pub fn new(id: &'a str) -> Self {
         Self {
             contact: ContactDeleteRequestData {
                 xmlns: XMLNS,
diff --git a/src/contact/info.rs b/src/contact/info.rs
index c9a1961..84d5e16 100644
--- a/src/contact/info.rs
+++ b/src/contact/info.rs
@@ -5,9 +5,9 @@ use crate::common::{NoExtension, ObjectStatus, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for ContactInfo {}
+impl<'a> Transaction<NoExtension> for ContactInfo<'a> {}
 
-impl Command for ContactInfo {
+impl<'a> Command for ContactInfo<'a> {
     type Response = ContactInfoResponse;
     const COMMAND: &'static str = "info";
 }
@@ -16,28 +16,28 @@ impl Command for ContactInfo {
 
 /// Type for elements under the contact &lt;info&gt; tag
 #[derive(Serialize, Debug)]
-pub struct ContactInfoRequestData {
+pub struct ContactInfoRequestData<'a> {
     /// XML namespace for contact commands
     #[serde(rename = "xmlns:contact")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The contact id for the info command
     #[serde(rename = "contact:id")]
-    id: StringValue,
+    id: StringValue<'a>,
     /// The &lt;authInfo&gt; data
     #[serde(rename = "contact:authInfo")]
-    auth_info: ContactAuthInfo,
+    auth_info: ContactAuthInfo<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;info&gt; command for contacts
-pub struct ContactInfo {
+pub struct ContactInfo<'a> {
     /// Data for &lt;info&gt; command for contact
     #[serde(rename = "contact:info")]
-    info: ContactInfoRequestData,
+    info: ContactInfoRequestData<'a>,
 }
 
-impl ContactInfo {
-    pub fn new(id: &str, auth_password: &str) -> ContactInfo {
+impl<'a> ContactInfo<'a> {
+    pub fn new(id: &'a str, auth_password: &'a str) -> ContactInfo<'a> {
         Self {
             info: ContactInfoRequestData {
                 xmlns: XMLNS,
@@ -52,44 +52,44 @@ impl ContactInfo {
 
 /// Type that represents the &lt;infData&gt; tag for contact check response
 #[derive(Deserialize, Debug)]
-pub struct ContactInfoData {
+pub struct ContactInfoData<'a> {
     /// The contact id
-    pub id: StringValue,
+    pub id: StringValue<'a>,
     /// The contact ROID
-    pub roid: StringValue,
+    pub roid: StringValue<'a>,
     /// The list of contact statuses
     #[serde(rename = "status")]
     pub statuses: Vec<ObjectStatus>,
     /// The postal info for the contact
     #[serde(rename = "postalInfo")]
-    pub postal_info: PostalInfo,
+    pub postal_info: PostalInfo<'a>,
     /// The voice data for the contact
     pub voice: Phone,
     /// The fax data for the contact
     pub fax: Option<Phone>,
     /// The email for the contact
-    pub email: StringValue,
+    pub email: StringValue<'a>,
     /// The epp user to whom the contact belongs
     #[serde(rename = "clID")]
-    pub client_id: StringValue,
+    pub client_id: StringValue<'a>,
     /// The epp user who created the contact
     #[serde(rename = "crID")]
-    pub creator_id: StringValue,
+    pub creator_id: StringValue<'a>,
     /// The creation date
     #[serde(rename = "crDate")]
-    pub created_at: StringValue,
+    pub created_at: StringValue<'a>,
     /// The epp user who last updated the contact
     #[serde(rename = "upID")]
-    pub updater_id: Option<StringValue>,
+    pub updater_id: Option<StringValue<'a>>,
     /// The last update date
     #[serde(rename = "upDate")]
-    pub updated_at: Option<StringValue>,
+    pub updated_at: Option<StringValue<'a>>,
     /// The contact transfer date
     #[serde(rename = "trDate")]
-    pub transferred_at: Option<StringValue>,
+    pub transferred_at: Option<StringValue<'a>>,
     /// The contact auth info
     #[serde(rename = "authInfo")]
-    pub auth_info: Option<ContactAuthInfo>,
+    pub auth_info: Option<ContactAuthInfo<'a>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for contact info response
@@ -97,7 +97,7 @@ pub struct ContactInfoData {
 pub struct ContactInfoResponse {
     /// Data under the &lt;infData&gt; tag
     #[serde(rename = "infData")]
-    pub info_data: ContactInfoData,
+    pub info_data: ContactInfoData<'static>,
 }
 
 #[cfg(test)]
diff --git a/src/contact/update.rs b/src/contact/update.rs
index cfa3f1a..aa93fda 100644
--- a/src/contact/update.rs
+++ b/src/contact/update.rs
@@ -5,15 +5,15 @@ use crate::common::{NoExtension, ObjectStatus, StringValue};
 use crate::request::{Command, Transaction};
 use serde::Serialize;
 
-impl Transaction<NoExtension> for ContactUpdate {}
+impl<'a> Transaction<NoExtension> for ContactUpdate<'a> {}
 
-impl Command for ContactUpdate {
+impl<'a> Command for ContactUpdate<'a> {
     type Response = ();
     const COMMAND: &'static str = "update";
 }
 
-impl ContactUpdate {
-    pub fn new(id: &str) -> ContactUpdate {
+impl<'a> ContactUpdate<'a> {
+    pub fn new(id: &'a str) -> ContactUpdate {
         Self {
             contact: ContactUpdateRequestData {
                 xmlns: XMLNS,
@@ -28,10 +28,10 @@ impl ContactUpdate {
     /// Sets the data for the &lt;chg&gt; tag for the contact update request
     pub fn set_info(
         &mut self,
-        email: &str,
-        postal_info: PostalInfo,
+        email: &'a str,
+        postal_info: PostalInfo<'a>,
         voice: Phone,
-        auth_password: &str,
+        auth_password: &'a str,
     ) {
         self.contact.change_info = Some(ContactChangeInfo {
             email: Some(email.into()),
@@ -62,17 +62,17 @@ impl ContactUpdate {
 
 /// Type for elements under the &lt;chg&gt; tag for contact update request
 #[derive(Serialize, Debug)]
-pub struct ContactChangeInfo {
+pub struct ContactChangeInfo<'a> {
     #[serde(rename = "contact:postalInfo")]
-    postal_info: Option<PostalInfo>,
+    postal_info: Option<PostalInfo<'a>>,
     #[serde(rename = "contact:voice")]
     voice: Option<Phone>,
     #[serde(rename = "contact:fax")]
     fax: Option<Phone>,
     #[serde(rename = "contact:email")]
-    email: Option<StringValue>,
+    email: Option<StringValue<'a>>,
     #[serde(rename = "contact:authInfo")]
-    auth_info: Option<ContactAuthInfo>,
+    auth_info: Option<ContactAuthInfo<'a>>,
 }
 
 /// Type for list of elements of the &lt;status&gt; tag for contact update request
@@ -84,25 +84,25 @@ pub struct StatusList {
 
 /// Type for elements under the contact &lt;update&gt; tag
 #[derive(Serialize, Debug)]
-pub struct ContactUpdateRequestData {
+pub struct ContactUpdateRequestData<'a> {
     #[serde(rename = "xmlns:contact")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     #[serde(rename = "contact:id")]
-    id: StringValue,
+    id: StringValue<'a>,
     #[serde(rename = "contact:add")]
     add_statuses: Option<StatusList>,
     #[serde(rename = "contact:rem")]
     remove_statuses: Option<StatusList>,
     #[serde(rename = "contact:chg")]
-    change_info: Option<ContactChangeInfo>,
+    change_info: Option<ContactChangeInfo<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;update&gt; command for contacts
-pub struct ContactUpdate {
+pub struct ContactUpdate<'a> {
     /// The data under the &lt;update&gt; tag for the contact update
     #[serde(rename = "contact:update")]
-    contact: ContactUpdateRequestData,
+    contact: ContactUpdateRequestData<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/domain.rs b/src/domain.rs
index 5ff14f1..32a02fa 100644
--- a/src/domain.rs
+++ b/src/domain.rs
@@ -14,10 +14,10 @@ pub const XMLNS: &str = "urn:ietf:params:xml:ns:domain-1.0";
 
 /// The &lt;hostAttr&gt; type for domain transactions
 #[derive(Serialize, Deserialize, Debug)]
-pub struct HostAttr {
+pub struct HostAttr<'a> {
     /// The &lt;hostName&gt; tag
     #[serde(rename = "domain:hostName", alias = "hostName")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
     /// The &lt;hostAddr&gt; tags
     #[serde(rename = "domain:hostAddr", alias = "hostAddr")]
     pub addresses: Option<Vec<HostAddr>>,
@@ -25,27 +25,27 @@ pub struct HostAttr {
 
 /// The list of &lt;hostAttr&gt; types for domain transactions. Typically under an &lt;ns&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostAttrList {
+pub struct HostAttrList<'a> {
     /// The list of &lt;hostAttr&gt; tags
     #[serde(rename = "domain:hostAttr", alias = "hostAttr")]
-    pub hosts: Vec<HostAttr>,
+    pub hosts: Vec<HostAttr<'a>>,
 }
 
 /// The list of &lt;hostObj&gt; types for domain transactions. Typically under an &lt;ns&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostObjList {
+pub struct HostObjList<'a> {
     /// The list of &lt;hostObj&gt; tags
     #[serde(rename = "domain:hostObj", alias = "hostObj")]
-    pub hosts: Vec<StringValue>,
+    pub hosts: Vec<StringValue<'a>>,
 }
 
 /// Enum that can accept one type which corresponds to either the &lt;hostObj&gt; or &lt;hostAttr&gt;
 /// list of tags
 #[derive(Serialize, Debug)]
 #[serde(untagged)]
-pub enum HostList {
-    HostObjList(HostObjList),
-    HostAttrList(HostAttrList),
+pub enum HostList<'a> {
+    HostObjList(HostObjList<'a>),
+    HostAttrList(HostAttrList<'a>),
 }
 
 /// The &lt;contact&gt; type on domain creation and update requests
@@ -86,16 +86,16 @@ impl Period {
 
 /// The &lt;authInfo&gt; tag for domain and contact transactions
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct DomainAuthInfo {
+pub struct DomainAuthInfo<'a> {
     /// The &lt;pw&gt; tag under &lt;authInfo&gt;
     #[serde(rename = "domain:pw", alias = "pw")]
-    pub password: StringValue,
+    pub password: StringValue<'a>,
 }
 
-impl DomainAuthInfo {
+impl<'a> DomainAuthInfo<'a> {
     /// Creates a DomainAuthInfo instance with the given password
-    pub fn new(password: &str) -> DomainAuthInfo {
-        DomainAuthInfo {
+    pub fn new(password: &'a str) -> Self {
+        Self {
             password: password.into(),
         }
     }
diff --git a/src/domain/check.rs b/src/domain/check.rs
index a2809f7..1c07926 100644
--- a/src/domain/check.rs
+++ b/src/domain/check.rs
@@ -5,22 +5,19 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for DomainCheck {}
+impl<'a> Transaction<NoExtension> for DomainCheck<'a> {}
 
-impl Command for DomainCheck {
+impl<'a> Command for DomainCheck<'a> {
     type Response = DomainCheckResponse;
     const COMMAND: &'static str = "check";
 }
 
-impl DomainCheck {
-    pub fn new(domains: Vec<&str>) -> Self {
+impl<'a> DomainCheck<'a> {
+    pub fn new(domains: Vec<&'a str>) -> Self {
         Self {
             list: DomainList {
                 xmlns: XMLNS,
-                domains: domains
-                    .into_iter()
-                    .map(|d| d.into())
-                    .collect::<Vec<StringValue>>(),
+                domains: domains.into_iter().map(|d| d.into()).collect(),
             },
         }
     }
@@ -30,21 +27,21 @@ impl DomainCheck {
 
 /// Type for &lt;name&gt; elements under the domain &lt;check&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainList {
+pub struct DomainList<'a> {
     #[serde(rename = "xmlns:domain")]
     /// XML namespace for domain commands
-    pub xmlns: &'static str,
+    pub xmlns: &'a str,
     #[serde(rename = "domain:name")]
     /// List of domains to be checked for availability
-    pub domains: Vec<StringValue>,
+    pub domains: Vec<StringValue<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;check&gt; command for domains
-pub struct DomainCheck {
+pub struct DomainCheck<'a> {
     /// The object holding the list of domains to be checked
     #[serde(rename = "domain:check")]
-    list: DomainList,
+    list: DomainList<'a>,
 }
 
 // Response
@@ -54,7 +51,7 @@ pub struct DomainCheck {
 pub struct DomainAvailable {
     /// The domain name
     #[serde(rename = "$value")]
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The domain (un)availability
     #[serde(rename = "avail")]
     pub available: u16,
@@ -67,7 +64,7 @@ pub struct DomainCheckResponseDataItem {
     #[serde(rename = "name")]
     pub domain: DomainAvailable,
     /// The reason for (un)availability
-    pub reason: Option<StringValue>,
+    pub reason: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;chkData&gt; tag for domain check response
diff --git a/src/domain/create.rs b/src/domain/create.rs
index f37a7bd..af085e1 100644
--- a/src/domain/create.rs
+++ b/src/domain/create.rs
@@ -6,9 +6,9 @@ use crate::request::{Command, Transaction};
 
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for DomainCreate {}
+impl<'a> Transaction<NoExtension> for DomainCreate<'a> {}
 
-impl Command for DomainCreate {
+impl<'a> Command for DomainCreate<'a> {
     type Response = DomainCreateResponse;
     const COMMAND: &'static str = "create";
 }
@@ -17,48 +17,48 @@ impl Command for DomainCreate {
 
 /// Type for elements under the domain &lt;create&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainCreateRequestData {
+pub struct DomainCreateRequestData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    pub xmlns: &'static str,
+    pub xmlns: &'a str,
     /// The domain name
     #[serde(rename = "domain:name")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
     /// The period of registration
     #[serde(rename = "domain:period")]
     pub period: Period,
     /// The list of nameserver hosts
     /// either of type `HostObjList` or `HostAttrList`
     #[serde(rename = "domain:ns")]
-    pub ns: Option<HostList>,
+    pub ns: Option<HostList<'a>>,
     /// The domain registrant
     #[serde(rename = "domain:registrant")]
-    pub registrant: Option<StringValue>,
+    pub registrant: Option<StringValue<'a>>,
     /// The list of contacts for the domain
     #[serde(rename = "domain:contact")]
     pub contacts: Option<Vec<DomainContact>>,
     /// The auth info for the domain
     #[serde(rename = "domain:authInfo")]
-    pub auth_info: DomainAuthInfo,
+    pub auth_info: DomainAuthInfo<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;create&gt; command for domains
-pub struct DomainCreate {
+pub struct DomainCreate<'a> {
     /// The data for the domain to be created with
     /// T being the type of nameserver list (`HostObjList` or `HostAttrList`)
     /// to be supplied
     #[serde(rename = "domain:create")]
-    pub domain: DomainCreateRequestData,
+    pub domain: DomainCreateRequestData<'a>,
 }
 
-impl DomainCreate {
+impl<'a> DomainCreate<'a> {
     pub fn new(
-        name: &str,
+        name: &'a str,
         period: u16,
-        ns: Option<HostList>,
-        registrant_id: Option<&str>,
-        auth_password: &str,
+        ns: Option<HostList<'a>>,
+        registrant_id: Option<&'a str>,
+        auth_password: &'a str,
         contacts: Option<Vec<DomainContact>>,
     ) -> Self {
         Self {
@@ -84,13 +84,13 @@ pub struct DomainCreateResponseData {
     #[serde(rename = "xmlns:domain")]
     pub xmlns: String,
     /// The domain name
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The creation date
     #[serde(rename = "crDate")]
-    pub created_at: StringValue,
+    pub created_at: StringValue<'static>,
     /// The expiry date
     #[serde(rename = "exDate")]
-    pub expiring_at: Option<StringValue>,
+    pub expiring_at: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for domain create response
diff --git a/src/domain/delete.rs b/src/domain/delete.rs
index 85d3edd..a4ea711 100644
--- a/src/domain/delete.rs
+++ b/src/domain/delete.rs
@@ -5,15 +5,15 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::Serialize;
 
-impl Transaction<NoExtension> for DomainDelete {}
+impl<'a> Transaction<NoExtension> for DomainDelete<'a> {}
 
-impl Command for DomainDelete {
+impl<'a> Command for DomainDelete<'a> {
     type Response = ();
     const COMMAND: &'static str = "delete";
 }
 
-impl DomainDelete {
-    pub fn new(name: &str) -> Self {
+impl<'a> DomainDelete<'a> {
+    pub fn new(name: &'a str) -> Self {
         Self {
             domain: DomainDeleteRequestData {
                 xmlns: XMLNS,
@@ -25,21 +25,21 @@ impl DomainDelete {
 
 /// Type for &lt;name&gt; element under the domain &lt;delete&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainDeleteRequestData {
+pub struct DomainDeleteRequestData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The domain to be deleted
     #[serde(rename = "domain:name")]
-    name: StringValue,
+    name: StringValue<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;delete&gt; command for domains
-pub struct DomainDelete {
+pub struct DomainDelete<'a> {
     /// The data under the &lt;delete&gt; tag for domain deletion
     #[serde(rename = "domain:delete")]
-    domain: DomainDeleteRequestData,
+    domain: DomainDeleteRequestData<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/domain/info.rs b/src/domain/info.rs
index 365c7f6..b80e46b 100644
--- a/src/domain/info.rs
+++ b/src/domain/info.rs
@@ -5,15 +5,15 @@ use crate::common::{NoExtension, ObjectStatus, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for DomainInfo {}
+impl<'a> Transaction<NoExtension> for DomainInfo<'a> {}
 
-impl Command for DomainInfo {
+impl<'a> Command for DomainInfo<'a> {
     type Response = DomainInfoResponse;
     const COMMAND: &'static str = "info";
 }
 
-impl DomainInfo {
-    pub fn new(name: &str, auth_password: Option<&str>) -> Self {
+impl<'a> DomainInfo<'a> {
+    pub fn new(name: &'a str, auth_password: Option<&'a str>) -> Self {
         Self {
             info: DomainInfoRequestData {
                 xmlns: XMLNS,
@@ -43,24 +43,24 @@ pub struct Domain {
 
 /// Type for &lt;name&gt; element under the domain &lt;info&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainInfoRequestData {
+pub struct DomainInfoRequestData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The data for the domain to be queried
     #[serde(rename = "domain:name")]
     domain: Domain,
     /// The auth info for the domain
     #[serde(rename = "domain:authInfo")]
-    auth_info: Option<DomainAuthInfo>,
+    auth_info: Option<DomainAuthInfo<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;info&gt; command for domains
-pub struct DomainInfo {
+pub struct DomainInfo<'a> {
     /// The data under the &lt;info&gt; tag for domain info
     #[serde(rename = "domain:info")]
-    info: DomainInfoRequestData,
+    info: DomainInfoRequestData<'a>,
 }
 
 // Response
@@ -71,23 +71,23 @@ pub struct DomainInfo {
 pub struct DomainNsList {
     /// List of &lt;hostObj&gt; ns elements
     #[serde(rename = "hostObj")]
-    pub host_obj: Option<Vec<StringValue>>,
+    pub host_obj: Option<Vec<StringValue<'static>>>,
     /// List of &lt;hostAttr&gt; ns elements
-    pub host_attr: Option<Vec<HostAttr>>,
+    pub host_attr: Option<Vec<HostAttr<'static>>>,
 }
 
 /// Type that represents the &lt;infData&gt; tag for domain info response
 #[derive(Deserialize, Debug)]
 pub struct DomainInfoResponseData {
     /// The domain name
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The domain ROID
-    pub roid: StringValue,
+    pub roid: StringValue<'static>,
     /// The list of domain statuses
     #[serde(rename = "status")]
     pub statuses: Option<Vec<ObjectStatus>>,
     /// The domain registrant
-    pub registrant: Option<StringValue>,
+    pub registrant: Option<StringValue<'static>>,
     /// The list of domain contacts
     #[serde(rename = "contact")]
     pub contacts: Option<Vec<DomainContact>>,
@@ -96,31 +96,31 @@ pub struct DomainInfoResponseData {
     pub ns: Option<DomainNsList>,
     /// The list of domain hosts
     #[serde(rename = "host")]
-    pub hosts: Option<Vec<StringValue>>,
+    pub hosts: Option<Vec<StringValue<'static>>>,
     /// The epp user who owns the domain
     #[serde(rename = "clID")]
-    pub client_id: StringValue,
+    pub client_id: StringValue<'static>,
     /// The epp user who created the domain
     #[serde(rename = "crID")]
-    pub creator_id: Option<StringValue>,
+    pub creator_id: Option<StringValue<'static>>,
     /// The domain creation date
     #[serde(rename = "crDate")]
-    pub created_at: Option<StringValue>,
+    pub created_at: Option<StringValue<'static>>,
     /// The domain expiry date
     #[serde(rename = "exDate")]
-    pub expiring_at: Option<StringValue>,
+    pub expiring_at: Option<StringValue<'static>>,
     /// The epp user who last updated the domain
     #[serde(rename = "upID")]
-    pub updater_id: Option<StringValue>,
+    pub updater_id: Option<StringValue<'static>>,
     /// The domain last updated date
     #[serde(rename = "upDate")]
-    pub updated_at: Option<StringValue>,
+    pub updated_at: Option<StringValue<'static>>,
     /// The domain transfer date
     #[serde(rename = "trDate")]
-    pub transferred_at: Option<StringValue>,
+    pub transferred_at: Option<StringValue<'static>>,
     /// The domain auth info
     #[serde(rename = "authInfo")]
-    pub auth_info: Option<DomainAuthInfo>,
+    pub auth_info: Option<DomainAuthInfo<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for domain info response
diff --git a/src/domain/renew.rs b/src/domain/renew.rs
index 9e92ceb..8617490 100644
--- a/src/domain/renew.rs
+++ b/src/domain/renew.rs
@@ -6,15 +6,15 @@ use crate::request::{Command, Transaction};
 use chrono::NaiveDate;
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for DomainRenew {}
+impl<'a> Transaction<NoExtension> for DomainRenew<'a> {}
 
-impl Command for DomainRenew {
+impl<'a> Command for DomainRenew<'a> {
     type Response = DomainRenewResponse;
     const COMMAND: &'static str = "renew";
 }
 
-impl DomainRenew {
-    pub fn new(name: &str, current_expiry_date: NaiveDate, years: u16) -> Self {
+impl<'a> DomainRenew<'a> {
+    pub fn new(name: &'a str, current_expiry_date: NaiveDate, years: u16) -> Self {
         let exp_date_str = current_expiry_date.format("%Y-%m-%d").to_string().into();
         Self {
             domain: DomainRenewRequestData {
@@ -31,16 +31,16 @@ impl DomainRenew {
 
 /// Type for data under the domain &lt;renew&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainRenewRequestData {
+pub struct DomainRenewRequestData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The name of the domain to be renewed
     #[serde(rename = "domain:name")]
-    name: StringValue,
+    name: StringValue<'a>,
     /// The current expiry date of the domain in 'Y-m-d' format
     #[serde(rename = "domain:curExpDate")]
-    current_expiry_date: StringValue,
+    current_expiry_date: StringValue<'a>,
     /// The period of renewal
     #[serde(rename = "domain:period")]
     period: Period,
@@ -48,10 +48,10 @@ pub struct DomainRenewRequestData {
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;renew&gt; command for domains
-pub struct DomainRenew {
+pub struct DomainRenew<'a> {
     /// The data under the &lt;renew&gt; tag for the domain renewal
     #[serde(rename = "domain:renew")]
-    domain: DomainRenewRequestData,
+    domain: DomainRenewRequestData<'a>,
 }
 
 // Response
@@ -60,10 +60,10 @@ pub struct DomainRenew {
 #[derive(Deserialize, Debug)]
 pub struct DomainRenewResponseData {
     /// The name of the domain
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The new expiry date after renewal
     #[serde(rename = "exDate")]
-    pub expiring_at: Option<StringValue>,
+    pub expiring_at: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for domain renew response
diff --git a/src/domain/transfer.rs b/src/domain/transfer.rs
index 2e9863d..ee18044 100644
--- a/src/domain/transfer.rs
+++ b/src/domain/transfer.rs
@@ -5,15 +5,15 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for DomainTransfer {}
+impl<'a> Transaction<NoExtension> for DomainTransfer<'a> {}
 
-impl Command for DomainTransfer {
+impl<'a> Command for DomainTransfer<'a> {
     type Response = DomainTransferResponse;
     const COMMAND: &'static str = "transfer";
 }
 
-impl DomainTransfer {
-    pub fn new(name: &str, years: Option<u16>, auth_password: &str) -> Self {
+impl<'a> DomainTransfer<'a> {
+    pub fn new(name: &'a str, years: Option<u16>, auth_password: &'a str) -> Self {
         Self::build(
             "request",
             name,
@@ -22,7 +22,7 @@ impl DomainTransfer {
         )
     }
 
-    pub fn query(name: &str, auth_password: &str) -> Self {
+    pub fn query(name: &'a str, auth_password: &'a str) -> Self {
         Self::build(
             "query",
             name,
@@ -31,23 +31,23 @@ impl DomainTransfer {
         )
     }
 
-    pub fn approve(name: &str) -> Self {
+    pub fn approve(name: &'a str) -> Self {
         Self::build("approve", name, None, None)
     }
 
-    pub fn reject(name: &str) -> Self {
+    pub fn reject(name: &'a str) -> Self {
         Self::build("reject", name, None, None)
     }
 
-    pub fn cancel(name: &str) -> Self {
+    pub fn cancel(name: &'a str) -> Self {
         Self::build("cancel", name, None, None)
     }
 
     fn build(
-        operation: &str,
-        name: &str,
+        operation: &'a str,
+        name: &'a str,
         period: Option<Period>,
-        auth_info: Option<DomainAuthInfo>,
+        auth_info: Option<DomainAuthInfo<'a>>,
     ) -> Self {
         Self {
             operation: operation.to_string(),
@@ -65,13 +65,13 @@ impl DomainTransfer {
 
 /// Type for elements under the domain &lt;transfer&gt; tag
 #[derive(Serialize, Debug)]
-pub struct DomainTransferReqData {
+pub struct DomainTransferReqData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The name of the domain under transfer
     #[serde(rename = "domain:name")]
-    name: StringValue,
+    name: StringValue<'a>,
     /// The period of renewal upon a successful transfer
     /// Only applicable in case of a transfer request
     #[serde(rename = "domain:period")]
@@ -79,19 +79,19 @@ pub struct DomainTransferReqData {
     /// The authInfo for the domain under transfer
     /// Only applicable to domain transfer and domain transfer query requests
     #[serde(rename = "domain:authInfo")]
-    auth_info: Option<DomainAuthInfo>,
+    auth_info: Option<DomainAuthInfo<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;transfer&gt; command for domains
-pub struct DomainTransfer {
+pub struct DomainTransfer<'a> {
     /// The transfer operation to perform indicated by the 'op' attr
     /// The values are one of transfer or query
     #[serde(rename = "op")]
     operation: String,
     /// The data under the &lt;transfer&gt; tag in the transfer request
     #[serde(rename = "domain:transfer")]
-    domain: DomainTransferReqData,
+    domain: DomainTransferReqData<'a>,
 }
 
 // Response
@@ -100,25 +100,25 @@ pub struct DomainTransfer {
 #[derive(Deserialize, Debug)]
 pub struct DomainTransferResponseData {
     /// The domain name
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The domain transfer status
     #[serde(rename = "trStatus")]
-    pub transfer_status: StringValue,
+    pub transfer_status: StringValue<'static>,
     /// The epp user who requested the transfer
     #[serde(rename = "reID")]
-    pub requester_id: StringValue,
+    pub requester_id: StringValue<'static>,
     /// The transfer rquest date
     #[serde(rename = "reDate")]
-    pub requested_at: StringValue,
+    pub requested_at: StringValue<'static>,
     /// The epp user who should acknowledge the transfer request
     #[serde(rename = "acID")]
-    pub ack_id: StringValue,
+    pub ack_id: StringValue<'static>,
     /// THe date by which the acknowledgment should be made
     #[serde(rename = "acDate")]
-    pub ack_by: StringValue,
+    pub ack_by: StringValue<'static>,
     /// The domain expiry date
     #[serde(rename = "exDate")]
-    pub expiring_at: Option<StringValue>,
+    pub expiring_at: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for domain transfer response
diff --git a/src/domain/update.rs b/src/domain/update.rs
index cd66d3d..bae9922 100644
--- a/src/domain/update.rs
+++ b/src/domain/update.rs
@@ -8,15 +8,15 @@ use crate::{
 
 use serde::Serialize;
 
-impl Transaction<NoExtension> for DomainUpdate {}
+impl<'a> Transaction<NoExtension> for DomainUpdate<'a> {}
 
-impl Command for DomainUpdate {
+impl<'a> Command for DomainUpdate<'a> {
     type Response = ();
     const COMMAND: &'static str = "update";
 }
 
-impl DomainUpdate {
-    pub fn new(name: &str) -> Self {
+impl<'a> DomainUpdate<'a> {
+    pub fn new(name: &'a str) -> Self {
         Self {
             domain: DomainUpdateRequestData {
                 xmlns: XMLNS,
@@ -29,39 +29,39 @@ impl DomainUpdate {
     }
 
     /// Sets the data for the &lt;chg&gt; tag
-    pub fn info(&mut self, info: DomainChangeInfo) {
+    pub fn info(&mut self, info: DomainChangeInfo<'a>) {
         self.domain.change_info = Some(info);
     }
 
     /// Sets the data for the &lt;add&gt; tag
-    pub fn add(&mut self, add: DomainAddRemove) {
+    pub fn add(&mut self, add: DomainAddRemove<'a>) {
         self.domain.add = Some(add);
     }
 
     /// Sets the data for the &lt;rem&gt; tag
-    pub fn remove(&mut self, remove: DomainAddRemove) {
+    pub fn remove(&mut self, remove: DomainAddRemove<'a>) {
         self.domain.remove = Some(remove);
     }
 }
 
 /// Type for elements under the &lt;chg&gt; tag for domain update
 #[derive(Serialize, Debug)]
-pub struct DomainChangeInfo {
+pub struct DomainChangeInfo<'a> {
     /// The new registrant contact for the domain
     #[serde(rename = "domain:registrant")]
-    pub registrant: Option<StringValue>,
+    pub registrant: Option<StringValue<'a>>,
     /// The new auth info for the domain
     #[serde(rename = "domain:authInfo")]
-    pub auth_info: Option<DomainAuthInfo>,
+    pub auth_info: Option<DomainAuthInfo<'a>>,
 }
 
 /// Type for elements under the &lt;add&gt; and &lt;rem&gt; tags for domain update
 #[derive(Serialize, Debug)]
-pub struct DomainAddRemove {
+pub struct DomainAddRemove<'a> {
     /// The list of nameservers to add or remove
     /// Type T can be either a `HostObjList` or `HostAttrList`
     #[serde(rename = "domain:ns")]
-    pub ns: Option<HostList>,
+    pub ns: Option<HostList<'a>>,
     /// The list of contacts to add to or remove from the domain
     #[serde(rename = "domain:contact")]
     pub contacts: Option<Vec<DomainContact>>,
@@ -72,31 +72,31 @@ pub struct DomainAddRemove {
 
 /// Type for elements under the &lt;update&gt; tag for domain update
 #[derive(Serialize, Debug)]
-pub struct DomainUpdateRequestData {
+pub struct DomainUpdateRequestData<'a> {
     /// XML namespace for domain commands
     #[serde(rename = "xmlns:domain")]
-    pub xmlns: &'static str,
+    pub xmlns: &'a str,
     /// The name of the domain to update
     #[serde(rename = "domain:name")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
     /// `DomainAddRemove` Object containing the list of elements to be added
     /// to the domain
     #[serde(rename = "domain:add")]
-    pub add: Option<DomainAddRemove>,
+    pub add: Option<DomainAddRemove<'a>>,
     /// `DomainAddRemove` Object containing the list of elements to be removed
     /// from the domain
     #[serde(rename = "domain:rem")]
-    pub remove: Option<DomainAddRemove>,
+    pub remove: Option<DomainAddRemove<'a>>,
     /// The data under the &lt;chg&gt; tag for domain update
     #[serde(rename = "domain:chg")]
-    pub change_info: Option<DomainChangeInfo>,
+    pub change_info: Option<DomainChangeInfo<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;update&gt; command for domains
-pub struct DomainUpdate {
+pub struct DomainUpdate<'a> {
     #[serde(rename = "domain:update")]
-    pub domain: DomainUpdateRequestData,
+    pub domain: DomainUpdateRequestData<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/extensions/consolidate.rs b/src/extensions/consolidate.rs
index ac5d493..a118686 100644
--- a/src/extensions/consolidate.rs
+++ b/src/extensions/consolidate.rs
@@ -11,7 +11,7 @@ use crate::request::{Extension, Transaction};
 
 pub const XMLNS: &str = "http://www.verisign.com/epp/sync-1.0";
 
-impl Transaction<Update> for DomainUpdate {}
+impl<'a> Transaction<Update> for DomainUpdate<'a> {}
 
 impl Extension for Update {
     type Response = NoExtension;
@@ -84,7 +84,7 @@ pub struct UpdateData {
     pub xmlns: &'static str,
     /// The expiry date of the domain
     #[serde(rename = "sync:expMonthDay")]
-    pub exp: StringValue,
+    pub exp: StringValue<'static>,
 }
 
 #[cfg(test)]
diff --git a/src/extensions/namestore.rs b/src/extensions/namestore.rs
index 3ca651c..eafcb2b 100644
--- a/src/extensions/namestore.rs
+++ b/src/extensions/namestore.rs
@@ -23,29 +23,29 @@ pub const XMLNS: &str = "http://www.verisign-grs.com/epp/namestoreExt-1.1";
 
 // Contact
 
-impl Transaction<NameStore> for ContactCheck {}
-impl Transaction<NameStore> for ContactCreate {}
-impl Transaction<NameStore> for ContactDelete {}
-impl Transaction<NameStore> for ContactInfo {}
-impl Transaction<NameStore> for ContactUpdate {}
+impl<'a> Transaction<NameStore> for ContactCheck<'a> {}
+impl<'a> Transaction<NameStore> for ContactCreate<'a> {}
+impl<'a> Transaction<NameStore> for ContactDelete<'a> {}
+impl<'a> Transaction<NameStore> for ContactInfo<'a> {}
+impl<'a> Transaction<NameStore> for ContactUpdate<'a> {}
 
 // Domain
 
-impl Transaction<NameStore> for DomainCheck {}
-impl Transaction<NameStore> for DomainCreate {}
-impl Transaction<NameStore> for DomainDelete {}
-impl Transaction<NameStore> for DomainInfo {}
-impl Transaction<NameStore> for DomainRenew {}
-impl Transaction<NameStore> for DomainTransfer {}
-impl Transaction<NameStore> for DomainUpdate {}
+impl<'a> Transaction<NameStore> for DomainCheck<'a> {}
+impl<'a> Transaction<NameStore> for DomainCreate<'a> {}
+impl<'a> Transaction<NameStore> for DomainDelete<'a> {}
+impl<'a> Transaction<NameStore> for DomainInfo<'a> {}
+impl<'a> Transaction<NameStore> for DomainRenew<'a> {}
+impl<'a> Transaction<NameStore> for DomainTransfer<'a> {}
+impl<'a> Transaction<NameStore> for DomainUpdate<'a> {}
 
 // Host
 
-impl Transaction<NameStore> for HostCheck {}
-impl Transaction<NameStore> for HostCreate {}
-impl Transaction<NameStore> for HostDelete {}
-impl Transaction<NameStore> for HostInfo {}
-impl Transaction<NameStore> for HostUpdate {}
+impl<'a> Transaction<NameStore> for HostCheck<'a> {}
+impl<'a> Transaction<NameStore> for HostCreate<'a> {}
+impl<'a> Transaction<NameStore> for HostDelete<'a> {}
+impl<'a> Transaction<NameStore> for HostInfo<'a> {}
+impl<'a> Transaction<NameStore> for HostUpdate<'a> {}
 
 impl NameStore {
     /// Create a new RGP restore report request
@@ -53,7 +53,7 @@ impl NameStore {
         NameStore {
             data: NameStoreData {
                 xmlns: XMLNS.to_string(),
-                subproduct: subproduct.into(),
+                subproduct: subproduct.to_owned().into(),
             },
         }
     }
@@ -78,7 +78,7 @@ pub struct NameStoreData {
     pub xmlns: String,
     /// The object holding the list of domains to be checked
     #[serde(rename = "namestoreExt:subProduct", alias = "subProduct")]
-    pub subproduct: StringValue,
+    pub subproduct: StringValue<'static>,
 }
 
 #[cfg(test)]
diff --git a/src/extensions/rgp/report.rs b/src/extensions/rgp/report.rs
index 3131f80..9af18ae 100644
--- a/src/extensions/rgp/report.rs
+++ b/src/extensions/rgp/report.rs
@@ -8,22 +8,22 @@ use serde::Serialize;
 
 use super::{Update, XMLNS};
 
-impl Transaction<Update<RgpRestoreReport>> for DomainUpdate {}
+impl<'a> Transaction<Update<RgpRestoreReport<'a>>> for DomainUpdate<'a> {}
 
-impl RgpRestoreReport {
+impl<'a> RgpRestoreReport<'a> {
     /// Create a new RGP restore report request
     pub fn new(
-        pre_data: &str,
-        post_data: &str,
+        pre_data: &'a str,
+        post_data: &'a str,
         deleted_at: DateTime<Utc>,
         restored_at: DateTime<Utc>,
-        restore_reason: &str,
-        statements: &[&str],
-        other: &str,
-    ) -> RgpRestoreReport {
+        restore_reason: &'a str,
+        statements: &[&'a str],
+        other: &'a str,
+    ) -> Self {
         let statements = statements.iter().map(|&s| s.into()).collect();
 
-        RgpRestoreReport {
+        Self {
             xmlns: XMLNS,
             restore: RgpRestoreReportSection {
                 op: "report".to_string(),
@@ -45,55 +45,55 @@ impl RgpRestoreReport {
     }
 }
 
-impl Extension for Update<RgpRestoreReport> {
+impl<'a> Extension for Update<RgpRestoreReport<'a>> {
     type Response = NoExtension;
 }
 
 /// Type corresponding to the &lt;report&gt; section in the EPP rgp restore extension
 #[derive(Serialize, Debug)]
-pub struct RgpRestoreReportSectionData {
+pub struct RgpRestoreReportSectionData<'a> {
     /// The pre-delete registration date
     #[serde(rename = "rgp:preData")]
-    pre_data: StringValue,
+    pre_data: StringValue<'a>,
     /// The post-delete registration date
     #[serde(rename = "rgp:postData")]
-    post_data: StringValue,
+    post_data: StringValue<'a>,
     /// The domain deletion date
     #[serde(rename = "rgp:delTime")]
-    deleted_at: StringValue,
+    deleted_at: StringValue<'a>,
     /// The domain restore request date
     #[serde(rename = "rgp:resTime")]
-    restored_at: StringValue,
+    restored_at: StringValue<'a>,
     /// The reason for domain restoration
     #[serde(rename = "rgp:resReason")]
-    restore_reason: StringValue,
+    restore_reason: StringValue<'a>,
     /// The registrar's statements on the domain restoration
     #[serde(rename = "rgp:statement")]
-    statements: Vec<StringValue>,
+    statements: Vec<StringValue<'a>>,
     /// Other remarks for domain restoration
     #[serde(rename = "rgp:other")]
-    other: StringValue,
+    other: StringValue<'a>,
 }
 
 /// Type corresponding to the &lt;restore&gt; section in the rgp restore extension
 #[derive(Serialize, Debug)]
-pub struct RgpRestoreReportSection {
+pub struct RgpRestoreReportSection<'a> {
     /// The value of the op attribute for the &lt;restore&gt; tag
     op: String,
     /// Data for the &lt;report&gt; tag
     #[serde(rename = "rgp:report")]
-    report: RgpRestoreReportSectionData,
+    report: RgpRestoreReportSectionData<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;check&gt; command for domains
-pub struct RgpRestoreReport {
+pub struct RgpRestoreReport<'a> {
     /// XML namespace for the RGP restore extension
     #[serde(rename = "xmlns:rgp")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The object holding the list of domains to be checked
     #[serde(rename = "rgp:restore")]
-    restore: RgpRestoreReportSection,
+    restore: RgpRestoreReportSection<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/extensions/rgp/request.rs b/src/extensions/rgp/request.rs
index e842f9a..bd488f0 100644
--- a/src/extensions/rgp/request.rs
+++ b/src/extensions/rgp/request.rs
@@ -9,9 +9,9 @@ use serde::{Deserialize, Serialize};
 
 use super::{Update, XMLNS};
 
-impl Transaction<Update<RgpRestoreRequest>> for DomainUpdate {}
+impl<'a> Transaction<Update<RgpRestoreRequest>> for DomainUpdate<'a> {}
 
-impl Transaction<Update<RgpRestoreRequest>> for DomainInfo {}
+impl<'a> Transaction<Update<RgpRestoreRequest>> for DomainInfo<'a> {}
 
 impl Extension for Update<RgpRestoreRequest> {
     type Response = Update<RgpRequestResponse>;
diff --git a/src/hello.rs b/src/hello.rs
index 723d177..08feda7 100644
--- a/src/hello.rs
+++ b/src/hello.rs
@@ -33,22 +33,22 @@ impl EppXml for HelloDocument {}
 /// Type for data within the <svcMenu> section of an EPP greeting
 #[derive(Debug, PartialEq)]
 pub struct ServiceMenu {
-    pub options: Options,
-    pub services: Services,
+    pub options: Options<'static>,
+    pub services: Services<'static>,
 }
 
 /// Simplified service menu type for deserialization to `ServiceMenu` type from EPP greeting XML
 #[derive(Deserialize, Debug, PartialEq)]
 struct FlattenedServiceMenu {
-    pub version: StringValue,
-    pub lang: StringValue,
+    pub version: StringValue<'static>,
+    pub lang: StringValue<'static>,
     #[serde(rename = "objURI")]
-    pub obj_uris: Vec<StringValue>,
+    pub obj_uris: Vec<StringValue<'static>>,
     #[serde(rename = "svcExtension")]
-    pub svc_ext: Option<ServiceExtension>,
+    pub svc_ext: Option<ServiceExtension<'static>>,
 }
 
-impl<'de> Deserialize<'de> for ServiceMenu {
+impl<'a, 'de: 'a> Deserialize<'de> for ServiceMenu {
     /// Deserializes the <svcMenu> data to the `ServiceMenu` type
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -238,14 +238,14 @@ pub struct Statement {
 #[derive(Deserialize, Debug, PartialEq)]
 pub struct Absolute {
     #[serde(rename = "$value")]
-    pub absolute: StringValue,
+    pub absolute: StringValue<'static>,
 }
 
 /// Type corresponding to <relative> value in the EPP greeting XML
 #[derive(Deserialize, Debug, PartialEq)]
 pub struct Relative {
     #[serde(rename = "$value")]
-    pub relative: StringValue,
+    pub relative: StringValue<'static>,
 }
 
 /// Type corresponding to possible <expiry> type values
diff --git a/src/host/check.rs b/src/host/check.rs
index 3f23f7e..ba171ce 100644
--- a/src/host/check.rs
+++ b/src/host/check.rs
@@ -7,15 +7,15 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for HostCheck {}
+impl<'a> Transaction<NoExtension> for HostCheck<'a> {}
 
-impl Command for HostCheck {
+impl<'a> Command for HostCheck<'a> {
     type Response = HostCheckResponse;
     const COMMAND: &'static str = "check";
 }
 
-impl HostCheck {
-    pub fn new(hosts: &[&str]) -> Self {
+impl<'a> HostCheck<'a> {
+    pub fn new(hosts: &[&'a str]) -> Self {
         let hosts = hosts.iter().map(|&d| d.into()).collect();
 
         Self {
@@ -31,21 +31,21 @@ impl HostCheck {
 
 /// Type for data under the host &lt;check&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostList {
+pub struct HostList<'a> {
     /// XML namespace for host commands
     #[serde(rename = "xmlns:host")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// List of hosts to be checked for availability
     #[serde(rename = "host:name")]
-    pub hosts: Vec<StringValue>,
+    pub hosts: Vec<StringValue<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;check&gt; command for hosts
-pub struct HostCheck {
+pub struct HostCheck<'a> {
     /// The instance holding the list of hosts to be checked
     #[serde(rename = "host:check")]
-    list: HostList,
+    list: HostList<'a>,
 }
 
 // Response
@@ -55,7 +55,7 @@ pub struct HostCheck {
 pub struct HostAvailable {
     /// The host name
     #[serde(rename = "$value")]
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The host (un)availability
     #[serde(rename = "avail")]
     pub available: u16,
@@ -68,7 +68,7 @@ pub struct HostCheckDataItem {
     #[serde(rename = "name")]
     pub host: HostAvailable,
     /// The reason for (un)availability
-    pub reason: Option<StringValue>,
+    pub reason: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;chkData&gt; tag for host check response
diff --git a/src/host/create.rs b/src/host/create.rs
index a03c475..048d557 100644
--- a/src/host/create.rs
+++ b/src/host/create.rs
@@ -5,15 +5,15 @@ use crate::common::{HostAddr, NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for HostCreate {}
+impl<'a> Transaction<NoExtension> for HostCreate<'a> {}
 
-impl Command for HostCreate {
+impl<'a> Command for HostCreate<'a> {
     type Response = HostCreateResponse;
     const COMMAND: &'static str = "create";
 }
 
-impl HostCreate {
-    pub fn new(host: &str, addresses: Vec<HostAddr>) -> Self {
+impl<'a> HostCreate<'a> {
+    pub fn new(host: &'a str, addresses: Vec<HostAddr>) -> Self {
         Self {
             host: HostCreateRequestData {
                 xmlns: XMLNS,
@@ -28,13 +28,13 @@ impl HostCreate {
 
 /// Type for data under the host &lt;create&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostCreateRequestData {
+pub struct HostCreateRequestData<'a> {
     /// XML namespace for host commands
     #[serde(rename = "xmlns:host")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The name of the host to be created
     #[serde(rename = "host:name")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
     /// The list of IP addresses for the host
     #[serde(rename = "host:addr")]
     pub addresses: Option<Vec<HostAddr>>,
@@ -42,10 +42,10 @@ pub struct HostCreateRequestData {
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;create&gt; command for hosts
-pub struct HostCreate {
+pub struct HostCreate<'a> {
     /// The instance holding the data for the host to be created
     #[serde(rename = "host:create")]
-    host: HostCreateRequestData,
+    host: HostCreateRequestData<'a>,
 }
 
 // Response
@@ -54,10 +54,10 @@ pub struct HostCreate {
 #[derive(Deserialize, Debug)]
 pub struct HostCreateData {
     /// The host name
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The host creation date
     #[serde(rename = "crDate")]
-    pub created_at: StringValue,
+    pub created_at: StringValue<'static>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for host check response
diff --git a/src/host/delete.rs b/src/host/delete.rs
index c90a2c0..7849c0c 100644
--- a/src/host/delete.rs
+++ b/src/host/delete.rs
@@ -5,15 +5,15 @@ use crate::common::{NoExtension, StringValue};
 use crate::request::{Command, Transaction};
 use serde::Serialize;
 
-impl Transaction<NoExtension> for HostDelete {}
+impl<'a> Transaction<NoExtension> for HostDelete<'a> {}
 
-impl Command for HostDelete {
+impl<'a> Command for HostDelete<'a> {
     type Response = ();
     const COMMAND: &'static str = "delete";
 }
 
-impl HostDelete {
-    pub fn new(name: &str) -> Self {
+impl<'a> HostDelete<'a> {
+    pub fn new(name: &'a str) -> Self {
         Self {
             host: HostDeleteRequestData {
                 xmlns: XMLNS,
@@ -25,21 +25,21 @@ impl HostDelete {
 
 /// Type for data under the host &lt;delete&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostDeleteRequestData {
+pub struct HostDeleteRequestData<'a> {
     /// XML namespace for host commands
     #[serde(rename = "xmlns:host")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The host to be deleted
     #[serde(rename = "host:name")]
-    name: StringValue,
+    name: StringValue<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;delete&gt; command for hosts
-pub struct HostDelete {
+pub struct HostDelete<'a> {
     /// The instance holding the data for the host to be deleted
     #[serde(rename = "host:delete")]
-    host: HostDeleteRequestData,
+    host: HostDeleteRequestData<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/host/info.rs b/src/host/info.rs
index 13b1035..4245fb0 100644
--- a/src/host/info.rs
+++ b/src/host/info.rs
@@ -5,15 +5,15 @@ use crate::common::{HostAddr, NoExtension, ObjectStatus, StringValue};
 use crate::request::{Command, Transaction};
 use serde::{Deserialize, Serialize};
 
-impl Transaction<NoExtension> for HostInfo {}
+impl<'a> Transaction<NoExtension> for HostInfo<'a> {}
 
-impl Command for HostInfo {
+impl<'a> Command for HostInfo<'a> {
     type Response = HostInfoResponse;
     const COMMAND: &'static str = "info";
 }
 
-impl HostInfo {
-    pub fn new(name: &str) -> Self {
+impl<'a> HostInfo<'a> {
+    pub fn new(name: &'a str) -> Self {
         Self {
             info: HostInfoRequestData {
                 xmlns: XMLNS,
@@ -27,21 +27,21 @@ impl HostInfo {
 
 /// Type for data under the host &lt;info&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostInfoRequestData {
+pub struct HostInfoRequestData<'a> {
     /// XML namespace for host commands
     #[serde(rename = "xmlns:host")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The name of the host to be queried
     #[serde(rename = "host:name")]
-    name: StringValue,
+    name: StringValue<'a>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;info&gt; command for hosts
-pub struct HostInfo {
+pub struct HostInfo<'a> {
     /// The instance holding the data for the host query
     #[serde(rename = "host:info")]
-    info: HostInfoRequestData,
+    info: HostInfoRequestData<'a>,
 }
 
 // Response
@@ -50,9 +50,9 @@ pub struct HostInfo {
 #[derive(Deserialize, Debug)]
 pub struct HostInfoResponseData {
     /// The host name
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The host ROID
-    pub roid: StringValue,
+    pub roid: StringValue<'static>,
     /// The list of host statuses
     #[serde(rename = "status")]
     pub statuses: Vec<ObjectStatus>,
@@ -61,22 +61,22 @@ pub struct HostInfoResponseData {
     pub addresses: Vec<HostAddr>,
     /// The epp user to whom the host belongs
     #[serde(rename = "clID")]
-    pub client_id: StringValue,
+    pub client_id: StringValue<'static>,
     /// THe epp user that created the host
     #[serde(rename = "crID")]
-    pub creator_id: StringValue,
+    pub creator_id: StringValue<'static>,
     /// The host creation date
     #[serde(rename = "crDate")]
-    pub created_at: StringValue,
+    pub created_at: StringValue<'static>,
     /// The epp user that last updated the host
     #[serde(rename = "upID")]
-    pub updater_id: Option<StringValue>,
+    pub updater_id: Option<StringValue<'static>>,
     /// The host last update date
     #[serde(rename = "upDate")]
-    pub updated_at: Option<StringValue>,
+    pub updated_at: Option<StringValue<'static>>,
     /// The host transfer date
     #[serde(rename = "trDate")]
-    pub transferred_at: Option<StringValue>,
+    pub transferred_at: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for host info response
diff --git a/src/host/update.rs b/src/host/update.rs
index 2b35615..f0bd4ae 100644
--- a/src/host/update.rs
+++ b/src/host/update.rs
@@ -5,15 +5,15 @@ use crate::common::{HostAddr, NoExtension, ObjectStatus, StringValue};
 use crate::request::{Command, Transaction};
 use serde::Serialize;
 
-impl Transaction<NoExtension> for HostUpdate {}
+impl<'a> Transaction<NoExtension> for HostUpdate<'a> {}
 
-impl Command for HostUpdate {
+impl<'a> Command for HostUpdate<'a> {
     type Response = ();
     const COMMAND: &'static str = "update";
 }
 
-impl HostUpdate {
-    pub fn new(name: &str) -> Self {
+impl<'a> HostUpdate<'a> {
+    pub fn new(name: &'a str) -> Self {
         Self {
             host: HostUpdateRequestData {
                 xmlns: XMLNS,
@@ -26,7 +26,7 @@ impl HostUpdate {
     }
 
     /// Sets the data for the &lt;chg&gt; element of the host update
-    pub fn info(&mut self, info: HostChangeInfo) {
+    pub fn info(&mut self, info: HostChangeInfo<'a>) {
         self.host.change_info = Some(info);
     }
 
@@ -43,10 +43,10 @@ impl HostUpdate {
 
 /// Type for data under the &lt;chg&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostChangeInfo {
+pub struct HostChangeInfo<'a> {
     /// The new name for the host
     #[serde(rename = "host:name")]
-    pub name: StringValue,
+    pub name: StringValue<'a>,
 }
 
 /// Type for data under the &lt;add&gt; and &lt;rem&gt; tags
@@ -62,13 +62,13 @@ pub struct HostAddRemove {
 
 /// Type for data under the host &lt;update&gt; tag
 #[derive(Serialize, Debug)]
-pub struct HostUpdateRequestData {
+pub struct HostUpdateRequestData<'a> {
     /// XML namespace for host commands
     #[serde(rename = "xmlns:host")]
-    xmlns: &'static str,
+    xmlns: &'a str,
     /// The name of the host
     #[serde(rename = "host:name")]
-    name: StringValue,
+    name: StringValue<'a>,
     /// The IP addresses and statuses to be added to the host
     #[serde(rename = "host:add")]
     add: Option<HostAddRemove>,
@@ -77,15 +77,15 @@ pub struct HostUpdateRequestData {
     remove: Option<HostAddRemove>,
     /// The host details that need to be updated
     #[serde(rename = "host:chg")]
-    change_info: Option<HostChangeInfo>,
+    change_info: Option<HostChangeInfo<'a>>,
 }
 
 #[derive(Serialize, Debug)]
 /// Type for EPP XML &lt;update&gt; command for hosts
-pub struct HostUpdate {
+pub struct HostUpdate<'a> {
     /// The instance holding the data for the host to be updated
     #[serde(rename = "host:update")]
-    host: HostUpdateRequestData,
+    host: HostUpdateRequestData<'a>,
 }
 
 #[cfg(test)]
diff --git a/src/login.rs b/src/login.rs
index ab2e4c6..1060a89 100644
--- a/src/login.rs
+++ b/src/login.rs
@@ -8,27 +8,27 @@ use crate::{
     request::{Command, Transaction, EPP_LANG, EPP_VERSION},
 };
 
-impl Transaction<NoExtension> for Login {}
+impl<'a> Transaction<NoExtension> for Login<'a> {}
 
 #[derive(Serialize, Debug, PartialEq)]
 /// Type corresponding to the &lt;login&gt; tag in an EPP XML login request
-pub struct Login {
+pub struct Login<'a> {
     /// The username to use for the login
     #[serde(rename(serialize = "clID", deserialize = "clID"))]
-    username: StringValue,
+    username: StringValue<'a>,
     /// The password to use for the login
     #[serde(rename = "pw", default)]
-    password: StringValue,
+    password: StringValue<'a>,
     /// Data under the <options> tag
-    options: Options,
+    options: Options<'a>,
     /// Data under the <svcs> tag
     #[serde(rename = "svcs")]
-    services: Services,
+    services: Services<'a>,
 }
 
-impl Login {
-    pub fn new(username: &str, password: &str, ext_uris: Option<Vec<String>>) -> Self {
-        let ext_uris = ext_uris.map(|uris| uris.iter().map(|u| u.as_str().into()).collect());
+impl<'a> Login<'a> {
+    pub fn new(username: &'a str, password: &'a str, ext_uris: Option<Vec<&'a str>>) -> Self {
+        let ext_uris = ext_uris.map(|uris| uris.into_iter().map(|u| u.into()).collect());
 
         Self {
             username: username.into(),
@@ -49,17 +49,17 @@ impl Login {
     }
 
     /// Sets the <options> tag data
-    pub fn options(&mut self, options: Options) {
+    pub fn options(&mut self, options: Options<'a>) {
         self.options = options;
     }
 
     /// Sets the <svcs> tag data
-    pub fn services(&mut self, services: Services) {
+    pub fn services(&mut self, services: Services<'a>) {
         self.services = services;
     }
 }
 
-impl Command for Login {
+impl<'a> Command for Login<'a> {
     type Response = ();
     const COMMAND: &'static str = "login";
 }
@@ -72,9 +72,7 @@ mod tests {
 
     #[test]
     fn command() {
-        let ext_uris = Some(vec![
-            "http://schema.ispapi.net/epp/xml/keyvalue-1.0".to_string()
-        ]);
+        let ext_uris = Some(vec!["http://schema.ispapi.net/epp/xml/keyvalue-1.0"]);
 
         let xml = get_xml("request/login.xml").unwrap();
         let object = Login::new("username", "password", ext_uris);
diff --git a/src/message/poll.rs b/src/message/poll.rs
index f2c0500..977281c 100644
--- a/src/message/poll.rs
+++ b/src/message/poll.rs
@@ -34,25 +34,25 @@ impl Default for MessagePoll {
 pub struct MessageDomainTransferData {
     /// The name of the domain under transfer
     #[serde(rename = "domain:name", alias = "name")]
-    pub name: StringValue,
+    pub name: StringValue<'static>,
     /// The domain transfer status
     #[serde(rename = "domain:trStatus", alias = "trStatus")]
-    pub transfer_status: StringValue,
+    pub transfer_status: StringValue<'static>,
     /// The epp user who requested the transfer
     #[serde(rename = "domain:reID", alias = "reID")]
-    pub requester_id: StringValue,
+    pub requester_id: StringValue<'static>,
     /// The date of the transfer request
     #[serde(rename = "domain:reDate", alias = "reDate")]
-    pub requested_at: StringValue,
+    pub requested_at: StringValue<'static>,
     /// The epp user who should acknowledge the transfer request
     #[serde(rename = "domain:acID", alias = "acID")]
-    pub ack_id: StringValue,
+    pub ack_id: StringValue<'static>,
     /// The date by which the transfer request should be acknowledged
     #[serde(rename = "domain:acDate", alias = "acDate")]
-    pub ack_by: StringValue,
+    pub ack_by: StringValue<'static>,
     /// The domain expiry date
     #[serde(rename = "domain:exDate", alias = "exDate")]
-    pub expiring_at: Option<StringValue>,
+    pub expiring_at: Option<StringValue<'static>>,
 }
 
 /// Type that represents the &lt;resData&gt; tag for message poll response
diff --git a/src/request.rs b/src/request.rs
index eaa3dbe..624c5c4 100644
--- a/src/request.rs
+++ b/src/request.rs
@@ -60,7 +60,7 @@ pub struct CommandWrapper<'a, D, E> {
     pub data: &'a D,
     /// The client TRID
     pub extension: Option<&'a E>,
-    pub client_tr_id: StringValue,
+    pub client_tr_id: StringValue<'a>,
 }
 
 impl<'a, D: Serialize, E: Serialize> Serialize for CommandWrapper<'a, D, E> {
diff --git a/src/response.rs b/src/response.rs
index 2c6e70a..561c9d1 100644
--- a/src/response.rs
+++ b/src/response.rs
@@ -26,7 +26,7 @@ pub struct ExtValue {
     /// Data under the <value> tag
     pub value: ResultValue,
     /// Data under the <reason> tag
-    pub reason: StringValue,
+    pub reason: StringValue<'static>,
 }
 
 /// Type corresponding to the <result> tag in an EPP response XML
@@ -36,7 +36,7 @@ pub struct EppResult {
     pub code: u16,
     /// The result message
     #[serde(rename = "msg")]
-    pub message: StringValue,
+    pub message: StringValue<'static>,
     /// Data under the <extValue> tag
     #[serde(rename = "extValue")]
     pub ext_value: Option<ExtValue>,
@@ -47,10 +47,10 @@ pub struct EppResult {
 pub struct ResponseTRID {
     /// The client TRID
     #[serde(rename = "clTRID")]
-    pub client_tr_id: Option<StringValue>,
+    pub client_tr_id: Option<StringValue<'static>>,
     /// The server TRID
     #[serde(rename = "svTRID")]
-    pub server_tr_id: StringValue,
+    pub server_tr_id: StringValue<'static>,
 }
 
 /// Type corresponding to the <msgQ> tag in an EPP response XML
@@ -62,10 +62,10 @@ pub struct MessageQueue {
     pub id: String,
     /// The message date
     #[serde(rename = "qDate")]
-    pub date: Option<StringValue>,
+    pub date: Option<StringValue<'static>>,
     /// The message text
     #[serde(rename = "msg")]
-    pub message: Option<StringValue>,
+    pub message: Option<StringValue<'static>>,
 }
 
 #[derive(Deserialize, Debug, PartialEq)]