diff --git a/code_generator/src/main.rs b/code_generator/src/main.rs
index 404e720..68f0ebc 100644
--- a/code_generator/src/main.rs
+++ b/code_generator/src/main.rs
@@ -210,9 +210,6 @@ pub const {type_identifier}: AVPType = {type_value};
 pub fn delete_{method_identifier}(packet: &mut Packet) {{
     packet.delete({type_identifier});
 }}
-pub fn lookup_{method_identifier}(packet: &Packet) -> Option<&AVP> {{
-    packet.lookup({type_identifier})
-}}
 pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&AVP> {{
     packet.lookup_all({type_identifier})
 }}
@@ -233,6 +230,9 @@ fn generate_string_attribute_code(
         "pub fn add_{method_identifier}(packet: &mut Packet, value: &str) {{
     packet.add(AVP::encode_string({type_identifier}, value));
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<String, AVPError>> {{
+    packet.lookup({type_identifier}).map(|v| v.decode_string())
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -250,6 +250,9 @@ fn generate_user_password_attribute_code(
     packet.add(AVP::encode_user_password({type_identifier}, value, packet.get_secret(), packet.get_authenticator())?);
     Ok(())
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {{
+    packet.lookup({type_identifier}).map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -266,6 +269,9 @@ fn generate_octets_attribute_code(
         "pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) {{
     packet.add(AVP::encode_bytes({type_identifier}, value));
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Vec<u8>> {{
+    packet.lookup({type_identifier}).map(|v| v.decode_bytes())
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -282,6 +288,9 @@ fn generate_ipaddr_attribute_code(
         "pub fn add_{method_identifier}(packet: &mut Packet, value: &Ipv4Addr) {{
     packet.add(AVP::encode_ipv4({type_identifier}, value));
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {{
+    packet.lookup({type_identifier}).map(|v| v.decode_ipv4())
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -298,6 +307,9 @@ fn generate_integer_attribute_code(
         "pub fn add_{method_identifier}(packet: &mut Packet, value: u32) {{
     packet.add(AVP::encode_u32({type_identifier}, value));
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<u32, AVPError>> {{
+    packet.lookup({type_identifier}).map(|v| v.decode_u32())
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
@@ -315,6 +327,9 @@ fn generate_value_defined_integer_attribute_code(
         "pub fn add_{method_identifier}(packet: &mut Packet, value: {value_type}) {{
     packet.add(AVP::encode_u32({type_identifier}, value as u32));
 }}
+pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<{value_type}, AVPError>> {{
+    packet.lookup({type_identifier}).map(|v| Ok(v.decode_u32()? as {value_type}))
+}}
 ",
         method_identifier = method_identifier,
         type_identifier = type_identifier,
diff --git a/examples/server.rs b/examples/server.rs
index 49385c9..a4aa428 100644
--- a/examples/server.rs
+++ b/examples/server.rs
@@ -46,14 +46,8 @@ impl RequestHandler<(), io::Error> for MyRequestHandler {
         let maybe_user_name_attr = rfc2865::lookup_user_name(req_packet);
         let maybe_user_password_attr = rfc2865::lookup_user_password(req_packet);
 
-        let user_name = maybe_user_name_attr.unwrap().decode_string().unwrap();
-        let user_password = String::from_utf8(
-            maybe_user_password_attr
-                .unwrap()
-                .decode_user_password(req_packet.get_secret(), req_packet.get_authenticator())
-                .unwrap(),
-        )
-        .unwrap();
+        let user_name = maybe_user_name_attr.unwrap().unwrap();
+        let user_password = String::from_utf8(maybe_user_password_attr.unwrap().unwrap()).unwrap();
         let code = if user_name == "admin" && user_password == "p@ssw0rd" {
             Code::AccessAccept
         } else {
diff --git a/src/rfc2865.rs b/src/rfc2865.rs
index a5a5647..af755e9 100644
--- a/src/rfc2865.rs
+++ b/src/rfc2865.rs
@@ -83,23 +83,20 @@ pub const USER_NAME_TYPE: AVPType = 1;
 pub fn delete_user_name(packet: &mut Packet) {
     packet.delete(USER_NAME_TYPE);
 }
-pub fn lookup_user_name(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(USER_NAME_TYPE)
-}
 pub fn lookup_all_user_name(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(USER_NAME_TYPE)
 }
 pub fn add_user_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(USER_NAME_TYPE, value));
 }
+pub fn lookup_user_name(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet.lookup(USER_NAME_TYPE).map(|v| v.decode_string())
+}
 
 pub const USER_PASSWORD_TYPE: AVPType = 2;
 pub fn delete_user_password(packet: &mut Packet) {
     packet.delete(USER_PASSWORD_TYPE);
 }
-pub fn lookup_user_password(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(USER_PASSWORD_TYPE)
-}
 pub fn lookup_all_user_password(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(USER_PASSWORD_TYPE)
 }
@@ -112,308 +109,330 @@ pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPErr
     )?);
     Ok(())
 }
+pub fn lookup_user_password(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
+    packet
+        .lookup(USER_PASSWORD_TYPE)
+        .map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
+}
 
 pub const CHAP_PASSWORD_TYPE: AVPType = 3;
 pub fn delete_chap_password(packet: &mut Packet) {
     packet.delete(CHAP_PASSWORD_TYPE);
 }
-pub fn lookup_chap_password(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CHAP_PASSWORD_TYPE)
-}
 pub fn lookup_all_chap_password(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CHAP_PASSWORD_TYPE)
 }
 pub fn add_chap_password(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CHAP_PASSWORD_TYPE, value));
 }
+pub fn lookup_chap_password(packet: &Packet) -> Option<Vec<u8>> {
+    packet.lookup(CHAP_PASSWORD_TYPE).map(|v| v.decode_bytes())
+}
 
 pub const NAS_IP_ADDRESS_TYPE: AVPType = 4;
 pub fn delete_nas_ip_address(packet: &mut Packet) {
     packet.delete(NAS_IP_ADDRESS_TYPE);
 }
-pub fn lookup_nas_ip_address(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(NAS_IP_ADDRESS_TYPE)
-}
 pub fn lookup_all_nas_ip_address(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(NAS_IP_ADDRESS_TYPE)
 }
 pub fn add_nas_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(NAS_IP_ADDRESS_TYPE, value));
 }
+pub fn lookup_nas_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
+    packet.lookup(NAS_IP_ADDRESS_TYPE).map(|v| v.decode_ipv4())
+}
 
 pub const NAS_PORT_TYPE: AVPType = 5;
 pub fn delete_nas_port(packet: &mut Packet) {
     packet.delete(NAS_PORT_TYPE);
 }
-pub fn lookup_nas_port(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(NAS_PORT_TYPE)
-}
 pub fn lookup_all_nas_port(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(NAS_PORT_TYPE)
 }
 pub fn add_nas_port(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(NAS_PORT_TYPE, value));
 }
+pub fn lookup_nas_port(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(NAS_PORT_TYPE).map(|v| v.decode_u32())
+}
 
 pub const SERVICE_TYPE_TYPE: AVPType = 6;
 pub fn delete_service_type(packet: &mut Packet) {
     packet.delete(SERVICE_TYPE_TYPE);
 }
-pub fn lookup_service_type(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(SERVICE_TYPE_TYPE)
-}
 pub fn lookup_all_service_type(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(SERVICE_TYPE_TYPE)
 }
 pub fn add_service_type(packet: &mut Packet, value: ServiceType) {
     packet.add(AVP::encode_u32(SERVICE_TYPE_TYPE, value as u32));
 }
+pub fn lookup_service_type(packet: &Packet) -> Option<Result<ServiceType, AVPError>> {
+    packet
+        .lookup(SERVICE_TYPE_TYPE)
+        .map(|v| Ok(v.decode_u32()? as ServiceType))
+}
 
 pub const FRAMED_PROTOCOL_TYPE: AVPType = 7;
 pub fn delete_framed_protocol(packet: &mut Packet) {
     packet.delete(FRAMED_PROTOCOL_TYPE);
 }
-pub fn lookup_framed_protocol(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_PROTOCOL_TYPE)
-}
 pub fn lookup_all_framed_protocol(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_PROTOCOL_TYPE)
 }
 pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) {
     packet.add(AVP::encode_u32(FRAMED_PROTOCOL_TYPE, value as u32));
 }
+pub fn lookup_framed_protocol(packet: &Packet) -> Option<Result<FramedProtocol, AVPError>> {
+    packet
+        .lookup(FRAMED_PROTOCOL_TYPE)
+        .map(|v| Ok(v.decode_u32()? as FramedProtocol))
+}
 
 pub const FRAMED_IP_ADDRESS_TYPE: AVPType = 8;
 pub fn delete_framed_ip_address(packet: &mut Packet) {
     packet.delete(FRAMED_IP_ADDRESS_TYPE);
 }
-pub fn lookup_framed_ip_address(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_IP_ADDRESS_TYPE)
-}
 pub fn lookup_all_framed_ip_address(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_IP_ADDRESS_TYPE)
 }
 pub fn add_framed_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IP_ADDRESS_TYPE, value));
 }
+pub fn lookup_framed_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
+    packet
+        .lookup(FRAMED_IP_ADDRESS_TYPE)
+        .map(|v| v.decode_ipv4())
+}
 
 pub const FRAMED_IP_NETMASK_TYPE: AVPType = 9;
 pub fn delete_framed_ip_netmask(packet: &mut Packet) {
     packet.delete(FRAMED_IP_NETMASK_TYPE);
 }
-pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_IP_NETMASK_TYPE)
-}
 pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_IP_NETMASK_TYPE)
 }
 pub fn add_framed_ip_netmask(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IP_NETMASK_TYPE, value));
 }
+pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
+    packet
+        .lookup(FRAMED_IP_NETMASK_TYPE)
+        .map(|v| v.decode_ipv4())
+}
 
 pub const FRAMED_ROUTING_TYPE: AVPType = 10;
 pub fn delete_framed_routing(packet: &mut Packet) {
     packet.delete(FRAMED_ROUTING_TYPE);
 }
-pub fn lookup_framed_routing(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_ROUTING_TYPE)
-}
 pub fn lookup_all_framed_routing(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_ROUTING_TYPE)
 }
 pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) {
     packet.add(AVP::encode_u32(FRAMED_ROUTING_TYPE, value as u32));
 }
+pub fn lookup_framed_routing(packet: &Packet) -> Option<Result<FramedRouting, AVPError>> {
+    packet
+        .lookup(FRAMED_ROUTING_TYPE)
+        .map(|v| Ok(v.decode_u32()? as FramedRouting))
+}
 
 pub const FILTER_ID_TYPE: AVPType = 11;
 pub fn delete_filter_id(packet: &mut Packet) {
     packet.delete(FILTER_ID_TYPE);
 }
-pub fn lookup_filter_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FILTER_ID_TYPE)
-}
 pub fn lookup_all_filter_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FILTER_ID_TYPE)
 }
 pub fn add_filter_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FILTER_ID_TYPE, value));
 }
+pub fn lookup_filter_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet.lookup(FILTER_ID_TYPE).map(|v| v.decode_string())
+}
 
 pub const FRAMED_MTU_TYPE: AVPType = 12;
 pub fn delete_framed_mtu(packet: &mut Packet) {
     packet.delete(FRAMED_MTU_TYPE);
 }
-pub fn lookup_framed_mtu(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_MTU_TYPE)
-}
 pub fn lookup_all_framed_mtu(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_MTU_TYPE)
 }
 pub fn add_framed_mtu(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_MTU_TYPE, value));
 }
+pub fn lookup_framed_mtu(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(FRAMED_MTU_TYPE).map(|v| v.decode_u32())
+}
 
 pub const FRAMED_COMPRESSION_TYPE: AVPType = 13;
 pub fn delete_framed_compression(packet: &mut Packet) {
     packet.delete(FRAMED_COMPRESSION_TYPE);
 }
-pub fn lookup_framed_compression(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_COMPRESSION_TYPE)
-}
 pub fn lookup_all_framed_compression(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_COMPRESSION_TYPE)
 }
 pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) {
     packet.add(AVP::encode_u32(FRAMED_COMPRESSION_TYPE, value as u32));
 }
+pub fn lookup_framed_compression(packet: &Packet) -> Option<Result<FramedCompression, AVPError>> {
+    packet
+        .lookup(FRAMED_COMPRESSION_TYPE)
+        .map(|v| Ok(v.decode_u32()? as FramedCompression))
+}
 
 pub const LOGIN_IP_HOST_TYPE: AVPType = 14;
 pub fn delete_login_ip_host(packet: &mut Packet) {
     packet.delete(LOGIN_IP_HOST_TYPE);
 }
-pub fn lookup_login_ip_host(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_IP_HOST_TYPE)
-}
 pub fn lookup_all_login_ip_host(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_IP_HOST_TYPE)
 }
 pub fn add_login_ip_host(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(LOGIN_IP_HOST_TYPE, value));
 }
+pub fn lookup_login_ip_host(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
+    packet.lookup(LOGIN_IP_HOST_TYPE).map(|v| v.decode_ipv4())
+}
 
 pub const LOGIN_SERVICE_TYPE: AVPType = 15;
 pub fn delete_login_service(packet: &mut Packet) {
     packet.delete(LOGIN_SERVICE_TYPE);
 }
-pub fn lookup_login_service(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_SERVICE_TYPE)
-}
 pub fn lookup_all_login_service(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_SERVICE_TYPE)
 }
 pub fn add_login_service(packet: &mut Packet, value: LoginService) {
     packet.add(AVP::encode_u32(LOGIN_SERVICE_TYPE, value as u32));
 }
+pub fn lookup_login_service(packet: &Packet) -> Option<Result<LoginService, AVPError>> {
+    packet
+        .lookup(LOGIN_SERVICE_TYPE)
+        .map(|v| Ok(v.decode_u32()? as LoginService))
+}
 
 pub const LOGIN_TCP_PORT_TYPE: AVPType = 16;
 pub fn delete_login_tcp_port(packet: &mut Packet) {
     packet.delete(LOGIN_TCP_PORT_TYPE);
 }
-pub fn lookup_login_tcp_port(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_TCP_PORT_TYPE)
-}
 pub fn lookup_all_login_tcp_port(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_TCP_PORT_TYPE)
 }
 pub fn add_login_tcp_port(packet: &mut Packet, value: LoginTCPPort) {
     packet.add(AVP::encode_u32(LOGIN_TCP_PORT_TYPE, value as u32));
 }
+pub fn lookup_login_tcp_port(packet: &Packet) -> Option<Result<LoginTCPPort, AVPError>> {
+    packet
+        .lookup(LOGIN_TCP_PORT_TYPE)
+        .map(|v| Ok(v.decode_u32()? as LoginTCPPort))
+}
 
 pub const REPLY_MESSAGE_TYPE: AVPType = 18;
 pub fn delete_reply_message(packet: &mut Packet) {
     packet.delete(REPLY_MESSAGE_TYPE);
 }
-pub fn lookup_reply_message(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(REPLY_MESSAGE_TYPE)
-}
 pub fn lookup_all_reply_message(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(REPLY_MESSAGE_TYPE)
 }
 pub fn add_reply_message(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(REPLY_MESSAGE_TYPE, value));
 }
+pub fn lookup_reply_message(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet.lookup(REPLY_MESSAGE_TYPE).map(|v| v.decode_string())
+}
 
 pub const CALLBACK_NUMBER_TYPE: AVPType = 19;
 pub fn delete_callback_number(packet: &mut Packet) {
     packet.delete(CALLBACK_NUMBER_TYPE);
 }
-pub fn lookup_callback_number(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CALLBACK_NUMBER_TYPE)
-}
 pub fn lookup_all_callback_number(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CALLBACK_NUMBER_TYPE)
 }
 pub fn add_callback_number(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLBACK_NUMBER_TYPE, value));
 }
+pub fn lookup_callback_number(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(CALLBACK_NUMBER_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const CALLBACK_ID_TYPE: AVPType = 20;
 pub fn delete_callback_id(packet: &mut Packet) {
     packet.delete(CALLBACK_ID_TYPE);
 }
-pub fn lookup_callback_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CALLBACK_ID_TYPE)
-}
 pub fn lookup_all_callback_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CALLBACK_ID_TYPE)
 }
 pub fn add_callback_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLBACK_ID_TYPE, value));
 }
+pub fn lookup_callback_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet.lookup(CALLBACK_ID_TYPE).map(|v| v.decode_string())
+}
 
 pub const FRAMED_ROUTE_TYPE: AVPType = 22;
 pub fn delete_framed_route(packet: &mut Packet) {
     packet.delete(FRAMED_ROUTE_TYPE);
 }
-pub fn lookup_framed_route(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_ROUTE_TYPE)
-}
 pub fn lookup_all_framed_route(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_ROUTE_TYPE)
 }
 pub fn add_framed_route(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FRAMED_ROUTE_TYPE, value));
 }
+pub fn lookup_framed_route(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet.lookup(FRAMED_ROUTE_TYPE).map(|v| v.decode_string())
+}
 
 pub const FRAMED_IPX_NETWORK_TYPE: AVPType = 23;
 pub fn delete_framed_ipx_network(packet: &mut Packet) {
     packet.delete(FRAMED_IPX_NETWORK_TYPE);
 }
-pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_IPX_NETWORK_TYPE)
-}
 pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_IPX_NETWORK_TYPE)
 }
 pub fn add_framed_ipx_network(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::encode_ipv4(FRAMED_IPX_NETWORK_TYPE, value));
 }
+pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
+    packet
+        .lookup(FRAMED_IPX_NETWORK_TYPE)
+        .map(|v| v.decode_ipv4())
+}
 
 pub const STATE_TYPE: AVPType = 24;
 pub fn delete_state(packet: &mut Packet) {
     packet.delete(STATE_TYPE);
 }
-pub fn lookup_state(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(STATE_TYPE)
-}
 pub fn lookup_all_state(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(STATE_TYPE)
 }
 pub fn add_state(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(STATE_TYPE, value));
 }
+pub fn lookup_state(packet: &Packet) -> Option<Vec<u8>> {
+    packet.lookup(STATE_TYPE).map(|v| v.decode_bytes())
+}
 
 pub const CLASS_TYPE: AVPType = 25;
 pub fn delete_class(packet: &mut Packet) {
     packet.delete(CLASS_TYPE);
 }
-pub fn lookup_class(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CLASS_TYPE)
-}
 pub fn lookup_all_class(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CLASS_TYPE)
 }
 pub fn add_class(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CLASS_TYPE, value));
 }
+pub fn lookup_class(packet: &Packet) -> Option<Vec<u8>> {
+    packet.lookup(CLASS_TYPE).map(|v| v.decode_bytes())
+}
 
 pub const VENDOR_SPECIFIC_TYPE: AVPType = 26;
 pub fn delete_vendor_specific(packet: &mut Packet) {
     packet.delete(VENDOR_SPECIFIC_TYPE);
 }
-pub fn lookup_vendor_specific(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(VENDOR_SPECIFIC_TYPE)
-}
 pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(VENDOR_SPECIFIC_TYPE)
 }
@@ -422,236 +441,260 @@ pub const SESSION_TIMEOUT_TYPE: AVPType = 27;
 pub fn delete_session_timeout(packet: &mut Packet) {
     packet.delete(SESSION_TIMEOUT_TYPE);
 }
-pub fn lookup_session_timeout(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(SESSION_TIMEOUT_TYPE)
-}
 pub fn lookup_all_session_timeout(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(SESSION_TIMEOUT_TYPE)
 }
 pub fn add_session_timeout(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(SESSION_TIMEOUT_TYPE, value));
 }
+pub fn lookup_session_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(SESSION_TIMEOUT_TYPE).map(|v| v.decode_u32())
+}
 
 pub const IDLE_TIMEOUT_TYPE: AVPType = 28;
 pub fn delete_idle_timeout(packet: &mut Packet) {
     packet.delete(IDLE_TIMEOUT_TYPE);
 }
-pub fn lookup_idle_timeout(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(IDLE_TIMEOUT_TYPE)
-}
 pub fn lookup_all_idle_timeout(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(IDLE_TIMEOUT_TYPE)
 }
 pub fn add_idle_timeout(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(IDLE_TIMEOUT_TYPE, value));
 }
+pub fn lookup_idle_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(IDLE_TIMEOUT_TYPE).map(|v| v.decode_u32())
+}
 
 pub const TERMINATION_ACTION_TYPE: AVPType = 29;
 pub fn delete_termination_action(packet: &mut Packet) {
     packet.delete(TERMINATION_ACTION_TYPE);
 }
-pub fn lookup_termination_action(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(TERMINATION_ACTION_TYPE)
-}
 pub fn lookup_all_termination_action(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(TERMINATION_ACTION_TYPE)
 }
 pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) {
     packet.add(AVP::encode_u32(TERMINATION_ACTION_TYPE, value as u32));
 }
+pub fn lookup_termination_action(packet: &Packet) -> Option<Result<TerminationAction, AVPError>> {
+    packet
+        .lookup(TERMINATION_ACTION_TYPE)
+        .map(|v| Ok(v.decode_u32()? as TerminationAction))
+}
 
 pub const CALLED_STATION_ID_TYPE: AVPType = 30;
 pub fn delete_called_station_id(packet: &mut Packet) {
     packet.delete(CALLED_STATION_ID_TYPE);
 }
-pub fn lookup_called_station_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CALLED_STATION_ID_TYPE)
-}
 pub fn lookup_all_called_station_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CALLED_STATION_ID_TYPE)
 }
 pub fn add_called_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLED_STATION_ID_TYPE, value));
 }
+pub fn lookup_called_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(CALLED_STATION_ID_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const CALLING_STATION_ID_TYPE: AVPType = 31;
 pub fn delete_calling_station_id(packet: &mut Packet) {
     packet.delete(CALLING_STATION_ID_TYPE);
 }
-pub fn lookup_calling_station_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CALLING_STATION_ID_TYPE)
-}
 pub fn lookup_all_calling_station_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CALLING_STATION_ID_TYPE)
 }
 pub fn add_calling_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(CALLING_STATION_ID_TYPE, value));
 }
+pub fn lookup_calling_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(CALLING_STATION_ID_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const NAS_IDENTIFIER_TYPE: AVPType = 32;
 pub fn delete_nas_identifier(packet: &mut Packet) {
     packet.delete(NAS_IDENTIFIER_TYPE);
 }
-pub fn lookup_nas_identifier(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(NAS_IDENTIFIER_TYPE)
-}
 pub fn lookup_all_nas_identifier(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(NAS_IDENTIFIER_TYPE)
 }
 pub fn add_nas_identifier(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(NAS_IDENTIFIER_TYPE, value));
 }
+pub fn lookup_nas_identifier(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(NAS_IDENTIFIER_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const PROXY_STATE_TYPE: AVPType = 33;
 pub fn delete_proxy_state(packet: &mut Packet) {
     packet.delete(PROXY_STATE_TYPE);
 }
-pub fn lookup_proxy_state(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(PROXY_STATE_TYPE)
-}
 pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(PROXY_STATE_TYPE)
 }
 pub fn add_proxy_state(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(PROXY_STATE_TYPE, value));
 }
+pub fn lookup_proxy_state(packet: &Packet) -> Option<Vec<u8>> {
+    packet.lookup(PROXY_STATE_TYPE).map(|v| v.decode_bytes())
+}
 
 pub const LOGIN_LAT_SERVICE_TYPE: AVPType = 34;
 pub fn delete_login_lat_service(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_SERVICE_TYPE);
 }
-pub fn lookup_login_lat_service(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_LAT_SERVICE_TYPE)
-}
 pub fn lookup_all_login_lat_service(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_LAT_SERVICE_TYPE)
 }
 pub fn add_login_lat_service(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_SERVICE_TYPE, value));
 }
+pub fn lookup_login_lat_service(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(LOGIN_LAT_SERVICE_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const LOGIN_LAT_NODE_TYPE: AVPType = 35;
 pub fn delete_login_lat_node(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_NODE_TYPE);
 }
-pub fn lookup_login_lat_node(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_LAT_NODE_TYPE)
-}
 pub fn lookup_all_login_lat_node(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_LAT_NODE_TYPE)
 }
 pub fn add_login_lat_node(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_NODE_TYPE, value));
 }
+pub fn lookup_login_lat_node(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(LOGIN_LAT_NODE_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const LOGIN_LAT_GROUP_TYPE: AVPType = 36;
 pub fn delete_login_lat_group(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_GROUP_TYPE);
 }
-pub fn lookup_login_lat_group(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_LAT_GROUP_TYPE)
-}
 pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_LAT_GROUP_TYPE)
 }
 pub fn add_login_lat_group(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(LOGIN_LAT_GROUP_TYPE, value));
 }
+pub fn lookup_login_lat_group(packet: &Packet) -> Option<Vec<u8>> {
+    packet
+        .lookup(LOGIN_LAT_GROUP_TYPE)
+        .map(|v| v.decode_bytes())
+}
 
 pub const FRAMED_APPLE_TALK_LINK_TYPE: AVPType = 37;
 pub fn delete_framed_apple_talk_link(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_LINK_TYPE);
 }
-pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_APPLE_TALK_LINK_TYPE)
-}
 pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE)
 }
 pub fn add_framed_apple_talk_link(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_LINK_TYPE, value));
 }
+pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(FRAMED_APPLE_TALK_LINK_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const FRAMED_APPLE_TALK_NETWORK_TYPE: AVPType = 38;
 pub fn delete_framed_apple_talk_network(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_NETWORK_TYPE);
 }
-pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
-}
 pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE)
 }
 pub fn add_framed_apple_talk_network(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value));
 }
+pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const FRAMED_APPLE_TALK_ZONE_TYPE: AVPType = 39;
 pub fn delete_framed_apple_talk_zone(packet: &mut Packet) {
     packet.delete(FRAMED_APPLE_TALK_ZONE_TYPE);
 }
-pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
-}
 pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE)
 }
 pub fn add_framed_apple_talk_zone(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(FRAMED_APPLE_TALK_ZONE_TYPE, value));
 }
+pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const CHAP_CHALLENGE_TYPE: AVPType = 60;
 pub fn delete_chap_challenge(packet: &mut Packet) {
     packet.delete(CHAP_CHALLENGE_TYPE);
 }
-pub fn lookup_chap_challenge(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(CHAP_CHALLENGE_TYPE)
-}
 pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(CHAP_CHALLENGE_TYPE)
 }
 pub fn add_chap_challenge(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::encode_bytes(CHAP_CHALLENGE_TYPE, value));
 }
+pub fn lookup_chap_challenge(packet: &Packet) -> Option<Vec<u8>> {
+    packet.lookup(CHAP_CHALLENGE_TYPE).map(|v| v.decode_bytes())
+}
 
 pub const NAS_PORT_TYPE_TYPE: AVPType = 61;
 pub fn delete_nas_port_type(packet: &mut Packet) {
     packet.delete(NAS_PORT_TYPE_TYPE);
 }
-pub fn lookup_nas_port_type(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(NAS_PORT_TYPE_TYPE)
-}
 pub fn lookup_all_nas_port_type(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(NAS_PORT_TYPE_TYPE)
 }
 pub fn add_nas_port_type(packet: &mut Packet, value: NasPortType) {
     packet.add(AVP::encode_u32(NAS_PORT_TYPE_TYPE, value as u32));
 }
+pub fn lookup_nas_port_type(packet: &Packet) -> Option<Result<NasPortType, AVPError>> {
+    packet
+        .lookup(NAS_PORT_TYPE_TYPE)
+        .map(|v| Ok(v.decode_u32()? as NasPortType))
+}
 
 pub const PORT_LIMIT_TYPE: AVPType = 62;
 pub fn delete_port_limit(packet: &mut Packet) {
     packet.delete(PORT_LIMIT_TYPE);
 }
-pub fn lookup_port_limit(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(PORT_LIMIT_TYPE)
-}
 pub fn lookup_all_port_limit(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(PORT_LIMIT_TYPE)
 }
 pub fn add_port_limit(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(PORT_LIMIT_TYPE, value));
 }
+pub fn lookup_port_limit(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(PORT_LIMIT_TYPE).map(|v| v.decode_u32())
+}
 
 pub const LOGIN_LAT_PORT_TYPE: AVPType = 63;
 pub fn delete_login_lat_port(packet: &mut Packet) {
     packet.delete(LOGIN_LAT_PORT_TYPE);
 }
-pub fn lookup_login_lat_port(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(LOGIN_LAT_PORT_TYPE)
-}
 pub fn lookup_all_login_lat_port(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(LOGIN_LAT_PORT_TYPE)
 }
 pub fn add_login_lat_port(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(LOGIN_LAT_PORT_TYPE, value));
 }
+pub fn lookup_login_lat_port(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(LOGIN_LAT_PORT_TYPE)
+        .map(|v| v.decode_string())
+}
diff --git a/src/rfc2866.rs b/src/rfc2866.rs
index b48b417..4394a35 100644
--- a/src/rfc2866.rs
+++ b/src/rfc2866.rs
@@ -1,6 +1,6 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPType, AVP};
+use crate::avp::{AVPError, AVPType, AVP};
 use crate::packet::Packet;
 
 pub type AcctAuthentic = u32;
@@ -42,166 +42,188 @@ pub const ACCT_STATUS_TYPE_TYPE: AVPType = 40;
 pub fn delete_acct_status_type(packet: &mut Packet) {
     packet.delete(ACCT_STATUS_TYPE_TYPE);
 }
-pub fn lookup_acct_status_type(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_STATUS_TYPE_TYPE)
-}
 pub fn lookup_all_acct_status_type(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_STATUS_TYPE_TYPE)
 }
 pub fn add_acct_status_type(packet: &mut Packet, value: AcctStatusType) {
     packet.add(AVP::encode_u32(ACCT_STATUS_TYPE_TYPE, value as u32));
 }
+pub fn lookup_acct_status_type(packet: &Packet) -> Option<Result<AcctStatusType, AVPError>> {
+    packet
+        .lookup(ACCT_STATUS_TYPE_TYPE)
+        .map(|v| Ok(v.decode_u32()? as AcctStatusType))
+}
 
 pub const ACCT_DELAY_TIME_TYPE: AVPType = 41;
 pub fn delete_acct_delay_time(packet: &mut Packet) {
     packet.delete(ACCT_DELAY_TIME_TYPE);
 }
-pub fn lookup_acct_delay_time(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_DELAY_TIME_TYPE)
-}
 pub fn lookup_all_acct_delay_time(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_DELAY_TIME_TYPE)
 }
 pub fn add_acct_delay_time(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_DELAY_TIME_TYPE, value));
 }
+pub fn lookup_acct_delay_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(ACCT_DELAY_TIME_TYPE).map(|v| v.decode_u32())
+}
 
 pub const ACCT_INPUT_OCTETS_TYPE: AVPType = 42;
 pub fn delete_acct_input_octets(packet: &mut Packet) {
     packet.delete(ACCT_INPUT_OCTETS_TYPE);
 }
-pub fn lookup_acct_input_octets(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_INPUT_OCTETS_TYPE)
-}
 pub fn lookup_all_acct_input_octets(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_INPUT_OCTETS_TYPE)
 }
 pub fn add_acct_input_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_INPUT_OCTETS_TYPE, value));
 }
+pub fn lookup_acct_input_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_INPUT_OCTETS_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const ACCT_OUTPUT_OCTETS_TYPE: AVPType = 43;
 pub fn delete_acct_output_octets(packet: &mut Packet) {
     packet.delete(ACCT_OUTPUT_OCTETS_TYPE);
 }
-pub fn lookup_acct_output_octets(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_OUTPUT_OCTETS_TYPE)
-}
 pub fn lookup_all_acct_output_octets(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE)
 }
 pub fn add_acct_output_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_OUTPUT_OCTETS_TYPE, value));
 }
+pub fn lookup_acct_output_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_OUTPUT_OCTETS_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const ACCT_SESSION_ID_TYPE: AVPType = 44;
 pub fn delete_acct_session_id(packet: &mut Packet) {
     packet.delete(ACCT_SESSION_ID_TYPE);
 }
-pub fn lookup_acct_session_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_SESSION_ID_TYPE)
-}
 pub fn lookup_all_acct_session_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_SESSION_ID_TYPE)
 }
 pub fn add_acct_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_SESSION_ID_TYPE, value));
 }
+pub fn lookup_acct_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(ACCT_SESSION_ID_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const ACCT_AUTHENTIC_TYPE: AVPType = 45;
 pub fn delete_acct_authentic(packet: &mut Packet) {
     packet.delete(ACCT_AUTHENTIC_TYPE);
 }
-pub fn lookup_acct_authentic(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_AUTHENTIC_TYPE)
-}
 pub fn lookup_all_acct_authentic(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_AUTHENTIC_TYPE)
 }
 pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) {
     packet.add(AVP::encode_u32(ACCT_AUTHENTIC_TYPE, value as u32));
 }
+pub fn lookup_acct_authentic(packet: &Packet) -> Option<Result<AcctAuthentic, AVPError>> {
+    packet
+        .lookup(ACCT_AUTHENTIC_TYPE)
+        .map(|v| Ok(v.decode_u32()? as AcctAuthentic))
+}
 
 pub const ACCT_SESSION_TIME_TYPE: AVPType = 46;
 pub fn delete_acct_session_time(packet: &mut Packet) {
     packet.delete(ACCT_SESSION_TIME_TYPE);
 }
-pub fn lookup_acct_session_time(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_SESSION_TIME_TYPE)
-}
 pub fn lookup_all_acct_session_time(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_SESSION_TIME_TYPE)
 }
 pub fn add_acct_session_time(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_SESSION_TIME_TYPE, value));
 }
+pub fn lookup_acct_session_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_SESSION_TIME_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const ACCT_INPUT_PACKETS_TYPE: AVPType = 47;
 pub fn delete_acct_input_packets(packet: &mut Packet) {
     packet.delete(ACCT_INPUT_PACKETS_TYPE);
 }
-pub fn lookup_acct_input_packets(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_INPUT_PACKETS_TYPE)
-}
 pub fn lookup_all_acct_input_packets(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_INPUT_PACKETS_TYPE)
 }
 pub fn add_acct_input_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_INPUT_PACKETS_TYPE, value));
 }
+pub fn lookup_acct_input_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_INPUT_PACKETS_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const ACCT_OUTPUT_PACKETS_TYPE: AVPType = 48;
 pub fn delete_acct_output_packets(packet: &mut Packet) {
     packet.delete(ACCT_OUTPUT_PACKETS_TYPE);
 }
-pub fn lookup_acct_output_packets(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_OUTPUT_PACKETS_TYPE)
-}
 pub fn lookup_all_acct_output_packets(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE)
 }
 pub fn add_acct_output_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_OUTPUT_PACKETS_TYPE, value));
 }
+pub fn lookup_acct_output_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_OUTPUT_PACKETS_TYPE)
+        .map(|v| v.decode_u32())
+}
 
 pub const ACCT_TERMINATE_CAUSE_TYPE: AVPType = 49;
 pub fn delete_acct_terminate_cause(packet: &mut Packet) {
     packet.delete(ACCT_TERMINATE_CAUSE_TYPE);
 }
-pub fn lookup_acct_terminate_cause(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_TERMINATE_CAUSE_TYPE)
-}
 pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE)
 }
 pub fn add_acct_terminate_cause(packet: &mut Packet, value: AcctTerminateCause) {
     packet.add(AVP::encode_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32));
 }
+pub fn lookup_acct_terminate_cause(
+    packet: &Packet,
+) -> Option<Result<AcctTerminateCause, AVPError>> {
+    packet
+        .lookup(ACCT_TERMINATE_CAUSE_TYPE)
+        .map(|v| Ok(v.decode_u32()? as AcctTerminateCause))
+}
 
 pub const ACCT_MULTI_SESSION_ID_TYPE: AVPType = 50;
 pub fn delete_acct_multi_session_id(packet: &mut Packet) {
     packet.delete(ACCT_MULTI_SESSION_ID_TYPE);
 }
-pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_MULTI_SESSION_ID_TYPE)
-}
 pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE)
 }
 pub fn add_acct_multi_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_MULTI_SESSION_ID_TYPE, value));
 }
+pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(ACCT_MULTI_SESSION_ID_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const ACCT_LINK_COUNT_TYPE: AVPType = 51;
 pub fn delete_acct_link_count(packet: &mut Packet) {
     packet.delete(ACCT_LINK_COUNT_TYPE);
 }
-pub fn lookup_acct_link_count(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_LINK_COUNT_TYPE)
-}
 pub fn lookup_all_acct_link_count(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_LINK_COUNT_TYPE)
 }
 pub fn add_acct_link_count(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_LINK_COUNT_TYPE, value));
 }
+pub fn lookup_acct_link_count(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet.lookup(ACCT_LINK_COUNT_TYPE).map(|v| v.decode_u32())
+}
diff --git a/src/rfc2867.rs b/src/rfc2867.rs
index b75ab8d..9c9d218 100644
--- a/src/rfc2867.rs
+++ b/src/rfc2867.rs
@@ -1,6 +1,6 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPType, AVP};
+use crate::avp::{AVPError, AVPType, AVP};
 use crate::packet::Packet;
 
 pub type AcctStatusType = u32;
@@ -15,26 +15,30 @@ pub const ACCT_TUNNEL_CONNECTION_TYPE: AVPType = 68;
 pub fn delete_acct_tunnel_connection(packet: &mut Packet) {
     packet.delete(ACCT_TUNNEL_CONNECTION_TYPE);
 }
-pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_TUNNEL_CONNECTION_TYPE)
-}
 pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE)
 }
 pub fn add_acct_tunnel_connection(packet: &mut Packet, value: &str) {
     packet.add(AVP::encode_string(ACCT_TUNNEL_CONNECTION_TYPE, value));
 }
+pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<Result<String, AVPError>> {
+    packet
+        .lookup(ACCT_TUNNEL_CONNECTION_TYPE)
+        .map(|v| v.decode_string())
+}
 
 pub const ACCT_TUNNEL_PACKETS_LOST_TYPE: AVPType = 86;
 pub fn delete_acct_tunnel_packets_lost(packet: &mut Packet) {
     packet.delete(ACCT_TUNNEL_PACKETS_LOST_TYPE);
 }
-pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<&AVP> {
-    packet.lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
-}
 pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Vec<&AVP> {
     packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE)
 }
 pub fn add_acct_tunnel_packets_lost(packet: &mut Packet, value: u32) {
     packet.add(AVP::encode_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value));
 }
+pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<Result<u32, AVPError>> {
+    packet
+        .lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
+        .map(|v| v.decode_u32())
+}