From be49318aa44d3942db3614eb6acf73e70b7946ca Mon Sep 17 00:00:00 2001
From: Pure White <wudi.daniel@bytedance.com>
Date: Mon, 24 Jun 2024 21:07:55 +0800
Subject: [PATCH] feat: update to rustc-hash 2

---
 Cargo.lock                                    |    48 +-
 pilota-build/Cargo.toml                       |     4 +-
 pilota-build/test_data/plugin/serde.rs        |   136 +-
 .../test_data/protobuf/nested_message.rs      |    73 +-
 pilota-build/test_data/protobuf/service.rs    |     4 +-
 pilota-build/test_data/thrift/apache.rs       | 21548 ++++++++--------
 pilota-build/test_data/thrift/auto_name.rs    |  1150 +-
 pilota-build/test_data/thrift/const_val.rs    |    15 +-
 pilota-build/test_data/thrift/decode_error.rs |    98 +-
 .../test_data/thrift/default_value.rs         |     2 +-
 pilota-build/test_data/thrift/enum_test.rs    |   484 +-
 pilota-build/test_data/thrift/multi.rs        |   770 +-
 pilota-build/test_data/thrift/normal.rs       |  2374 +-
 pilota-build/test_data/thrift/pilota_name.rs  |   616 +-
 .../test_data/thrift/recursive_type.rs        |   164 +-
 pilota-build/test_data/thrift/union.rs        |   204 +-
 pilota-build/test_data/thrift/void.rs         |    26 +-
 pilota-build/test_data/thrift/wrapper_arc.rs  |   426 +-
 pilota-build/test_data/unknown_fields.rs      |  3694 +--
 19 files changed, 15921 insertions(+), 15915 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e7ed0ce4..5117bfe4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -66,7 +66,7 @@ checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -77,7 +77,7 @@ checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -151,9 +151,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.99"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+checksum = "c891175c3fb232128f48de6590095e59198bbeb8620c310be349bfc3afd12c7b"
 
 [[package]]
 name = "cfg-if"
@@ -518,9 +518,9 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
@@ -765,7 +765,7 @@ dependencies = [
  "phf_shared",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -803,7 +803,7 @@ dependencies = [
 
 [[package]]
 name = "pilota-build"
-version = "0.11.11"
+version = "0.11.12"
 dependencies = [
  "ahash",
  "anyhow",
@@ -828,12 +828,12 @@ dependencies = [
  "quote",
  "rand",
  "rayon",
- "rustc-hash",
+ "rustc-hash 2.0.0",
  "salsa",
  "scoped-tls",
  "serde",
  "serde_yaml",
- "syn 2.0.67",
+ "syn 2.0.68",
  "tempfile",
  "tokio",
  "toml",
@@ -899,9 +899,9 @@ dependencies = [
 
 [[package]]
 name = "proptest"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
+checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d"
 dependencies = [
  "bit-set",
  "bit-vec",
@@ -1101,6 +1101,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"
+
 [[package]]
 name = "rustix"
 version = "0.38.34"
@@ -1144,7 +1150,7 @@ dependencies = [
  "log",
  "oorandom",
  "parking_lot",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "salsa-macros",
  "smallvec",
 ]
@@ -1199,7 +1205,7 @@ checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -1275,9 +1281,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.67"
+version = "2.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff8655ed1d86f3af4ee3fd3263786bc14245ad17c4c7e85ba7187fb3ae028c90"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1313,7 +1319,7 @@ checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -1400,7 +1406,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
 
 [[package]]
@@ -1524,7 +1530,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
  "wasm-bindgen-shared",
 ]
 
@@ -1546,7 +1552,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -1775,5 +1781,5 @@ checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.68",
 ]
diff --git a/pilota-build/Cargo.toml b/pilota-build/Cargo.toml
index 92388720..90ca840f 100644
--- a/pilota-build/Cargo.toml
+++ b/pilota-build/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pilota-build"
-version = "0.11.11"
+version = "0.11.12"
 edition = "2021"
 description = "Compile thrift and protobuf idl into rust code at compile-time."
 documentation = "https://docs.rs/pilota-build"
@@ -32,7 +32,7 @@ phf = { version = "0.11", features = ["macros"] }
 proc-macro2 = "1"
 quote = "1"
 rayon = "1"
-rustc-hash = "1"
+rustc-hash = "2"
 salsa = { version = "0.17.0-pre.2" }
 scoped-tls = "1"
 serde = { version = "1", features = ["derive"] }
diff --git a/pilota-build/test_data/plugin/serde.rs b/pilota-build/test_data/plugin/serde.rs
index dfb24ef9..01a14459 100644
--- a/pilota-build/test_data/plugin/serde.rs
+++ b/pilota-build/test_data/plugin/serde.rs
@@ -195,6 +195,74 @@ pub mod serde {
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+        )]
+        #[serde(rename = "BB")]
+        #[derive(Clone, PartialEq)]
+        pub struct B(pub i32);
+
+        impl ::std::ops::Deref for B {
+            type Target = i32;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl From<i32> for B {
+            fn from(v: i32) -> Self {
+                Self(v)
+            }
+        }
+
+        impl ::pilota::thrift::Message for B {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i32(*(&**self))?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                ::std::result::Result::Ok(B(__protocol.read_i32()?))
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    ::std::result::Result::Ok(B(__protocol.read_i32().await?))
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.i32_len(*&**self)
+            }
+        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize)]
@@ -289,73 +357,5 @@ pub mod serde {
                 __protocol.i32_len(self.inner())
             }
         }
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-        )]
-        #[serde(rename = "BB")]
-        #[derive(Clone, PartialEq)]
-        pub struct B(pub i32);
-
-        impl ::std::ops::Deref for B {
-            type Target = i32;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-
-        impl From<i32> for B {
-            fn from(v: i32) -> Self {
-                Self(v)
-            }
-        }
-
-        impl ::pilota::thrift::Message for B {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(*(&**self))?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                ::std::result::Result::Ok(B(__protocol.read_i32()?))
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    ::std::result::Result::Ok(B(__protocol.read_i32().await?))
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(*&**self)
-            }
-        }
     }
 }
diff --git a/pilota-build/test_data/protobuf/nested_message.rs b/pilota-build/test_data/protobuf/nested_message.rs
index 157d6983..2f18c9cb 100644
--- a/pilota-build/test_data/protobuf/nested_message.rs
+++ b/pilota-build/test_data/protobuf/nested_message.rs
@@ -84,43 +84,6 @@ pub mod nested_message {
     }
 
     pub mod tt1 {
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct Label(i32);
-
-        impl Label {
-            pub const LABEL_OPTIONAL: Self = Self(1);
-            pub const LABEL_REQUIRED: Self = Self(2);
-            pub const LABEL_REPEATED: Self = Self(3);
-
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(1) => ::std::string::String::from("LABEL_OPTIONAL"),
-                    Self(2) => ::std::string::String::from("LABEL_REQUIRED"),
-                    Self(3) => ::std::string::String::from("LABEL_REPEATED"),
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
-
-        impl ::std::convert::From<i32> for Label {
-            fn from(value: i32) -> Self {
-                Self(value)
-            }
-        }
-
-        impl ::std::convert::From<Label> for i32 {
-            fn from(value: Label) -> i32 {
-                value.0
-            }
-        }
-
         #[derive(Debug, Default, Clone, PartialEq)]
         pub struct T2 {
             pub t3: t2::Tt3,
@@ -169,6 +132,42 @@ pub mod nested_message {
                 }
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct Label(i32);
+
+        impl Label {
+            pub const LABEL_OPTIONAL: Self = Self(1);
+            pub const LABEL_REQUIRED: Self = Self(2);
+            pub const LABEL_REPEATED: Self = Self(3);
+
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(1) => ::std::string::String::from("LABEL_OPTIONAL"),
+                    Self(2) => ::std::string::String::from("LABEL_REQUIRED"),
+                    Self(3) => ::std::string::String::from("LABEL_REPEATED"),
+                    Self(val) => val.to_string(),
+                }
+            }
+        }
+
+        impl ::std::convert::From<i32> for Label {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
+
+        impl ::std::convert::From<Label> for i32 {
+            fn from(value: Label) -> i32 {
+                value.0
+            }
+        }
 
         pub mod t2 {
             #[derive(Debug, Default, Clone, PartialEq)]
diff --git a/pilota-build/test_data/protobuf/service.rs b/pilota-build/test_data/protobuf/service.rs
index 268d3c61..3c9d401c 100644
--- a/pilota-build/test_data/protobuf/service.rs
+++ b/pilota-build/test_data/protobuf/service.rs
@@ -50,8 +50,6 @@ pub mod service {
                 }
             }
         }
-
-        pub trait Echo {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
         pub struct EchoResponse {
             pub message: ::pilota::FastStr,
@@ -100,5 +98,7 @@ pub mod service {
                 }
             }
         }
+
+        pub trait Echo {}
     }
 }
diff --git a/pilota-build/test_data/thrift/apache.rs b/pilota-build/test_data/thrift/apache.rs
index 7c4ccb98..d3367199 100644
--- a/pilota-build/test_data/thrift/apache.rs
+++ b/pilota-build/test_data/thrift/apache.rs
@@ -101,29 +101,11 @@ pub mod apache {
                 __protocol.i32_len(self.inner())
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct LargeDeltas {
-            pub b1: ::std::option::Option<Bools>,
-
-            pub b10: ::std::option::Option<Bools>,
-
-            pub b100: ::std::option::Option<Bools>,
-
-            pub check_true: ::std::option::Option<bool>,
-
-            pub b1000: ::std::option::Option<Bools>,
-
-            pub check_false: ::std::option::Option<bool>,
-
-            pub vertwo2000: ::std::option::Option<VersioningTestV2>,
-
-            pub a_set2500: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
-
-            pub vertwo3000: ::std::option::Option<VersioningTestV2>,
-
-            pub big_numbers: ::std::option::Option<::std::vec::Vec<i32>>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestBinaryArgsSend {
+            pub thing: ::pilota::Bytes,
         }
-        impl ::pilota::thrift::Message for LargeDeltas {
+        impl ::pilota::thrift::Message for ThriftTestTestBinaryArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -131,56 +113,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "LargeDeltas",
+                    name: "ThriftTestTestBinaryArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.b1.as_ref() {
-                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.b10.as_ref() {
-                    __protocol.write_struct_field(10, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.b100.as_ref() {
-                    __protocol.write_struct_field(100, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.check_true.as_ref() {
-                    __protocol.write_bool_field(500, *value)?;
-                }
-                if let Some(value) = self.b1000.as_ref() {
-                    __protocol.write_struct_field(1000, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.check_false.as_ref() {
-                    __protocol.write_bool_field(1500, *value)?;
-                }
-                if let Some(value) = self.vertwo2000.as_ref() {
-                    __protocol.write_struct_field(2000, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.a_set2500.as_ref() {
-                    __protocol.write_set_field(
-                        2500,
-                        ::pilota::thrift::TType::Binary,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.vertwo3000.as_ref() {
-                    __protocol.write_struct_field(3000, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.big_numbers.as_ref() {
-                    __protocol.write_list_field(
-                        4000,
-                        ::pilota::thrift::TType::I32,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_i32(*val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+                __protocol.write_bytes_field(1, (&self.thing).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -192,16 +129,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut b1 = None;
-                let mut b10 = None;
-                let mut b100 = None;
-                let mut check_true = None;
-                let mut b1000 = None;
-                let mut check_false = None;
-                let mut vertwo2000 = None;
-                let mut a_set2500 = None;
-                let mut vertwo3000 = None;
-                let mut big_numbers = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -218,74 +146,9 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b1 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(10)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b10 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(100)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b100 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(500)
-                                if field_ident.field_type == ::pilota::thrift::TType::Bool =>
-                            {
-                                check_true = Some(__protocol.read_bool()?);
-                            }
-                            Some(1000)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b1000 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(1500)
-                                if field_ident.field_type == ::pilota::thrift::TType::Bool =>
-                            {
-                                check_false = Some(__protocol.read_bool()?);
-                            }
-                            Some(2000)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                vertwo2000 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(2500)
-                                if field_ident.field_type == ::pilota::thrift::TType::Set =>
-                            {
-                                a_set2500 = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_faststr()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
-                            }
-                            Some(3000)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                vertwo3000 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(4000)
-                                if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                big_numbers = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
+                                thing = Some(__protocol.read_bytes()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -298,27 +161,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `LargeDeltas` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    b1,
-                    b10,
-                    b100,
-                    check_true,
-                    b1000,
-                    check_false,
-                    vertwo2000,
-                    a_set2500,
-                    vertwo3000,
-                    big_numbers,
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
                 };
+
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -333,175 +189,83 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut b1 = None;
-                    let mut b10 = None;
-                    let mut b100 = None;
-                    let mut check_true = None;
-                    let mut b1000 = None;
-                    let mut check_false = None;
-                    let mut vertwo2000 = None;
-                    let mut a_set2500 = None;
-                    let mut vertwo3000 = None;
-                    let mut big_numbers = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                    loop {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    thing = Some(__protocol.read_bytes().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
 
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
 
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
 
-                    break;
-                } else {
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
 
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    b1 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestBinaryArgsSend",
+                }) + __protocol.bytes_field_len(Some(1), &self.thing)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMultiArgsRecv {
+            pub arg0: i8,
 
-                },Some(10) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    b10 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },Some(100) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    b100 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },Some(500) if field_ident.field_type == ::pilota::thrift::TType::Bool  => {
-                    check_true = Some(__protocol.read_bool().await?);
-
-                },Some(1000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    b1000 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },Some(1500) if field_ident.field_type == ::pilota::thrift::TType::Bool  => {
-                    check_false = Some(__protocol.read_bool().await?);
-
-                },Some(2000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    vertwo2000 = Some(<VersioningTestV2 as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },Some(2500) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
-                    a_set2500 = Some({let list_ident = __protocol.read_set_begin().await?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(__protocol.read_faststr().await?);
-                    };
-                    __protocol.read_set_end().await?;
-                    val});
-
-                },Some(3000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    vertwo3000 = Some(<VersioningTestV2 as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },Some(4000) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    big_numbers = Some({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push(__protocol.read_i32().await?);
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
+            pub arg1: i32,
 
+            pub arg2: i64,
 
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `LargeDeltas` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
-                    __protocol.read_struct_end().await?;
+            pub arg3: ::pilota::AHashMap<i16, ::pilota::FastStr>,
 
-                    let data = Self {
-                        b1,
-                        b10,
-                        b100,
-                        check_true,
-                        b1000,
-                        check_false,
-                        vertwo2000,
-                        a_set2500,
-                        vertwo3000,
-                        big_numbers,
-                    };
-                    ::std::result::Result::Ok(data)
-                })
-            }
+            pub arg4: Numberz,
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "LargeDeltas",
-                }) + self
-                    .b1
-                    .as_ref()
-                    .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
-                    + self
-                        .b10
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(10), value))
-                    + self
-                        .b100
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(100), value))
-                    + self
-                        .check_true
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bool_field_len(Some(500), *value))
-                    + self
-                        .b1000
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(1000), value))
-                    + self
-                        .check_false
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bool_field_len(Some(1500), *value))
-                    + self
-                        .vertwo2000
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(2000), value))
-                    + self.a_set2500.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(2500),
-                            ::pilota::thrift::TType::Binary,
-                            value,
-                            |__protocol, el| __protocol.faststr_len(el),
-                        )
-                    })
-                    + self
-                        .vertwo3000
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(3000), value))
-                    + self.big_numbers.as_ref().map_or(0, |value| {
-                        __protocol.list_field_len(
-                            Some(4000),
-                            ::pilota::thrift::TType::I32,
-                            value,
-                            |__protocol, el| __protocol.i32_len(*el),
-                        )
-                    })
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestI32ArgsSend {
-            pub thing: i32,
+            pub arg5: UserId,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestI32ArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -509,11 +273,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ArgsSend",
+                    name: "ThriftTestTestMultiArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.thing)?;
+                __protocol.write_i8_field(1, *&self.arg0)?;
+                __protocol.write_i32_field(2, *&self.arg1)?;
+                __protocol.write_i64_field(3, *&self.arg2)?;
+                __protocol.write_map_field(
+                    4,
+                    ::pilota::thrift::TType::I16,
+                    ::pilota::thrift::TType::Binary,
+                    &&self.arg3,
+                    |__protocol, key| {
+                        __protocol.write_i16(*key)?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_faststr((val).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                __protocol.write_i32_field(5, (&self.arg4).inner())?;
+                __protocol.write_struct_field(6, &self.arg5, ::pilota::thrift::TType::I64)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -525,7 +307,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut arg0 = None;
+                let mut arg1 = None;
+                let mut arg2 = None;
+                let mut arg3 = None;
+                let mut arg4 = None;
+                let mut arg5 = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -541,8 +328,34 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                thing = Some(__protocol.read_i32()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                arg0 = Some(__protocol.read_i8()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                arg1 = Some(__protocol.read_i32()?);
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                arg2 = Some(__protocol.read_i64()?);
+                            }
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                arg3 = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_i16()?,
+                                            __protocol.read_faststr()?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
+                            }
+                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                arg4 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(6) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                arg5 = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -555,20 +368,57 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(arg0) = arg0 else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field arg0 is required".to_string(),
+                    ));
+                };
+                let Some(arg1) = arg1 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg1 is required".to_string(),
+                    ));
+                };
+                let Some(arg2) = arg2 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg2 is required".to_string(),
+                    ));
+                };
+                let Some(arg3) = arg3 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg3 is required".to_string(),
+                    ));
+                };
+                let Some(arg4) = arg4 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg4 is required".to_string(),
+                    ));
+                };
+                let Some(arg5) = arg5 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg5 is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self {
+                    arg0,
+                    arg1,
+                    arg2,
+                    arg3,
+                    arg4,
+                    arg5,
+                };
                 ::std::result::Result::Ok(data)
             }
 
@@ -583,7 +433,12 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut arg0 = None;
+                    let mut arg1 = None;
+                    let mut arg2 = None;
+                    let mut arg3 = None;
+                    let mut arg4 = None;
+                    let mut arg5 = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -598,9 +453,56 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    arg0 = Some(__protocol.read_i8().await?);
+                                }
+                                Some(2)
                                     if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    thing = Some(__protocol.read_i32().await?);
+                                    arg1 = Some(__protocol.read_i32().await?);
+                                }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    arg2 = Some(__protocol.read_i64().await?);
+                                }
+                                Some(4)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                {
+                                    arg3 = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i16().await?,
+                                                __protocol.read_faststr().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
+                                }
+                                Some(5)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    arg4 = Some(
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                Some(6)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    arg5 = Some(
+                                        <UserId as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -614,22 +516,69 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(arg0) = arg0 else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field arg0 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg1) = arg1 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg1 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg2) = arg2 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg2 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg3) = arg3 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg3 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg4) = arg4 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg4 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg5) = arg5 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg5 is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self {
+                        arg0,
+                        arg1,
+                        arg2,
+                        arg3,
+                        arg4,
+                        arg5,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -638,17 +587,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ArgsSend",
-                }) + __protocol.i32_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestMultiArgsRecv",
+                }) + __protocol.i8_field_len(Some(1), *&self.arg0)
+                    + __protocol.i32_field_len(Some(2), *&self.arg1)
+                    + __protocol.i64_field_len(Some(3), *&self.arg2)
+                    + __protocol.map_field_len(
+                        Some(4),
+                        ::pilota::thrift::TType::I16,
+                        ::pilota::thrift::TType::Binary,
+                        &self.arg3,
+                        |__protocol, key| __protocol.i16_len(*key),
+                        |__protocol, val| __protocol.faststr_len(val),
+                    )
+                    + __protocol.i32_field_len(Some(5), (&self.arg4).inner())
+                    + __protocol.struct_field_len(Some(6), &self.arg5)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestSetArgsRecv {
-            pub thing: ::pilota::AHashSet<i32>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestUuidArgsSend {
+            pub thing: [u8; 16],
         }
-        impl ::pilota::thrift::Message for ThriftTestTestSetArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestUuidArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -656,19 +617,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetArgsRecv",
+                    name: "ThriftTestTestUuidArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_set_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_uuid_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -696,17 +649,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                thing = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_i32()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
+                                thing = Some(__protocol.read_uuid()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -719,7 +663,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -762,18 +706,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Uuid =>
                                 {
-                                    thing = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
+                                    thing = Some(__protocol.read_uuid().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -787,7 +722,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -811,43 +746,33 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetArgsRecv",
-                }) + __protocol.set_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, el| __protocol.i32_len(*el),
-                ) + __protocol.field_stop_len()
+                    name: "ThriftTestTestUuidArgsSend",
+                }) + __protocol.uuid_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMultiExceptionException {
-            #[derivative(Default)]
-            Err1(Xception),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct Bonk {
+            pub message: ::std::option::Option<::pilota::FastStr>,
 
-            Err2(Xception2),
+            pub r#type: ::std::option::Option<i32>,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionException {
+        impl ::pilota::thrift::Message for Bonk {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionException",
-                })?;
-                match self {
-                    ThriftTestTestMultiExceptionException::Err1(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    ThriftTestTestMultiExceptionException::Err2(ref value) => {
-                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Bonk" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.message.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
+                if let Some(value) = self.r#type.as_ref() {
+                    __protocol.write_i32_field(2, *value)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -859,196 +784,34 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut message = None;
+                let mut r#type = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionException::Err1(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(2) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionException::Err2(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(ThriftTestTestMultiExceptionException::Err1(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(2) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(ThriftTestTestMultiExceptionException::Err2(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionException",
-                }) + match self {
-                    ThriftTestTestMultiExceptionException::Err1(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                    ThriftTestTestMultiExceptionException::Err2(ref value) => {
-                        __protocol.struct_field_len(Some(2), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestVoidArgsSend {}
-        impl ::pilota::thrift::Message for ThriftTestTestVoidArgsSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                message = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                r#type = Some(__protocol.read_i32()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
 
@@ -1058,13 +821,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `Bonk` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {};
+                let data = Self { message, r#type };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1079,6 +845,9 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
+                    let mut message = None;
+                    let mut r#type = None;
+
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
@@ -1091,6 +860,17 @@ pub mod apache {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    message = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    r#type = Some(__protocol.read_i32().await?);
+                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -1103,13 +883,16 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `Bonk` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {};
+                    let data = Self { message, r#type };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1117,17 +900,24 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidArgsSend",
-                }) + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Bonk" })
+                    + self
+                        .message
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + self
+                        .r#type
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(2), *value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStructArgsRecv {
-            pub thing: Xtruct,
+        pub struct ThriftTestTestExceptionArgsSend {
+            pub arg: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestStructArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestExceptionArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1135,11 +925,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructArgsRecv",
+                    name: "ThriftTestTestExceptionArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_faststr_field(1, (&self.arg).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1151,7 +941,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut arg = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1168,9 +958,9 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                arg = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1183,20 +973,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(arg) = arg else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field arg is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self { arg };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1211,7 +1001,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut arg = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1227,14 +1017,9 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    thing = Some(
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    arg = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1248,22 +1033,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(arg) = arg else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field arg is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self { arg };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1272,170 +1057,44 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructArgsRecv",
-                }) + __protocol.struct_field_len(Some(1), &self.thing)
+                    name: "ThriftTestTestExceptionArgsSend",
+                }) + __protocol.faststr_field_len(Some(1), &self.arg)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMultiResultRecv {
-            #[derivative(Default)]
-            Ok(Xtruct),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestMultiResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestMultiResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestMultiResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct Xtruct {
+            pub string_thing: ::std::option::Option<::pilota::FastStr>,
 
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+            pub byte_thing: ::std::option::Option<i8>,
 
-                                    ret = Some(ThriftTestTestMultiResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
+            pub i32_thing: ::std::option::Option<i32>,
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiResultRecv",
-                }) + match self {
-                    ThriftTestTestMultiResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        pub const MY_NUMBERZ: Numberz = Numberz::ONE;
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct StructA {
-            pub s: ::pilota::FastStr,
+            pub i64_thing: ::std::option::Option<i64>,
         }
-        impl ::pilota::thrift::Message for StructA {
+        impl ::pilota::thrift::Message for Xtruct {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "StructA" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.s).clone())?;
+                if let Some(value) = self.string_thing.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
+                if let Some(value) = self.byte_thing.as_ref() {
+                    __protocol.write_i8_field(4, *value)?;
+                }
+                if let Some(value) = self.i32_thing.as_ref() {
+                    __protocol.write_i32_field(9, *value)?;
+                }
+                if let Some(value) = self.i64_thing.as_ref() {
+                    __protocol.write_i64_field(11, *value)?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1447,7 +1106,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut s = None;
+                let mut string_thing = None;
+                let mut byte_thing = None;
+                let mut i32_thing = None;
+                let mut i64_thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1466,7 +1128,16 @@ pub mod apache {
                             Some(1)
                                 if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                s = Some(__protocol.read_faststr()?);
+                                string_thing = Some(__protocol.read_faststr()?);
+                            }
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                byte_thing = Some(__protocol.read_i8()?);
+                            }
+                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                i32_thing = Some(__protocol.read_i32()?);
+                            }
+                            Some(11) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                i64_thing = Some(__protocol.read_i64()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1480,7 +1151,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `StructA` field(#{}) failed, caused by: ",
+                            "decode struct `Xtruct` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1488,14 +1159,12 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(s) = s else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field s is required".to_string(),
-                    ));
+                let data = Self {
+                    string_thing,
+                    byte_thing,
+                    i32_thing,
+                    i64_thing,
                 };
-
-                let data = Self { s };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1510,7 +1179,10 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut s = None;
+                    let mut string_thing = None;
+                    let mut byte_thing = None;
+                    let mut i32_thing = None;
+                    let mut i64_thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1528,7 +1200,22 @@ pub mod apache {
                                     if field_ident.field_type
                                         == ::pilota::thrift::TType::Binary =>
                                 {
-                                    s = Some(__protocol.read_faststr().await?);
+                                    string_thing = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(4)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    byte_thing = Some(__protocol.read_i8().await?);
+                                }
+                                Some(9)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    i32_thing = Some(__protocol.read_i32().await?);
+                                }
+                                Some(11)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    i64_thing = Some(__protocol.read_i64().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1543,7 +1230,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `StructA` field(#{}) failed, caused by: ",
+                                "decode struct `Xtruct` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -1551,16 +1238,12 @@ pub mod apache {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(s) = s else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field s is required".to_string(),
-                            ),
-                        );
+                    let data = Self {
+                        string_thing,
+                        byte_thing,
+                        i32_thing,
+                        i64_thing,
                     };
-
-                    let data = Self { s };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1568,18 +1251,32 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "StructA" })
-                    + __protocol.faststr_field_len(Some(1), &self.s)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct" })
+                    + self
+                        .string_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + self
+                        .byte_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i8_field_len(Some(4), *value))
+                    + self
+                        .i32_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(9), *value))
+                    + self
+                        .i64_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i64_field_len(Some(11), *value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestI64ArgsRecv {
-            pub thing: i64,
+        pub struct ThriftTestTestStructArgsSend {
+            pub thing: Xtruct,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestI64ArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestStructArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1587,11 +1284,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ArgsRecv",
+                    name: "ThriftTestTestStructArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i64_field(1, *&self.thing)?;
+                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1619,8 +1316,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                thing = Some(__protocol.read_i64()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1633,7 +1332,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -1676,9 +1375,15 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    thing = Some(__protocol.read_i64().await?);
+                                    thing = Some(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1692,7 +1397,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -1716,34 +1421,54 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ArgsRecv",
-                }) + __protocol.i64_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestStructArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestEnumResultRecv {
-            #[derivative(Default)]
-            Ok(Numberz),
-        }
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct Insanity {
+            pub user_map: ::std::option::Option<::pilota::AHashMap<Numberz, UserId>>,
 
-        impl ::pilota::thrift::Message for ThriftTestTestEnumResultRecv {
+            pub xtructs: ::std::option::Option<::std::vec::Vec<Xtruct>>,
+        }
+        impl ::pilota::thrift::Message for Insanity {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestEnumResultRecv::Ok(ref value) => {
-                        __protocol.write_i32_field(0, (value).inner())?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Insanity" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.user_map.as_ref() {
+                    __protocol.write_map_field(
+                        1,
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::I64,
+                        &value,
+                        |__protocol, key| {
+                            __protocol.write_struct(key)?;
+                            ::std::result::Result::Ok(())
+                        },
+                        |__protocol, val| {
+                            __protocol.write_struct(val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.xtructs.as_ref() {
+                    __protocol.write_list_field(
+                        2,
+                        ::pilota::thrift::TType::Struct,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_struct(val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1755,46 +1480,74 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut user_map = None;
+                let mut xtructs = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestEnumResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                user_map = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                xtructs = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<Xtruct> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(::pilota::thrift::Message::decode(__protocol)?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `Insanity` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self { user_map, xtructs };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1808,82 +1561,131 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut user_map = None;
+                    let mut xtructs = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
                     loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
 
-                                    ret = Some(ThriftTestTestEnumResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumResultRecv",
-                }) + match self {
-                    ThriftTestTestEnumResultRecv::Ok(ref value) => {
-                        __protocol.i32_field_len(Some(0), (value).inner())
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestOnewayResultSend {
-            #[derivative(Default)]
-            Ok(()),
-        }
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
 
-        impl ::pilota::thrift::Message for ThriftTestTestOnewayResultSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayResultSend",
-                })?;
-                match self {
-                    ThriftTestTestOnewayResultSend::Ok(ref value) => {}
+                    break;
+                } else {
+
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map  => {
+                    user_map = Some({
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                        }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+
+                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::List  => {
+                    xtructs = Some({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push(<Xtruct as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
+
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `Insanity` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { user_map, xtructs };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Insanity" })
+                    + self.user_map.as_ref().map_or(0, |value| {
+                        __protocol.map_field_len(
+                            Some(1),
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I64,
+                            value,
+                            |__protocol, key| __protocol.struct_len(key),
+                            |__protocol, val| __protocol.struct_len(val),
+                        )
+                    })
+                    + self.xtructs.as_ref().map_or(0, |value| {
+                        __protocol.list_field_len(
+                            Some(2),
+                            ::pilota::thrift::TType::Struct,
+                            value,
+                            |__protocol, el| __protocol.struct_len(el),
+                        )
+                    })
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMultiExceptionResultSend {
+            #[derivative(Default)]
+            Ok(Xtruct),
+
+            Err1(Xception),
+
+            Err2(Xception2),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMultiExceptionResultSend",
+                })?;
+                match self {
+                    ThriftTestTestMultiExceptionResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    ThriftTestTestMultiExceptionResultSend::Err1(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    ThriftTestTestMultiExceptionResultSend::Err2(ref value) => {
+                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1906,6 +1708,50 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestMultiExceptionResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionResultSend::Err1(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(2) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionResultSend::Err2(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -1916,7 +1762,10 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Ok(ThriftTestTestOnewayResultSend::Ok(()))
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
                 }
             }
 
@@ -1940,6 +1789,60 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Ok(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Err1(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(2) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Err2(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -1950,7 +1853,10 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Ok(ThriftTestTestOnewayResultSend::Ok(()))
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
                     }
                 })
             }
@@ -1959,18 +1865,26 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayResultSend",
+                    name: "ThriftTestTestMultiExceptionResultSend",
                 }) + match self {
-                    ThriftTestTestOnewayResultSend::Ok(ref value) => 0,
+                    ThriftTestTestMultiExceptionResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                    ThriftTestTestMultiExceptionResultSend::Err1(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                    ThriftTestTestMultiExceptionResultSend::Err2(ref value) => {
+                        __protocol.struct_field_len(Some(2), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStringArgsRecv {
-            pub thing: ::pilota::FastStr,
+        pub struct ThriftTestTestNestArgsSend {
+            pub thing: Xtruct2,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestStringArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestNestArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1978,11 +1892,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringArgsRecv",
+                    name: "ThriftTestTestNestArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.thing).clone())?;
+                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -2011,9 +1925,9 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                thing = Some(__protocol.read_faststr()?);
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -2026,7 +1940,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestNestArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -2070,14 +1984,19 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    thing = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                                    thing = Some(
+                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
 
                             __protocol.read_field_end().await?;
                         }
@@ -2086,7 +2005,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestNestArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -2110,225 +2029,33 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringArgsRecv",
-                }) + __protocol.faststr_field_len(Some(1), &self.thing)
+                    name: "ThriftTestTestNestArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMapResultRecv {
-            #[derivative(Default)]
-            Ok(::pilota::AHashMap<i32, i32>),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestMapResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestMapResultRecv::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_i32(*key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.i32_len(*key),
-                                    |__protocol, val| __protocol.i32_len(*val),
-                                );
-                                ret = Some(ThriftTestTestMapResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i32().await?,
-                                                __protocol.read_i32().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
-
-                                    ret = Some(ThriftTestTestMapResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapResultRecv",
-                }) + match self {
-                    ThriftTestTestMapResultRecv::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, key| __protocol.i32_len(*key),
-                        |__protocol, val| __protocol.i32_len(*val),
-                    ),
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Xtruct3 {
-            pub string_thing: ::std::option::Option<::pilota::FastStr>,
-
-            pub changed: ::std::option::Option<i32>,
-
-            pub i32_thing: ::std::option::Option<i32>,
+        pub struct Xception2 {
+            pub error_code: ::std::option::Option<i32>,
 
-            pub i64_thing: ::std::option::Option<i64>,
+            pub struct_thing: ::std::option::Option<Xtruct>,
         }
-        impl ::pilota::thrift::Message for Xtruct3 {
+        impl ::pilota::thrift::Message for Xception2 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct3" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xception2" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.string_thing.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                if let Some(value) = self.changed.as_ref() {
-                    __protocol.write_i32_field(4, *value)?;
-                }
-                if let Some(value) = self.i32_thing.as_ref() {
-                    __protocol.write_i32_field(9, *value)?;
+                if let Some(value) = self.error_code.as_ref() {
+                    __protocol.write_i32_field(1, *value)?;
                 }
-                if let Some(value) = self.i64_thing.as_ref() {
-                    __protocol.write_i64_field(11, *value)?;
+                if let Some(value) = self.struct_thing.as_ref() {
+                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2341,10 +2068,8 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut string_thing = None;
-                let mut changed = None;
-                let mut i32_thing = None;
-                let mut i64_thing = None;
+                let mut error_code = None;
+                let mut struct_thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -2360,19 +2085,13 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                string_thing = Some(__protocol.read_faststr()?);
-                            }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                changed = Some(__protocol.read_i32()?);
-                            }
-                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                i32_thing = Some(__protocol.read_i32()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                error_code = Some(__protocol.read_i32()?);
                             }
-                            Some(11) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                i64_thing = Some(__protocol.read_i64()?);
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                struct_thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -2386,7 +2105,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `Xtruct3` field(#{}) failed, caused by: ",
+                            "decode struct `Xception2` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -2395,10 +2114,8 @@ pub mod apache {
                 __protocol.read_struct_end()?;
 
                 let data = Self {
-                    string_thing,
-                    changed,
-                    i32_thing,
-                    i64_thing,
+                    error_code,
+                    struct_thing,
                 };
                 ::std::result::Result::Ok(data)
             }
@@ -2414,10 +2131,8 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut string_thing = None;
-                    let mut changed = None;
-                    let mut i32_thing = None;
-                    let mut i64_thing = None;
+                    let mut error_code = None;
+                    let mut struct_thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -2432,25 +2147,20 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    string_thing = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(4)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    changed = Some(__protocol.read_i32().await?);
-                                }
-                                Some(9)
                                     if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    i32_thing = Some(__protocol.read_i32().await?);
+                                    error_code = Some(__protocol.read_i32().await?);
                                 }
-                                Some(11)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    i64_thing = Some(__protocol.read_i64().await?);
+                                    struct_thing = Some(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -2465,7 +2175,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `Xtruct3` field(#{}) failed, caused by: ",
+                                "decode struct `Xception2` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -2474,10 +2184,8 @@ pub mod apache {
                     __protocol.read_struct_end().await?;
 
                     let data = Self {
-                        string_thing,
-                        changed,
-                        i32_thing,
-                        i64_thing,
+                        error_code,
+                        struct_thing,
                     };
                     ::std::result::Result::Ok(data)
                 })
@@ -2487,50 +2195,49 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct3" })
-                    + self
-                        .string_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self
-                        .changed
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(4), *value))
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xception2" })
                     + self
-                        .i32_thing
+                        .error_code
                         .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(9), *value))
+                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
                     + self
-                        .i64_thing
+                        .struct_thing
                         .as_ref()
-                        .map_or(0, |value| __protocol.i64_field_len(Some(11), *value))
+                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestBinaryResultRecv {
-            #[derivative(Default)]
-            Ok(::pilota::Bytes),
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMapArgsSend {
+            pub thing: ::pilota::AHashMap<i32, i32>,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestBinaryResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMapArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestBinaryResultRecv::Ok(ref value) => {
-                        __protocol.write_bytes_field(0, (value).clone())?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_map_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, key| {
+                        __protocol.write_i32(*key)?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -2541,46 +2248,60 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_bytes()?;
-                                __protocol.bytes_len(&field_ident);
-                                ret = Some(ThriftTestTestBinaryResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                thing = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -2594,67 +2315,94 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_bytes().await?;
+                    let mut thing = None;
 
-                                    ret = Some(ThriftTestTestBinaryResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                {
+                                    thing = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i32().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryResultRecv",
-                }) + match self {
-                    ThriftTestTestBinaryResultRecv::Ok(ref value) => {
-                        __protocol.bytes_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestMapArgsSend",
+                }) + __protocol.map_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, key| __protocol.i32_len(*key),
+                    |__protocol, val| __protocol.i32_len(*val),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum SecondServiceSecondtestStringResultSend {
+        pub enum ThriftTestTestOnewayResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::FastStr),
+            Ok(()),
         }
 
-        impl ::pilota::thrift::Message for SecondServiceSecondtestStringResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestOnewayResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -2662,12 +2410,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringResultSend",
+                    name: "ThriftTestTestOnewayResultRecv",
                 })?;
                 match self {
-                    SecondServiceSecondtestStringResultSend::Ok(ref value) => {
-                        __protocol.write_faststr_field(0, (value).clone())?;
-                    }
+                    ThriftTestTestOnewayResultRecv::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2690,21 +2436,6 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_faststr()?;
-                                __protocol.faststr_len(&field_ident);
-                                ret =
-                                    Some(SecondServiceSecondtestStringResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -2715,10 +2446,7 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
+                    ::std::result::Result::Ok(ThriftTestTestOnewayResultRecv::Ok(()))
                 }
             }
 
@@ -2742,20 +2470,6 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_faststr().await?;
-
-                                    ret = Some(SecondServiceSecondtestStringResultSend::Ok(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -2766,10 +2480,7 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
+                        ::std::result::Result::Ok(ThriftTestTestOnewayResultRecv::Ok(()))
                     }
                 })
             }
@@ -2778,11 +2489,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringResultSend",
+                    name: "ThriftTestTestOnewayResultRecv",
                 }) + match self {
-                    SecondServiceSecondtestStringResultSend::Ok(ref value) => {
-                        __protocol.faststr_field_len(Some(0), value)
-                    }
+                    ThriftTestTestOnewayResultRecv::Ok(ref value) => 0,
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -2790,12 +2499,12 @@ pub mod apache {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestByteResultRecv {
+        pub enum ThriftTestTestVoidResultRecv {
             #[derivative(Default)]
-            Ok(i8),
+            Ok(()),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestByteResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestVoidResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -2803,12 +2512,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteResultRecv",
+                    name: "ThriftTestTestVoidResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestByteResultRecv::Ok(ref value) => {
-                        __protocol.write_i8_field(0, *value)?;
-                    }
+                    ThriftTestTestVoidResultRecv::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2831,20 +2538,6 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_i8()?;
-                                __protocol.i8_len(*&field_ident);
-                                ret = Some(ThriftTestTestByteResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -2855,10 +2548,7 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
+                    ::std::result::Result::Ok(ThriftTestTestVoidResultRecv::Ok(()))
                 }
             }
 
@@ -2882,18 +2572,6 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_i8().await?;
-
-                                    ret = Some(ThriftTestTestByteResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -2904,10 +2582,7 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
+                        ::std::result::Result::Ok(ThriftTestTestVoidResultRecv::Ok(()))
                     }
                 })
             }
@@ -2916,20 +2591,18 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteResultRecv",
+                    name: "ThriftTestTestVoidResultRecv",
                 }) + match self {
-                    ThriftTestTestByteResultRecv::Ok(ref value) => {
-                        __protocol.i8_field_len(Some(0), *value)
-                    }
+                    ThriftTestTestVoidResultRecv::Ok(ref value) => 0,
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestExceptionArgsSend {
-            pub arg: ::pilota::FastStr,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestStringMapArgsSend {
+            pub thing: ::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestExceptionArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStringMapArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -2937,11 +2610,24 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionArgsSend",
+                    name: "ThriftTestTestStringMapArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.arg).clone())?;
+                __protocol.write_map_field(
+                    1,
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Binary,
+                    &&self.thing,
+                    |__protocol, key| {
+                        __protocol.write_faststr((key).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_faststr((val).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -2953,7 +2639,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -2969,10 +2655,19 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                arg = Some(__protocol.read_faststr()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                thing = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_faststr()?,
+                                            __protocol.read_faststr()?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -2985,20 +2680,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg) = arg else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self { arg };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -3013,7 +2708,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -3028,10 +2723,21 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    arg = Some(__protocol.read_faststr().await?);
+                                    thing = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_faststr().await?,
+                                                __protocol.read_faststr().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -3045,22 +2751,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg) = arg else {
+                    let Some(thing) = thing else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg is required".to_string(),
+                                "field thing is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { arg };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -3069,21 +2775,28 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionArgsSend",
-                }) + __protocol.faststr_field_len(Some(1), &self.arg)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestStringMapArgsSend",
+                }) + __protocol.map_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Binary,
+                    &self.thing,
+                    |__protocol, key| __protocol.faststr_len(key),
+                    |__protocol, val| __protocol.faststr_len(val),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
+        pub trait ThriftTest {}
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMapMapResultSend {
+        pub enum ThriftTestTestStringResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::AHashMap<i32, ::pilota::AHashMap<i32, i32>>),
+            Ok(::pilota::FastStr),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestMapMapResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStringResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -3091,36 +2804,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapResultSend",
+                    name: "ThriftTestTestStringResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestMapMapResultSend::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::Map,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_i32(*key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_map(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::I32,
-                                    &val,
-                                    |__protocol, key| {
-                                        __protocol.write_i32(*key)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                    |__protocol, val| {
-                                        __protocol.write_i32(*val)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
+                    ThriftTestTestStringResultRecv::Ok(ref value) => {
+                        __protocol.write_faststr_field(0, (value).clone())?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -3146,43 +2834,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, {
-                                            let map_ident = __protocol.read_map_begin()?;
-                                            let mut val =
-                                                ::pilota::AHashMap::with_capacity(map_ident.size);
-                                            for _ in 0..map_ident.size {
-                                                val.insert(
-                                                    __protocol.read_i32()?,
-                                                    __protocol.read_i32()?,
-                                                );
-                                            }
-                                            __protocol.read_map_end()?;
-                                            val
-                                        });
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::Map,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.i32_len(*key),
-                                    |__protocol, val| {
-                                        __protocol.map_len(
-                                            ::pilota::thrift::TType::I32,
-                                            ::pilota::thrift::TType::I32,
-                                            val,
-                                            |__protocol, key| __protocol.i32_len(*key),
-                                            |__protocol, val| __protocol.i32_len(*val),
-                                        )
-                                    },
-                                );
-                                ret = Some(ThriftTestTestMapMapResultSend::Ok(field_ident));
+                                let field_ident = __protocol.read_faststr()?;
+                                __protocol.faststr_len(&field_ident);
+                                ret = Some(ThriftTestTestStringResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -3231,31 +2885,9 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(__protocol.read_i32().await?, {
-                                                let map_ident = __protocol.read_map_begin().await?;
-                                                let mut val = ::pilota::AHashMap::with_capacity(
-                                                    map_ident.size,
-                                                );
-                                                for _ in 0..map_ident.size {
-                                                    val.insert(
-                                                        __protocol.read_i32().await?,
-                                                        __protocol.read_i32().await?,
-                                                    );
-                                                }
-                                                __protocol.read_map_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
+                                    let field_ident = __protocol.read_faststr().await?;
 
-                                    ret = Some(ThriftTestTestMapMapResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestStringResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -3285,59 +2917,37 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapResultSend",
+                    name: "ThriftTestTestStringResultRecv",
                 }) + match self {
-                    ThriftTestTestMapMapResultSend::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::Map,
-                        value,
-                        |__protocol, key| __protocol.i32_len(*key),
-                        |__protocol, val| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::I32,
-                                val,
-                                |__protocol, key| __protocol.i32_len(*key),
-                                |__protocol, val| __protocol.i32_len(*val),
-                            )
-                        },
-                    ),
+                    ThriftTestTestStringResultRecv::Ok(ref value) => {
+                        __protocol.faststr_field_len(Some(0), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ListTypeVersioningV1 {
-            pub myints: ::std::option::Option<::std::vec::Vec<i32>>,
-
-            pub hello: ::std::option::Option<::pilota::FastStr>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum SecondServiceSecondtestStringResultSend {
+            #[derivative(Default)]
+            Ok(::pilota::FastStr),
         }
-        impl ::pilota::thrift::Message for ListTypeVersioningV1 {
+
+        impl ::pilota::thrift::Message for SecondServiceSecondtestStringResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ListTypeVersioningV1",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.myints.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::I32,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_i32(*val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.hello.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "SecondServiceSecondtestStringResultSend",
+                })?;
+                match self {
+                    SecondServiceSecondtestStringResultSend::Ok(ref value) => {
+                        __protocol.write_faststr_field(0, (value).clone())?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -3349,65 +2959,47 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut myints = None;
-                let mut hello = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                myints = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                hello = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_faststr()?;
+                                __protocol.faststr_len(&field_ident);
+                                ret =
+                                    Some(SecondServiceSecondtestStringResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `ListTypeVersioningV1` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self { myints, hello };
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -3421,60 +3013,44 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut myints = None;
-                    let mut hello = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    myints = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    hello = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_faststr().await?;
+
+                                    ret = Some(SecondServiceSecondtestStringResultSend::Ok(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ListTypeVersioningV1` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self { myints, hello };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -3482,53 +3058,40 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ListTypeVersioningV1",
-                }) + self.myints.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, el| __protocol.i32_len(*el),
-                    )
-                }) + self
-                    .hello
-                    .as_ref()
-                    .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
-                    + __protocol.field_stop_len()
+                    name: "SecondServiceSecondtestStringResultSend",
+                }) + match self {
+                    SecondServiceSecondtestStringResultSend::Ok(ref value) => {
+                        __protocol.faststr_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestSetResultSend {
-            #[derivative(Default)]
-            Ok(::pilota::AHashSet<i32>),
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestSetArgsSend {
+            pub thing: ::pilota::AHashSet<i32>,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestSetResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestSetArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetResultSend",
-                })?;
-                match self {
-                    ThriftTestTestSetResultSend::Ok(ref value) => {
-                        __protocol.write_set_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestSetArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_set_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -3539,20 +3102,25 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = {
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                thing = Some({
                                     let list_ident = __protocol.read_set_begin()?;
                                     let mut val =
                                         ::pilota::AHashSet::with_capacity(list_ident.size);
@@ -3561,37 +3129,34 @@ pub mod apache {
                                     }
                                     __protocol.read_set_end()?;
                                     val
-                                };
-                                __protocol.set_len(
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, el| __protocol.i32_len(*el),
-                                );
-                                ret = Some(ThriftTestTestSetResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -3605,18 +3170,24 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                {
+                                    thing = Some({
                                         let list_ident = __protocol.read_set_begin().await?;
                                         let mut val =
                                             ::pilota::AHashSet::with_capacity(list_ident.size);
@@ -3625,31 +3196,191 @@ pub mod apache {
                                         }
                                         __protocol.read_set_end().await?;
                                         val
-                                    };
-
-                                    ret = Some(ThriftTestTestSetResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestSetArgsSend",
+                }) + __protocol.set_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, el| __protocol.i32_len(*el),
+                ) + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct SecondServiceSecondtestStringArgsRecv {
+            pub thing: ::pilota::FastStr,
+        }
+        impl ::pilota::thrift::Message for SecondServiceSecondtestStringArgsRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "SecondServiceSecondtestStringArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_faststr_field(1, (&self.thing).clone())?;
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                thing = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    thing = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -3657,27 +3388,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetResultSend",
-                }) + match self {
-                    ThriftTestTestSetResultSend::Ok(ref value) => __protocol.set_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, el| __protocol.i32_len(*el),
-                    ),
-                } + __protocol.field_stop_len()
+                    name: "SecondServiceSecondtestStringArgsRecv",
+                }) + __protocol.faststr_field_len(Some(1), &self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStructResultSend {
+        pub enum ThriftTestTestBoolResultRecv {
             #[derivative(Default)]
-            Ok(Xtruct),
+            Ok(bool),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestStructResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestBoolResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -3685,11 +3410,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructResultSend",
+                    name: "ThriftTestTestBoolResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestStructResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    ThriftTestTestBoolResultRecv::Ok(ref value) => {
+                        __protocol.write_bool_field(0, *value)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -3715,9 +3440,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestStructResultSend::Ok(field_ident));
+                                let field_ident = __protocol.read_bool()?;
+                                __protocol.bool_len(*&field_ident);
+                                ret = Some(ThriftTestTestBoolResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -3766,13 +3491,9 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                                    let field_ident = __protocol.read_bool().await?;
 
-                                    ret = Some(ThriftTestTestStructResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestBoolResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -3802,40 +3523,118 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructResultSend",
+                    name: "ThriftTestTestBoolResultRecv",
                 }) + match self {
-                    ThriftTestTestStructResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
+                    ThriftTestTestBoolResultRecv::Ok(ref value) => {
+                        __protocol.bool_field_len(Some(0), *value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ListBonks {
-            pub bonk: ::std::option::Option<::std::vec::Vec<Bonk>>,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct VersioningTestV2 {
+            pub begin_in_both: ::std::option::Option<i32>,
+
+            pub newint: ::std::option::Option<i32>,
+
+            pub newbyte: ::std::option::Option<i8>,
+
+            pub newshort: ::std::option::Option<i16>,
+
+            pub newlong: ::std::option::Option<i64>,
+
+            pub newdouble: ::std::option::Option<f64>,
+
+            pub newstruct: ::std::option::Option<Bonk>,
+
+            pub newlist: ::std::option::Option<::std::vec::Vec<i32>>,
+
+            pub newset: ::std::option::Option<::pilota::AHashSet<i32>>,
+
+            pub newmap: ::std::option::Option<::pilota::AHashMap<i32, i32>>,
+
+            pub newstring: ::std::option::Option<::pilota::FastStr>,
+
+            pub end_in_both: ::std::option::Option<i32>,
         }
-        impl ::pilota::thrift::Message for ListBonks {
+        impl ::pilota::thrift::Message for VersioningTestV2 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ListBonks" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "VersioningTestV2",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.bonk.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::Struct,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_struct(val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+                if let Some(value) = self.begin_in_both.as_ref() {
+                    __protocol.write_i32_field(1, *value)?;
+                }
+                if let Some(value) = self.newint.as_ref() {
+                    __protocol.write_i32_field(2, *value)?;
+                }
+                if let Some(value) = self.newbyte.as_ref() {
+                    __protocol.write_i8_field(3, *value)?;
+                }
+                if let Some(value) = self.newshort.as_ref() {
+                    __protocol.write_i16_field(4, *value)?;
+                }
+                if let Some(value) = self.newlong.as_ref() {
+                    __protocol.write_i64_field(5, *value)?;
+                }
+                if let Some(value) = self.newdouble.as_ref() {
+                    __protocol.write_double_field(6, *value)?;
+                }
+                if let Some(value) = self.newstruct.as_ref() {
+                    __protocol.write_struct_field(7, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.newlist.as_ref() {
+                    __protocol.write_list_field(
+                        8,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.newset.as_ref() {
+                    __protocol.write_set_field(
+                        9,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.newmap.as_ref() {
+                    __protocol.write_map_field(
+                        10,
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, key| {
+                            __protocol.write_i32(*key)?;
+                            ::std::result::Result::Ok(())
+                        },
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.newstring.as_ref() {
+                    __protocol.write_faststr_field(11, (value).clone())?;
+                }
+                if let Some(value) = self.end_in_both.as_ref() {
+                    __protocol.write_i32_field(12, *value)?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -3847,7 +3646,18 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut bonk = None;
+                let mut begin_in_both = None;
+                let mut newint = None;
+                let mut newbyte = None;
+                let mut newshort = None;
+                let mut newlong = None;
+                let mut newdouble = None;
+                let mut newstruct = None;
+                let mut newlist = None;
+                let mut newset = None;
+                let mut newmap = None;
+                let mut newstring = None;
+                let mut end_in_both = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -3863,20 +3673,76 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                bonk = Some(unsafe {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                begin_in_both = Some(__protocol.read_i32()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                newint = Some(__protocol.read_i32()?);
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                newbyte = Some(__protocol.read_i8()?);
+                            }
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I16 => {
+                                newshort = Some(__protocol.read_i16()?);
+                            }
+                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                newlong = Some(__protocol.read_i64()?);
+                            }
+                            Some(6)
+                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
+                            {
+                                newdouble = Some(__protocol.read_double()?);
+                            }
+                            Some(7)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                newstruct = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(8) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                newlist = Some(unsafe {
                                     let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<Bonk> = Vec::with_capacity(list_ident.size);
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
                                     for i in 0..list_ident.size {
                                         val.as_mut_ptr()
                                             .offset(i as isize)
-                                            .write(::pilota::thrift::Message::decode(__protocol)?);
+                                            .write(__protocol.read_i32()?);
                                     }
                                     val.set_len(list_ident.size);
                                     __protocol.read_list_end()?;
                                     val
                                 });
                             }
+                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                newset = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_i32()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
+                            }
+                            Some(10) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                newmap = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
+                            }
+                            Some(11)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                newstring = Some(__protocol.read_faststr()?);
+                            }
+                            Some(12) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                end_in_both = Some(__protocol.read_i32()?);
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -3889,7 +3755,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `ListBonks` field(#{}) failed, caused by: ",
+                            "decode struct `VersioningTestV2` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -3897,7 +3763,20 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { bonk };
+                let data = Self {
+                    begin_in_both,
+                    newint,
+                    newbyte,
+                    newshort,
+                    newlong,
+                    newdouble,
+                    newstruct,
+                    newlist,
+                    newset,
+                    newmap,
+                    newstring,
+                    end_in_both,
+                };
                 ::std::result::Result::Ok(data)
             }
 
@@ -3912,7 +3791,18 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut bonk = None;
+                    let mut begin_in_both = None;
+                    let mut newint = None;
+                    let mut newbyte = None;
+                    let mut newshort = None;
+                    let mut newlong = None;
+                    let mut newdouble = None;
+                    let mut newstruct = None;
+                    let mut newlist = None;
+                    let mut newset = None;
+                    let mut newmap = None;
+                    let mut newstring = None;
+                    let mut end_in_both = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -3927,45 +3817,137 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    begin_in_both = Some(__protocol.read_i32().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    newint = Some(__protocol.read_i32().await?);
+                                }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    newbyte = Some(__protocol.read_i8().await?);
+                                }
+                                Some(4)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I16 =>
+                                {
+                                    newshort = Some(__protocol.read_i16().await?);
+                                }
+                                Some(5)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    newlong = Some(__protocol.read_i64().await?);
+                                }
+                                Some(6)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Double =>
+                                {
+                                    newdouble = Some(__protocol.read_double().await?);
+                                }
+                                Some(7)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    newstruct = Some(
+                                        <Bonk as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                Some(8)
                                     if field_ident.field_type == ::pilota::thrift::TType::List =>
                                 {
-                                    bonk = Some({
+                                    newlist = Some({
                                         let list_ident = __protocol.read_list_begin().await?;
                                         let mut val = Vec::with_capacity(list_ident.size);
                                         for _ in 0..list_ident.size {
-                                            val.push(
-                                                <Bonk as ::pilota::thrift::Message>::decode_async(
-                                                    __protocol,
-                                                )
-                                                .await?,
-                                            );
+                                            val.push(__protocol.read_i32().await?);
                                         }
                                         __protocol.read_list_end().await?;
                                         val
                                     });
                                 }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                                Some(9)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                {
+                                    newset = Some({
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    });
                                 }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `ListBonks` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { bonk };
+                                Some(10)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                {
+                                    newmap = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i32().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
+                                }
+                                Some(11)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    newstring = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(12)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    end_in_both = Some(__protocol.read_i32().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `VersioningTestV2` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self {
+                        begin_in_both,
+                        newint,
+                        newbyte,
+                        newshort,
+                        newlong,
+                        newdouble,
+                        newstruct,
+                        newlist,
+                        newset,
+                        newmap,
+                        newstring,
+                        end_in_both,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -3973,43 +3955,99 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ListBonks" })
-                    + self.bonk.as_ref().map_or(0, |value| {
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "VersioningTestV2",
+                }) + self
+                    .begin_in_both
+                    .as_ref()
+                    .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
+                    + self
+                        .newint
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(2), *value))
+                    + self
+                        .newbyte
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i8_field_len(Some(3), *value))
+                    + self
+                        .newshort
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i16_field_len(Some(4), *value))
+                    + self
+                        .newlong
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i64_field_len(Some(5), *value))
+                    + self
+                        .newdouble
+                        .as_ref()
+                        .map_or(0, |value| __protocol.double_field_len(Some(6), *value))
+                    + self
+                        .newstruct
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(7), value))
+                    + self.newlist.as_ref().map_or(0, |value| {
                         __protocol.list_field_len(
-                            Some(1),
-                            ::pilota::thrift::TType::Struct,
+                            Some(8),
+                            ::pilota::thrift::TType::I32,
                             value,
-                            |__protocol, el| __protocol.struct_len(el),
+                            |__protocol, el| __protocol.i32_len(*el),
+                        )
+                    })
+                    + self.newset.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(9),
+                            ::pilota::thrift::TType::I32,
+                            value,
+                            |__protocol, el| __protocol.i32_len(*el),
                         )
                     })
+                    + self.newmap.as_ref().map_or(0, |value| {
+                        __protocol.map_field_len(
+                            Some(10),
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I32,
+                            value,
+                            |__protocol, key| __protocol.i32_len(*key),
+                            |__protocol, val| __protocol.i32_len(*val),
+                        )
+                    })
+                    + self
+                        .newstring
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(11), value))
+                    + self
+                        .end_in_both
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(12), *value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestI64ResultSend {
-            #[derivative(Default)]
-            Ok(i64),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestListArgsSend {
+            pub thing: ::std::vec::Vec<i32>,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestI64ResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestListArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ResultSend",
-                })?;
-                match self {
-                    ThriftTestTestI64ResultSend::Ok(ref value) => {
-                        __protocol.write_i64_field(0, *value)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestListArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_list_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -4020,46 +4058,63 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_i64()?;
-                                __protocol.i64_len(*&field_ident);
-                                ret = Some(ThriftTestTestI64ResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                thing = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_i32()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -4073,42 +4128,62 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_i64().await?;
-
-                                    ret = Some(ThriftTestTestI64ResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    thing = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -4116,22 +4191,22 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ResultSend",
-                }) + match self {
-                    ThriftTestTestI64ResultSend::Ok(ref value) => {
-                        __protocol.i64_field_len(Some(0), *value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestListArgsSend",
+                }) + __protocol.list_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, el| __protocol.i32_len(*el),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMultiExceptionArgsRecv {
-            pub arg0: ::pilota::FastStr,
-
-            pub arg1: ::pilota::FastStr,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct GuessProtocolStruct {
+            pub map_field:
+                ::std::option::Option<::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionArgsRecv {
+        impl ::pilota::thrift::Message for GuessProtocolStruct {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -4139,12 +4214,26 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionArgsRecv",
+                    name: "GuessProtocolStruct",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.arg0).clone())?;
-                __protocol.write_faststr_field(2, (&self.arg1).clone())?;
+                if let Some(value) = self.map_field.as_ref() {
+                    __protocol.write_map_field(
+                        7,
+                        ::pilota::thrift::TType::Binary,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, key| {
+                            __protocol.write_faststr((key).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -4156,8 +4245,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg0 = None;
-                let mut arg1 = None;
+                let mut map_field = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -4173,15 +4261,19 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                arg0 = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                arg1 = Some(__protocol.read_faststr()?);
+                            Some(7) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                map_field = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_faststr()?,
+                                            __protocol.read_faststr()?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -4194,26 +4286,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `GuessProtocolStruct` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg0) = arg0 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg0 is required".to_string(),
-                    ));
-                };
-                let Some(arg1) = arg1 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg1 is required".to_string(),
-                    ));
-                };
-
-                let data = Self { arg0, arg1 };
+                let data = Self { map_field };
                 ::std::result::Result::Ok(data)
             }
 
@@ -4228,8 +4310,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg0 = None;
-                    let mut arg1 = None;
+                    let mut map_field = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -4243,17 +4324,22 @@ pub mod apache {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    arg0 = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                Some(7)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    arg1 = Some(__protocol.read_faststr().await?);
+                                    map_field = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_faststr().await?,
+                                                __protocol.read_faststr().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -4267,30 +4353,13 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `GuessProtocolStruct` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg0) = arg0 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg0 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg1) = arg1 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg1 is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { arg0, arg1 };
+                    let data = Self { map_field };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -4299,22 +4368,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionArgsRecv",
-                }) + __protocol.faststr_field_len(Some(1), &self.arg0)
-                    + __protocol.faststr_field_len(Some(2), &self.arg1)
-                    + __protocol.field_stop_len()
+                    name: "GuessProtocolStruct",
+                }) + self.map_field.as_ref().map_or(0, |value| {
+                    __protocol.map_field_len(
+                        Some(7),
+                        ::pilota::thrift::TType::Binary,
+                        ::pilota::thrift::TType::Binary,
+                        value,
+                        |__protocol, key| __protocol.faststr_len(key),
+                        |__protocol, val| __protocol.faststr_len(val),
+                    )
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStringResultSend {
+        pub enum ThriftTestTestByteResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::FastStr),
+            Ok(i8),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestStringResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestByteResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -4322,11 +4398,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringResultSend",
+                    name: "ThriftTestTestByteResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestStringResultSend::Ok(ref value) => {
-                        __protocol.write_faststr_field(0, (value).clone())?;
+                    ThriftTestTestByteResultRecv::Ok(ref value) => {
+                        __protocol.write_i8_field(0, *value)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -4352,9 +4428,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_faststr()?;
-                                __protocol.faststr_len(&field_ident);
-                                ret = Some(ThriftTestTestStringResultSend::Ok(field_ident));
+                                let field_ident = __protocol.read_i8()?;
+                                __protocol.i8_len(*&field_ident);
+                                ret = Some(ThriftTestTestByteResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -4403,9 +4479,9 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_faststr().await?;
+                                    let field_ident = __protocol.read_i8().await?;
 
-                                    ret = Some(ThriftTestTestStringResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestByteResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -4435,30 +4511,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringResultSend",
+                    name: "ThriftTestTestByteResultRecv",
                 }) + match self {
-                    ThriftTestTestStringResultSend::Ok(ref value) => {
-                        __protocol.faststr_field_len(Some(0), value)
+                    ThriftTestTestByteResultRecv::Ok(ref value) => {
+                        __protocol.i8_field_len(Some(0), *value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMultiArgsSend {
-            pub arg0: i8,
-
-            pub arg1: i32,
-
-            pub arg2: i64,
-
-            pub arg3: ::pilota::AHashMap<i16, ::pilota::FastStr>,
-
-            pub arg4: Numberz,
-
-            pub arg5: UserId,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct NestedListsI32x3 {
+            pub integerlist:
+                ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::vec::Vec<i32>>>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMultiArgsSend {
+        impl ::pilota::thrift::Message for NestedListsI32x3 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -4466,29 +4533,35 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiArgsSend",
+                    name: "NestedListsI32x3",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i8_field(1, *&self.arg0)?;
-                __protocol.write_i32_field(2, *&self.arg1)?;
-                __protocol.write_i64_field(3, *&self.arg2)?;
-                __protocol.write_map_field(
-                    4,
-                    ::pilota::thrift::TType::I16,
-                    ::pilota::thrift::TType::Binary,
-                    &&self.arg3,
-                    |__protocol, key| {
-                        __protocol.write_i16(*key)?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_faststr((val).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                __protocol.write_i32_field(5, (&self.arg4).inner())?;
-                __protocol.write_struct_field(6, &self.arg5, ::pilota::thrift::TType::I64)?;
+                if let Some(value) = self.integerlist.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::List,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_list(
+                                ::pilota::thrift::TType::List,
+                                &val,
+                                |__protocol, val| {
+                                    __protocol.write_list(
+                                        ::pilota::thrift::TType::I32,
+                                        &val,
+                                        |__protocol, val| {
+                                            __protocol.write_i32(*val)?;
+                                            ::std::result::Result::Ok(())
+                                        },
+                                    )?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -4500,12 +4573,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg0 = None;
-                let mut arg1 = None;
-                let mut arg2 = None;
-                let mut arg3 = None;
-                let mut arg4 = None;
-                let mut arg5 = None;
+                let mut integerlist = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -4521,35 +4589,42 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                arg0 = Some(__protocol.read_i8()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                arg1 = Some(__protocol.read_i32()?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                arg2 = Some(__protocol.read_i64()?);
-                            }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                arg3 = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_i16()?,
-                                            __protocol.read_faststr()?,
-                                        );
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                integerlist = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::std::vec::Vec<::std::vec::Vec<i32>>> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                            let list_ident = __protocol.read_list_begin()?;
+                                            let mut val: Vec<::std::vec::Vec<i32>> =
+                                                Vec::with_capacity(list_ident.size);
+                                            for i in 0..list_ident.size {
+                                                val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                                    let list_ident =
+                                                        __protocol.read_list_begin()?;
+                                                    let mut val: Vec<i32> =
+                                                        Vec::with_capacity(list_ident.size);
+                                                    for i in 0..list_ident.size {
+                                                        val.as_mut_ptr()
+                                                            .offset(i as isize)
+                                                            .write(__protocol.read_i32()?);
+                                                    }
+                                                    val.set_len(list_ident.size);
+                                                    __protocol.read_list_end()?;
+                                                    val
+                                                });
+                                            }
+                                            val.set_len(list_ident.size);
+                                            __protocol.read_list_end()?;
+                                            val
+                                        });
                                     }
-                                    __protocol.read_map_end()?;
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
                                     val
                                 });
                             }
-                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                arg4 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(6) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                arg5 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -4561,57 +4636,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `NestedListsI32x3` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg0) = arg0 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg0 is required".to_string(),
-                    ));
-                };
-                let Some(arg1) = arg1 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg1 is required".to_string(),
-                    ));
-                };
-                let Some(arg2) = arg2 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg2 is required".to_string(),
-                    ));
-                };
-                let Some(arg3) = arg3 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg3 is required".to_string(),
-                    ));
-                };
-                let Some(arg4) = arg4 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg4 is required".to_string(),
-                    ));
-                };
-                let Some(arg5) = arg5 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg5 is required".to_string(),
-                    ));
-                };
-
-                let data = Self {
-                    arg0,
-                    arg1,
-                    arg2,
-                    arg3,
-                    arg4,
-                    arg5,
-                };
+                let data = Self { integerlist };
                 ::std::result::Result::Ok(data)
             }
 
@@ -4626,12 +4660,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg0 = None;
-                    let mut arg1 = None;
-                    let mut arg2 = None;
-                    let mut arg3 = None;
-                    let mut arg4 = None;
-                    let mut arg5 = None;
+                    let mut integerlist = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -4646,59 +4675,39 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    arg0 = Some(__protocol.read_i8().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    arg1 = Some(__protocol.read_i32().await?);
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    arg2 = Some(__protocol.read_i64().await?);
-                                }
-                                Some(4)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
                                 {
-                                    arg3 = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i16().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
+                                    integerlist = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push({
+                                                let list_ident =
+                                                    __protocol.read_list_begin().await?;
+                                                let mut val = Vec::with_capacity(list_ident.size);
+                                                for _ in 0..list_ident.size {
+                                                    val.push({
+                                                        let list_ident =
+                                                            __protocol.read_list_begin().await?;
+                                                        let mut val =
+                                                            Vec::with_capacity(list_ident.size);
+                                                        for _ in 0..list_ident.size {
+                                                            val.push(__protocol.read_i32().await?);
+                                                        }
+                                                        __protocol.read_list_end().await?;
+                                                        val
+                                                    });
+                                                }
+                                                __protocol.read_list_end().await?;
+                                                val
+                                            });
                                         }
-                                        __protocol.read_map_end().await?;
+                                        __protocol.read_list_end().await?;
                                         val
                                     });
                                 }
-                                Some(5)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    arg4 = Some(
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                Some(6)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    arg5 = Some(
-                                        <UserId as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
 
@@ -4709,69 +4718,16 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `NestedListsI32x3` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg0) = arg0 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg0 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg1) = arg1 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg1 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg2) = arg2 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg2 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg3) = arg3 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg3 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg4) = arg4 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg4 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg5) = arg5 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg5 is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self {
-                        arg0,
-                        arg1,
-                        arg2,
-                        arg3,
-                        arg4,
-                        arg5,
-                    };
+                    let data = Self { integerlist };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -4780,46 +4736,47 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiArgsSend",
-                }) + __protocol.i8_field_len(Some(1), *&self.arg0)
-                    + __protocol.i32_field_len(Some(2), *&self.arg1)
-                    + __protocol.i64_field_len(Some(3), *&self.arg2)
-                    + __protocol.map_field_len(
-                        Some(4),
-                        ::pilota::thrift::TType::I16,
-                        ::pilota::thrift::TType::Binary,
-                        &self.arg3,
-                        |__protocol, key| __protocol.i16_len(*key),
-                        |__protocol, val| __protocol.faststr_len(val),
+                    name: "NestedListsI32x3",
+                }) + self.integerlist.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::List,
+                        value,
+                        |__protocol, el| {
+                            __protocol.list_len(
+                                ::pilota::thrift::TType::List,
+                                el,
+                                |__protocol, el| {
+                                    __protocol.list_len(
+                                        ::pilota::thrift::TType::I32,
+                                        el,
+                                        |__protocol, el| __protocol.i32_len(*el),
+                                    )
+                                },
+                            )
+                        },
                     )
-                    + __protocol.i32_field_len(Some(5), (&self.arg4).inner())
-                    + __protocol.struct_field_len(Some(6), &self.arg5)
-                    + __protocol.field_stop_len()
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Bools {
-            pub im_true: ::std::option::Option<bool>,
-
-            pub im_false: ::std::option::Option<bool>,
+        pub struct ThriftTestTestEnumArgsSend {
+            pub thing: Numberz,
         }
-        impl ::pilota::thrift::Message for Bools {
+        impl ::pilota::thrift::Message for ThriftTestTestEnumArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Bools" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestEnumArgsSend",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.im_true.as_ref() {
-                    __protocol.write_bool_field(1, *value)?;
-                }
-                if let Some(value) = self.im_false.as_ref() {
-                    __protocol.write_bool_field(2, *value)?;
-                }
+                __protocol.write_i32_field(1, (&self.thing).inner())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -4831,8 +4788,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut im_true = None;
-                let mut im_false = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -4848,11 +4804,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
-                                im_true = Some(__protocol.read_bool()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
-                                im_false = Some(__protocol.read_bool()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -4865,16 +4818,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Bools` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { im_true, im_false };
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -4889,8 +4846,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut im_true = None;
-                    let mut im_false = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -4905,14 +4861,14 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
-                                {
-                                    im_true = Some(__protocol.read_bool().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    im_false = Some(__protocol.read_bool().await?);
+                                    thing = Some(
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -4926,16 +4882,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Bools` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { im_true, im_false };
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -4943,24 +4905,19 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Bools" })
-                    + self
-                        .im_true
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bool_field_len(Some(1), *value))
-                    + self
-                        .im_false
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bool_field_len(Some(2), *value))
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestEnumArgsSend",
+                }) + __protocol.i32_field_len(Some(1), (&self.thing).inner())
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestEnumArgsSend {
-            pub thing: Numberz,
+        pub struct NestedListsBonk {
+            pub bonk:
+                ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::vec::Vec<Bonk>>>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestEnumArgsSend {
+        impl ::pilota::thrift::Message for NestedListsBonk {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -4968,11 +4925,35 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumArgsSend",
+                    name: "NestedListsBonk",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, (&self.thing).inner())?;
+                if let Some(value) = self.bonk.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::List,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_list(
+                                ::pilota::thrift::TType::List,
+                                &val,
+                                |__protocol, val| {
+                                    __protocol.write_list(
+                                        ::pilota::thrift::TType::Struct,
+                                        &val,
+                                        |__protocol, val| {
+                                            __protocol.write_struct(val)?;
+                                            ::std::result::Result::Ok(())
+                                        },
+                                    )?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -4984,7 +4965,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut bonk = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -5000,35 +4981,66 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsSend` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                bonk = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::std::vec::Vec<::std::vec::Vec<Bonk>>> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                            let list_ident = __protocol.read_list_begin()?;
+                                            let mut val: Vec<::std::vec::Vec<Bonk>> =
+                                                Vec::with_capacity(list_ident.size);
+                                            for i in 0..list_ident.size {
+                                                val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                                    let list_ident =
+                                                        __protocol.read_list_begin()?;
+                                                    let mut val: Vec<Bonk> =
+                                                        Vec::with_capacity(list_ident.size);
+                                                    for i in 0..list_ident.size {
+                                                        val.as_mut_ptr().offset(i as isize).write(
+                                                            ::pilota::thrift::Message::decode(
+                                                                __protocol,
+                                                            )?,
+                                                        );
+                                                    }
+                                                    val.set_len(list_ident.size);
+                                                    __protocol.read_list_end()?;
+                                                    val
+                                                });
+                                            }
+                                            val.set_len(list_ident.size);
+                                            __protocol.read_list_end()?;
+                                            val
+                                        });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `NestedListsBonk` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let data = Self { bonk };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -5042,58 +5054,72 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut bonk = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    thing = Some(
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                    loop {
 
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
 
-                    let data = Self { thing };
+                    break;
+                } else {
+
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::List  => {
+                    bonk = Some({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push(<Bonk as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
+
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `NestedListsBonk` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { bonk };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -5102,43 +5128,53 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumArgsSend",
-                }) + __protocol.i32_field_len(Some(1), (&self.thing).inner())
-                    + __protocol.field_stop_len()
+                    name: "NestedListsBonk",
+                }) + self.bonk.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::List,
+                        value,
+                        |__protocol, el| {
+                            __protocol.list_len(
+                                ::pilota::thrift::TType::List,
+                                el,
+                                |__protocol, el| {
+                                    __protocol.list_len(
+                                        ::pilota::thrift::TType::Struct,
+                                        el,
+                                        |__protocol, el| __protocol.struct_len(el),
+                                    )
+                                },
+                            )
+                        },
+                    )
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        pub trait ThriftTest {}
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMapArgsSend {
-            pub thing: ::pilota::AHashMap<i32, i32>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestI32ResultRecv {
+            #[derivative(Default)]
+            Ok(i32),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMapArgsSend {
+
+        impl ::pilota::thrift::Message for ThriftTestTestI32ResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_map_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, key| {
-                        __protocol.write_i32(*key)?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestI32ResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestI32ResultRecv::Ok(ref value) => {
+                        __protocol.write_i32_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -5149,60 +5185,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                thing = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_i32()?;
+                                __protocol.i32_len(*&field_ident);
+                                ret = Some(ThriftTestTestI32ResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -5216,66 +5238,42 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
-                                {
-                                    thing = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i32().await?,
-                                                __protocol.read_i32().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_i32().await?;
+
+                                    ret = Some(ThriftTestTestI32ResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -5283,35 +5281,35 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapArgsSend",
-                }) + __protocol.map_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, key| __protocol.i32_len(*key),
-                    |__protocol, val| __protocol.i32_len(*val),
-                ) + __protocol.field_stop_len()
+                    name: "ThriftTestTestI32ResultRecv",
+                }) + match self {
+                    ThriftTestTestI32ResultRecv::Ok(ref value) => {
+                        __protocol.i32_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestBinaryArgsSend {
-            pub thing: ::pilota::Bytes,
+        pub struct StructB {
+            pub aa: ::std::option::Option<StructA>,
+
+            pub ab: StructA,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestBinaryArgsSend {
+        impl ::pilota::thrift::Message for StructB {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryArgsSend",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "StructB" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_bytes_field(1, (&self.thing).clone())?;
+                if let Some(value) = self.aa.as_ref() {
+                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                }
+                __protocol.write_struct_field(2, &self.ab, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -5323,7 +5321,8 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut aa = None;
+                let mut ab = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -5340,9 +5339,14 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                thing = Some(__protocol.read_bytes()?);
+                                aa = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                ab = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -5355,20 +5359,23 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `StructB` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(ab) = ab else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field ab is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self { aa, ab };
                 ::std::result::Result::Ok(data)
             }
 
@@ -5383,7 +5390,8 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut aa = None;
+                    let mut ab = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -5399,9 +5407,25 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    thing = Some(__protocol.read_bytes().await?);
+                                    aa = Some(
+                                        <StructA as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    ab = Some(
+                                        <StructA as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -5415,22 +5439,25 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `StructB` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(ab) = ab else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field ab is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self { aa, ab };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -5438,18 +5465,22 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryArgsSend",
-                }) + __protocol.bytes_field_len(Some(1), &self.thing)
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "StructB" })
+                    + self
+                        .aa
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                    + __protocol.struct_field_len(Some(2), &self.ab)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestTypedefArgsRecv {
+        pub struct ThriftTestTestTypedefArgsSend {
             pub thing: UserId,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestTypedefArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestTypedefArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -5457,7 +5488,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefArgsRecv",
+                    name: "ThriftTestTestTypedefArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -5503,7 +5534,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -5567,7 +5598,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -5591,30 +5622,35 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefArgsRecv",
+                    name: "ThriftTestTestTypedefArgsSend",
                 }) + __protocol.struct_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        pub trait SecondService {}
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestByteArgsSend {
-            pub thing: i8,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestByteArgsSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestI64ResultRecv {
+            #[derivative(Default)]
+            Ok(i64),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestI64ResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i8_field(1, *&self.thing)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestI64ResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestI64ResultRecv::Ok(ref value) => {
+                        __protocol.write_i64_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -5625,52 +5661,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                thing = Some(__protocol.read_i8()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_i64()?;
+                                __protocol.i64_len(*&field_ident);
+                                ret = Some(ThriftTestTestI64ResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -5684,54 +5714,42 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    thing = Some(__protocol.read_i8().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_i64().await?;
+
+                                    ret = Some(ThriftTestTestI64ResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -5739,17 +5757,20 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteArgsSend",
-                }) + __protocol.i8_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestI64ResultRecv",
+                }) + match self {
+                    ThriftTestTestI64ResultRecv::Ok(ref value) => {
+                        __protocol.i64_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStringMapArgsRecv {
-            pub thing: ::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMapMapArgsSend {
+            pub hello: i32,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestStringMapArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMapMapArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -5757,24 +5778,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapArgsRecv",
+                    name: "ThriftTestTestMapMapArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_map_field(
-                    1,
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Binary,
-                    &&self.thing,
-                    |__protocol, key| {
-                        __protocol.write_faststr((key).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_faststr((val).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_i32_field(1, *&self.hello)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -5786,7 +5794,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut hello = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -5802,19 +5810,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                thing = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_faststr()?,
-                                            __protocol.read_faststr()?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                hello = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -5827,20 +5824,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(hello) = hello else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field hello is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self { hello };
                 ::std::result::Result::Ok(data)
             }
 
@@ -5855,7 +5852,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut hello = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -5870,21 +5867,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    thing = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_faststr().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
+                                    hello = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -5898,22 +5883,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(hello) = hello else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field hello is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self { hello };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -5922,33 +5907,35 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapArgsRecv",
-                }) + __protocol.map_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Binary,
-                    &self.thing,
-                    |__protocol, key| __protocol.faststr_len(key),
-                    |__protocol, val| __protocol.faststr_len(val),
-                ) + __protocol.field_stop_len()
+                    name: "ThriftTestTestMapMapArgsSend",
+                }) + __protocol.i32_field_len(Some(1), *&self.hello)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct EmptyStruct {}
-        impl ::pilota::thrift::Message for EmptyStruct {
+        #[derive(PartialOrd, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestDoubleResultRecv {
+            #[derivative(Default)]
+            Ok(f64),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestDoubleResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "EmptyStruct",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestDoubleResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestDoubleResultRecv::Ok(ref value) => {
+                        __protocol.write_double_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -5959,43 +5946,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_double()?;
+                                __protocol.double_len(*&field_ident);
+                                ret = Some(ThriftTestTestDoubleResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `EmptyStruct` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self {};
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -6009,41 +5999,42 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_double().await?;
+
+                                    ret = Some(ThriftTestTestDoubleResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `EmptyStruct` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self {};
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -6051,16 +6042,20 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "EmptyStruct",
-                }) + __protocol.field_stop_len()
+                    name: "ThriftTestTestDoubleResultRecv",
+                }) + match self {
+                    ThriftTestTestDoubleResultRecv::Ok(ref value) => {
+                        __protocol.double_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestUuidArgsRecv {
-            pub thing: [u8; 16],
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestInsanityArgsSend {
+            pub argument: Insanity,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestUuidArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestInsanityArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -6068,11 +6063,15 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidArgsRecv",
+                    name: "ThriftTestTestInsanityArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_uuid_field(1, *&self.thing)?;
+                __protocol.write_struct_field(
+                    1,
+                    &self.argument,
+                    ::pilota::thrift::TType::Struct,
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -6084,7 +6083,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut argument = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -6100,8 +6099,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
-                                thing = Some(__protocol.read_uuid()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                argument = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -6114,20 +6115,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(argument) = argument else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field argument is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self { argument };
                 ::std::result::Result::Ok(data)
             }
 
@@ -6142,7 +6143,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut argument = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -6157,9 +6158,15 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Uuid =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    thing = Some(__protocol.read_uuid().await?);
+                                    argument = Some(
+                                        <Insanity as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -6173,22 +6180,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(argument) = argument else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field argument is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self { argument };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -6197,21 +6204,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidArgsRecv",
-                }) + __protocol.uuid_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestInsanityArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.argument)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestInsanityResultRecv {
+        pub enum ThriftTestTestBinaryResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::AHashMap<UserId, ::pilota::AHashMap<Numberz, Insanity>>),
+            Ok(::pilota::Bytes),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestInsanityResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestBinaryResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -6219,36 +6226,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityResultRecv",
+                    name: "ThriftTestTestBinaryResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestInsanityResultRecv::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I64,
-                            ::pilota::thrift::TType::Map,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_struct(key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_map(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::Struct,
-                                    &val,
-                                    |__protocol, key| {
-                                        __protocol.write_struct(key)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                    |__protocol, val| {
-                                        __protocol.write_struct(val)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
+                    ThriftTestTestBinaryResultRecv::Ok(ref value) => {
+                        __protocol.write_bytes_field(0, (value).clone())?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -6274,51 +6256,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                            {
-                                                let map_ident = __protocol.read_map_begin()?;
-                                                let mut val = ::pilota::AHashMap::with_capacity(
-                                                    map_ident.size,
-                                                );
-                                                for _ in 0..map_ident.size {
-                                                    val.insert(
-                                                        ::pilota::thrift::Message::decode(
-                                                            __protocol,
-                                                        )?,
-                                                        ::pilota::thrift::Message::decode(
-                                                            __protocol,
-                                                        )?,
-                                                    );
-                                                }
-                                                __protocol.read_map_end()?;
-                                                val
-                                            },
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I64,
-                                    ::pilota::thrift::TType::Map,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.struct_len(key),
-                                    |__protocol, val| {
-                                        __protocol.map_len(
-                                            ::pilota::thrift::TType::I32,
-                                            ::pilota::thrift::TType::Struct,
-                                            val,
-                                            |__protocol, key| __protocol.struct_len(key),
-                                            |__protocol, val| __protocol.struct_len(val),
-                                        )
-                                    },
-                                );
-                                ret = Some(ThriftTestTestInsanityResultRecv::Ok(field_ident));
+                                let field_ident = __protocol.read_bytes()?;
+                                __protocol.bytes_len(&field_ident);
+                                ret = Some(ThriftTestTestBinaryResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -6367,26 +6307,9 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(<UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?, {
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                        }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
+                                    let field_ident = __protocol.read_bytes().await?;
 
-                                    ret = Some(ThriftTestTestInsanityResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestBinaryResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -6416,33 +6339,30 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityResultRecv",
+                    name: "ThriftTestTestBinaryResultRecv",
                 }) + match self {
-                    ThriftTestTestInsanityResultRecv::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I64,
-                        ::pilota::thrift::TType::Map,
-                        value,
-                        |__protocol, key| __protocol.struct_len(key),
-                        |__protocol, val| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::Struct,
-                                val,
-                                |__protocol, key| __protocol.struct_len(key),
-                                |__protocol, val| __protocol.struct_len(val),
-                            )
-                        },
-                    ),
+                    ThriftTestTestBinaryResultRecv::Ok(ref value) => {
+                        __protocol.bytes_field_len(Some(0), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct NestedListsI32x2 {
-            pub integerlist: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<i32>>>,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMultiArgsSend {
+            pub arg0: i8,
+
+            pub arg1: i32,
+
+            pub arg2: i64,
+
+            pub arg3: ::pilota::AHashMap<i16, ::pilota::FastStr>,
+
+            pub arg4: Numberz,
+
+            pub arg5: UserId,
         }
-        impl ::pilota::thrift::Message for NestedListsI32x2 {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -6450,28 +6370,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsI32x2",
+                    name: "ThriftTestTestMultiArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.integerlist.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::List,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_list(
-                                ::pilota::thrift::TType::I32,
-                                &val,
-                                |__protocol, val| {
-                                    __protocol.write_i32(*val)?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+                __protocol.write_i8_field(1, *&self.arg0)?;
+                __protocol.write_i32_field(2, *&self.arg1)?;
+                __protocol.write_i64_field(3, *&self.arg2)?;
+                __protocol.write_map_field(
+                    4,
+                    ::pilota::thrift::TType::I16,
+                    ::pilota::thrift::TType::Binary,
+                    &&self.arg3,
+                    |__protocol, key| {
+                        __protocol.write_i16(*key)?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_faststr((val).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                __protocol.write_i32_field(5, (&self.arg4).inner())?;
+                __protocol.write_struct_field(6, &self.arg5, ::pilota::thrift::TType::I64)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -6483,7 +6404,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut integerlist = None;
+                let mut arg0 = None;
+                let mut arg1 = None;
+                let mut arg2 = None;
+                let mut arg3 = None;
+                let mut arg4 = None;
+                let mut arg5 = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -6499,31 +6425,35 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                integerlist = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::std::vec::Vec<i32>> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                            let list_ident = __protocol.read_list_begin()?;
-                                            let mut val: Vec<i32> =
-                                                Vec::with_capacity(list_ident.size);
-                                            for i in 0..list_ident.size {
-                                                val.as_mut_ptr()
-                                                    .offset(i as isize)
-                                                    .write(__protocol.read_i32()?);
-                                            }
-                                            val.set_len(list_ident.size);
-                                            __protocol.read_list_end()?;
-                                            val
-                                        });
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                arg0 = Some(__protocol.read_i8()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                arg1 = Some(__protocol.read_i32()?);
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                arg2 = Some(__protocol.read_i64()?);
+                            }
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                arg3 = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_i16()?,
+                                            __protocol.read_faststr()?,
+                                        );
                                     }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
+                                    __protocol.read_map_end()?;
                                     val
                                 });
                             }
+                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                arg4 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(6) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                arg5 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -6535,18 +6465,59 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `NestedListsI32x2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { integerlist };
-                ::std::result::Result::Ok(data)
-            }
+                let Some(arg0) = arg0 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg0 is required".to_string(),
+                    ));
+                };
+                let Some(arg1) = arg1 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg1 is required".to_string(),
+                    ));
+                };
+                let Some(arg2) = arg2 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg2 is required".to_string(),
+                    ));
+                };
+                let Some(arg3) = arg3 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg3 is required".to_string(),
+                    ));
+                };
+                let Some(arg4) = arg4 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg4 is required".to_string(),
+                    ));
+                };
+                let Some(arg5) = arg5 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg5 is required".to_string(),
+                    ));
+                };
+
+                let data = Self {
+                    arg0,
+                    arg1,
+                    arg2,
+                    arg3,
+                    arg4,
+                    arg5,
+                };
+                ::std::result::Result::Ok(data)
+            }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
                 __protocol: &'a mut T,
@@ -6559,7 +6530,12 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut integerlist = None;
+                    let mut arg0 = None;
+                    let mut arg1 = None;
+                    let mut arg2 = None;
+                    let mut arg3 = None;
+                    let mut arg4 = None;
+                    let mut arg5 = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -6574,27 +6550,57 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
                                 {
-                                    integerlist = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push({
-                                                let list_ident =
-                                                    __protocol.read_list_begin().await?;
-                                                let mut val = Vec::with_capacity(list_ident.size);
-                                                for _ in 0..list_ident.size {
-                                                    val.push(__protocol.read_i32().await?);
-                                                }
-                                                __protocol.read_list_end().await?;
-                                                val
-                                            });
+                                    arg0 = Some(__protocol.read_i8().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    arg1 = Some(__protocol.read_i32().await?);
+                                }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    arg2 = Some(__protocol.read_i64().await?);
+                                }
+                                Some(4)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                {
+                                    arg3 = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i16().await?,
+                                                __protocol.read_faststr().await?,
+                                            );
                                         }
-                                        __protocol.read_list_end().await?;
+                                        __protocol.read_map_end().await?;
                                         val
                                     });
                                 }
+                                Some(5)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    arg4 = Some(
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                Some(6)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    arg5 = Some(
+                                        <UserId as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -6607,16 +6613,69 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `NestedListsI32x2` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { integerlist };
+                    let Some(arg0) = arg0 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg0 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg1) = arg1 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg1 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg2) = arg2 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg2 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg3) = arg3 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg3 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg4) = arg4 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg4 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg5) = arg5 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg5 is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self {
+                        arg0,
+                        arg1,
+                        arg2,
+                        arg3,
+                        arg4,
+                        arg5,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -6625,41 +6684,47 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsI32x2",
-                }) + self.integerlist.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::List,
-                        value,
-                        |__protocol, el| {
-                            __protocol.list_len(
-                                ::pilota::thrift::TType::I32,
-                                el,
-                                |__protocol, el| __protocol.i32_len(*el),
-                            )
-                        },
+                    name: "ThriftTestTestMultiArgsSend",
+                }) + __protocol.i8_field_len(Some(1), *&self.arg0)
+                    + __protocol.i32_field_len(Some(2), *&self.arg1)
+                    + __protocol.i64_field_len(Some(3), *&self.arg2)
+                    + __protocol.map_field_len(
+                        Some(4),
+                        ::pilota::thrift::TType::I16,
+                        ::pilota::thrift::TType::Binary,
+                        &self.arg3,
+                        |__protocol, key| __protocol.i16_len(*key),
+                        |__protocol, val| __protocol.faststr_len(val),
                     )
-                }) + __protocol.field_stop_len()
+                    + __protocol.i32_field_len(Some(5), (&self.arg4).inner())
+                    + __protocol.struct_field_len(Some(6), &self.arg5)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestI32ArgsRecv {
-            pub thing: i32,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestUuidResultRecv {
+            #[derivative(Default)]
+            Ok([u8; 16]),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestI32ArgsRecv {
+
+        impl ::pilota::thrift::Message for ThriftTestTestUuidResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.thing)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestUuidResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestUuidResultRecv::Ok(ref value) => {
+                        __protocol.write_uuid_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -6670,52 +6735,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                thing = Some(__protocol.read_i32()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_uuid()?;
+                                __protocol.uuid_len(*&field_ident);
+                                ret = Some(ThriftTestTestUuidResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -6729,54 +6788,42 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    thing = Some(__protocol.read_i32().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_uuid().await?;
+
+                                    ret = Some(ThriftTestTestUuidResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -6784,21 +6831,81 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ArgsRecv",
-                }) + __protocol.i32_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestUuidResultRecv",
+                }) + match self {
+                    ThriftTestTestUuidResultRecv::Ok(ref value) => {
+                        __protocol.uuid_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct UserId(pub i64);
+
+        impl ::std::ops::Deref for UserId {
+            type Target = i64;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl From<i64> for UserId {
+            fn from(v: i64) -> Self {
+                Self(v)
+            }
+        }
+
+        impl ::pilota::thrift::Message for UserId {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i64(*(&**self))?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                ::std::result::Result::Ok(UserId(__protocol.read_i64()?))
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    ::std::result::Result::Ok(UserId(__protocol.read_i64().await?))
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.i64_len(*&**self)
+            }
+        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestListResultRecv {
+        pub enum ThriftTestTestStructResultRecv {
             #[derivative(Default)]
-            Ok(::std::vec::Vec<i32>),
+            Ok(Xtruct),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestListResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestStructResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -6806,19 +6913,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListResultRecv",
+                    name: "ThriftTestTestStructResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestListResultRecv::Ok(ref value) => {
-                        __protocol.write_list_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
+                    ThriftTestTestStructResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -6844,24 +6943,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                };
-                                __protocol.list_len(
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, el| __protocol.i32_len(*el),
-                                );
-                                ret = Some(ThriftTestTestListResultRecv::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestStructResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -6910,17 +6994,13 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = {
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    };
+                                    let field_ident =
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestListResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestStructResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -6950,33 +7030,37 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListResultRecv",
+                    name: "ThriftTestTestStructResultRecv",
                 }) + match self {
-                    ThriftTestTestListResultRecv::Ok(ref value) => __protocol.list_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, el| __protocol.i32_len(*el),
-                    ),
+                    ThriftTestTestStructResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestVoidArgsRecv {}
-        impl ::pilota::thrift::Message for ThriftTestTestVoidArgsRecv {
+        pub struct Bools {
+            pub im_true: ::std::option::Option<bool>,
+
+            pub im_false: ::std::option::Option<bool>,
+        }
+        impl ::pilota::thrift::Message for Bools {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidArgsRecv",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Bools" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-
+                if let Some(value) = self.im_true.as_ref() {
+                    __protocol.write_bool_field(1, *value)?;
+                }
+                if let Some(value) = self.im_false.as_ref() {
+                    __protocol.write_bool_field(2, *value)?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -6988,6 +7072,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
+                let mut im_true = None;
+                let mut im_false = None;
+
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
@@ -7002,6 +7089,12 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
+                                im_true = Some(__protocol.read_bool()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
+                                im_false = Some(__protocol.read_bool()?);
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -7013,13 +7106,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `Bools` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {};
+                let data = Self { im_true, im_false };
                 ::std::result::Result::Ok(data)
             }
 
@@ -7034,6 +7130,9 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
+                    let mut im_true = None;
+                    let mut im_false = None;
+
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
@@ -7046,6 +7145,16 @@ pub mod apache {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                {
+                                    im_true = Some(__protocol.read_bool().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                {
+                                    im_false = Some(__protocol.read_bool().await?);
+                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -7058,13 +7167,16 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `Bools` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {};
+                    let data = Self { im_true, im_false };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -7072,21 +7184,32 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidArgsRecv",
-                }) + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Bools" })
+                    + self
+                        .im_true
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bool_field_len(Some(1), *value))
+                    + self
+                        .im_false
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bool_field_len(Some(2), *value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestNestResultRecv {
+        pub enum ThriftTestTestMultiExceptionResultRecv {
             #[derivative(Default)]
-            Ok(Xtruct2),
+            Ok(Xtruct),
+
+            Err1(Xception),
+
+            Err2(Xception2),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestNestResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -7094,12 +7217,18 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestResultRecv",
+                    name: "ThriftTestTestMultiExceptionResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestNestResultRecv::Ok(ref value) => {
+                    ThriftTestTestMultiExceptionResultRecv::Ok(ref value) => {
                         __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
+                    ThriftTestTestMultiExceptionResultRecv::Err1(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    ThriftTestTestMultiExceptionResultRecv::Err2(ref value) => {
+                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -7126,7 +7255,37 @@ pub mod apache {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestNestResultRecv::Ok(field_ident));
+                                ret = Some(ThriftTestTestMultiExceptionResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionResultRecv::Err1(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(2) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionResultRecv::Err2(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -7176,12 +7335,50 @@ pub mod apache {
                             Some(0) => {
                                 if ret.is_none() {
                                     let field_ident =
-                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
                                         .await?;
 
-                                    ret = Some(ThriftTestTestNestResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Ok(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Err1(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(2) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Err2(
+                                        field_ident,
+                                    ));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -7211,92 +7408,53 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestResultRecv",
+                    name: "ThriftTestTestMultiExceptionResultRecv",
                 }) + match self {
-                    ThriftTestTestNestResultRecv::Ok(ref value) => {
+                    ThriftTestTestMultiExceptionResultRecv::Ok(ref value) => {
                         __protocol.struct_field_len(Some(0), value)
                     }
+                    ThriftTestTestMultiExceptionResultRecv::Err1(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                    ThriftTestTestMultiExceptionResultRecv::Err2(ref value) => {
+                        __protocol.struct_field_len(Some(2), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct UserId(pub i64);
-
-        impl ::std::ops::Deref for UserId {
-            type Target = i64;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-
-        impl From<i64> for UserId {
-            fn from(v: i64) -> Self {
-                Self(v)
-            }
-        }
-
-        impl ::pilota::thrift::Message for UserId {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i64(*(&**self))?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                ::std::result::Result::Ok(UserId(__protocol.read_i64()?))
-            }
+        pub struct Xtruct3 {
+            pub string_thing: ::std::option::Option<::pilota::FastStr>,
 
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    ::std::result::Result::Ok(UserId(__protocol.read_i64().await?))
-                })
-            }
+            pub changed: ::std::option::Option<i32>,
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i64_len(*&**self)
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct StructB {
-            pub aa: ::std::option::Option<StructA>,
+            pub i32_thing: ::std::option::Option<i32>,
 
-            pub ab: StructA,
+            pub i64_thing: ::std::option::Option<i64>,
         }
-        impl ::pilota::thrift::Message for StructB {
+        impl ::pilota::thrift::Message for Xtruct3 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "StructB" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct3" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.aa.as_ref() {
-                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                if let Some(value) = self.string_thing.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
+                if let Some(value) = self.changed.as_ref() {
+                    __protocol.write_i32_field(4, *value)?;
+                }
+                if let Some(value) = self.i32_thing.as_ref() {
+                    __protocol.write_i32_field(9, *value)?;
+                }
+                if let Some(value) = self.i64_thing.as_ref() {
+                    __protocol.write_i64_field(11, *value)?;
                 }
-                __protocol.write_struct_field(2, &self.ab, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -7308,8 +7466,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut aa = None;
-                let mut ab = None;
+                let mut string_thing = None;
+                let mut changed = None;
+                let mut i32_thing = None;
+                let mut i64_thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -7326,14 +7486,18 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                aa = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                string_thing = Some(__protocol.read_faststr()?);
                             }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                ab = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                changed = Some(__protocol.read_i32()?);
+                            }
+                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                i32_thing = Some(__protocol.read_i32()?);
+                            }
+                            Some(11) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                i64_thing = Some(__protocol.read_i64()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -7347,7 +7511,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `StructB` field(#{}) failed, caused by: ",
+                            "decode struct `Xtruct3` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -7355,14 +7519,12 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(ab) = ab else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field ab is required".to_string(),
-                    ));
+                let data = Self {
+                    string_thing,
+                    changed,
+                    i32_thing,
+                    i64_thing,
                 };
-
-                let data = Self { aa, ab };
                 ::std::result::Result::Ok(data)
             }
 
@@ -7377,8 +7539,10 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut aa = None;
-                    let mut ab = None;
+                    let mut string_thing = None;
+                    let mut changed = None;
+                    let mut i32_thing = None;
+                    let mut i64_thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -7394,25 +7558,24 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    aa = Some(
-                                        <StructA as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    string_thing = Some(__protocol.read_faststr().await?);
                                 }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                Some(4)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    ab = Some(
-                                        <StructA as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    changed = Some(__protocol.read_i32().await?);
+                                }
+                                Some(9)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    i32_thing = Some(__protocol.read_i32().await?);
+                                }
+                                Some(11)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    i64_thing = Some(__protocol.read_i64().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -7427,7 +7590,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `StructB` field(#{}) failed, caused by: ",
+                                "decode struct `Xtruct3` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -7435,16 +7598,12 @@ pub mod apache {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(ab) = ab else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field ab is required".to_string(),
-                            ),
-                        );
+                    let data = Self {
+                        string_thing,
+                        changed,
+                        i32_thing,
+                        i64_thing,
                     };
-
-                    let data = Self { aa, ab };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -7453,25 +7612,36 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "StructB" })
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct3" })
                     + self
-                        .aa
+                        .string_thing
                         .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
-                    + __protocol.struct_field_len(Some(2), &self.ab)
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + self
+                        .changed
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(4), *value))
+                    + self
+                        .i32_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(9), *value))
+                    + self
+                        .i64_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i64_field_len(Some(11), *value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestDoubleResultRecv {
+        pub enum ThriftTestTestNestResultRecv {
             #[derivative(Default)]
-            Ok(f64),
+            Ok(Xtruct2),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestDoubleResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestNestResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -7479,11 +7649,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleResultRecv",
+                    name: "ThriftTestTestNestResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestDoubleResultRecv::Ok(ref value) => {
-                        __protocol.write_double_field(0, *value)?;
+                    ThriftTestTestNestResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -7509,9 +7679,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_double()?;
-                                __protocol.double_len(*&field_ident);
-                                ret = Some(ThriftTestTestDoubleResultRecv::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestNestResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -7560,9 +7730,13 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_double().await?;
+                                    let field_ident =
+                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestDoubleResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestNestResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -7592,24 +7766,32 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleResultRecv",
+                    name: "ThriftTestTestNestResultRecv",
                 }) + match self {
-                    ThriftTestTestDoubleResultRecv::Ok(ref value) => {
-                        __protocol.double_field_len(Some(0), *value)
+                    ThriftTestTestNestResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestBoolResultRecv {
+        pub enum SomeUnion {
             #[derivative(Default)]
-            Ok(bool),
+            MapThing(::pilota::AHashMap<Numberz, UserId>),
+
+            StringThing(::pilota::FastStr),
+
+            I32Thing(i32),
+
+            XtructThing(Xtruct3),
+
+            InsanityThing(Insanity),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestBoolResultRecv {
+        impl ::pilota::thrift::Message for SomeUnion {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -7617,11 +7799,36 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolResultRecv",
+                    name: "SomeUnion",
                 })?;
                 match self {
-                    ThriftTestTestBoolResultRecv::Ok(ref value) => {
-                        __protocol.write_bool_field(0, *value)?;
+                    SomeUnion::MapThing(ref value) => {
+                        __protocol.write_map_field(
+                            1,
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I64,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_struct(key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_struct(val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
+                    SomeUnion::StringThing(ref value) => {
+                        __protocol.write_faststr_field(2, (value).clone())?;
+                    }
+                    SomeUnion::I32Thing(ref value) => {
+                        __protocol.write_i32_field(3, *value)?;
+                    }
+                    SomeUnion::XtructThing(ref value) => {
+                        __protocol.write_struct_field(4, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    SomeUnion::InsanityThing(ref value) => {
+                        __protocol.write_struct_field(5, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -7645,11 +7852,84 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
+                        Some(1) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_bool()?;
-                                __protocol.bool_len(*&field_ident);
-                                ret = Some(ThriftTestTestBoolResultRecv::Ok(field_ident));
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::I64,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.struct_len(key),
+                                    |__protocol, val| __protocol.struct_len(val),
+                                );
+                                ret = Some(SomeUnion::MapThing(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(2) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_faststr()?;
+                                __protocol.faststr_len(&field_ident);
+                                ret = Some(SomeUnion::StringThing(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(3) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_i32()?;
+                                __protocol.i32_len(*&field_ident);
+                                ret = Some(SomeUnion::I32Thing(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(4) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(SomeUnion::XtructThing(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(5) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(SomeUnion::InsanityThing(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -7696,11 +7976,20 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
+                            Some(1) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_bool().await?;
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
 
-                                    ret = Some(ThriftTestTestBoolResultRecv::Ok(field_ident));
+                                    ret = Some(SomeUnion::MapThing(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -7708,15 +7997,71 @@ pub mod apache {
                                         ));
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
+                            Some(2) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_faststr().await?;
+
+                                    ret = Some(SomeUnion::StringThing(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(3) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_i32().await?;
+
+                                    ret = Some(SomeUnion::I32Thing(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(4) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xtruct3 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(SomeUnion::XtructThing(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(5) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Insanity as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(SomeUnion::InsanityThing(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
                     } else {
                         ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -7729,58 +8074,67 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolResultRecv",
-                }) + match self {
-                    ThriftTestTestBoolResultRecv::Ok(ref value) => {
-                        __protocol.bool_field_len(Some(0), *value)
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SomeUnion" })
+                    + match self {
+                        SomeUnion::MapThing(ref value) => __protocol.map_field_len(
+                            Some(1),
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I64,
+                            value,
+                            |__protocol, key| __protocol.struct_len(key),
+                            |__protocol, val| __protocol.struct_len(val),
+                        ),
+                        SomeUnion::StringThing(ref value) => {
+                            __protocol.faststr_field_len(Some(2), value)
+                        }
+                        SomeUnion::I32Thing(ref value) => __protocol.i32_field_len(Some(3), *value),
+                        SomeUnion::XtructThing(ref value) => {
+                            __protocol.struct_field_len(Some(4), value)
+                        }
+                        SomeUnion::InsanityThing(ref value) => {
+                            __protocol.struct_field_len(Some(5), value)
+                        }
                     }
-                } + __protocol.field_stop_len()
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct Insanity {
-            pub user_map: ::std::option::Option<::pilota::AHashMap<Numberz, UserId>>,
-
-            pub xtructs: ::std::option::Option<::std::vec::Vec<Xtruct>>,
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMapResultRecv {
+            #[derivative(Default)]
+            Ok(::pilota::AHashMap<i32, i32>),
         }
-        impl ::pilota::thrift::Message for Insanity {
+
+        impl ::pilota::thrift::Message for ThriftTestTestMapResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Insanity" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.user_map.as_ref() {
-                    __protocol.write_map_field(
-                        1,
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::I64,
-                        &value,
-                        |__protocol, key| {
-                            __protocol.write_struct(key)?;
-                            ::std::result::Result::Ok(())
-                        },
-                        |__protocol, val| {
-                            __protocol.write_struct(val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.xtructs.as_ref() {
-                    __protocol.write_list_field(
-                        2,
-                        ::pilota::thrift::TType::Struct,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_struct(val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestMapResultRecv::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_i32(*key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -7792,253 +8146,60 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut user_map = None;
-                let mut xtructs = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                user_map = Some({
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = {
                                     let map_ident = __protocol.read_map_begin()?;
                                     let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
                                     for _ in 0..map_ident.size {
-                                        val.insert(
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                        );
+                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
                                     }
                                     __protocol.read_map_end()?;
                                     val
-                                });
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                xtructs = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<Xtruct> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(::pilota::thrift::Message::decode(__protocol)?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.i32_len(*key),
+                                    |__protocol, val| __protocol.i32_len(*val),
+                                );
+                                ret = Some(ThriftTestTestMapResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Insanity` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self { user_map, xtructs };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut user_map = None;
-                    let mut xtructs = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                    loop {
-
-
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
-
-                    break;
-                } else {
-
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map  => {
-                    user_map = Some({
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                        }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
-
-                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    xtructs = Some({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push(<Xtruct as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
-
-
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `Insanity` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { user_map, xtructs };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Insanity" })
-                    + self.user_map.as_ref().map_or(0, |value| {
-                        __protocol.map_field_len(
-                            Some(1),
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I64,
-                            value,
-                            |__protocol, key| __protocol.struct_len(key),
-                            |__protocol, val| __protocol.struct_len(val),
-                        )
-                    })
-                    + self.xtructs.as_ref().map_or(0, |value| {
-                        __protocol.list_field_len(
-                            Some(2),
-                            ::pilota::thrift::TType::Struct,
-                            value,
-                            |__protocol, el| __protocol.struct_len(el),
-                        )
-                    })
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestTypedefResultSend {
-            #[derivative(Default)]
-            Ok(UserId),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestTypedefResultSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefResultSend",
-                })?;
-                match self {
-                    ThriftTestTestTypedefResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::I64)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestTypedefResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -8063,13 +8224,21 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident =
-                                        <UserId as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i32().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
 
-                                    ret = Some(ThriftTestTestTypedefResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestMapResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -8099,50 +8268,41 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefResultSend",
+                    name: "ThriftTestTestMapResultRecv",
                 }) + match self {
-                    ThriftTestTestTypedefResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
+                    ThriftTestTestMapResultRecv::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, key| __protocol.i32_len(*key),
+                        |__protocol, val| __protocol.i32_len(*val),
+                    ),
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStringMapResultSend {
-            #[derivative(Default)]
-            Ok(::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>),
-        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct Xception {
+            pub error_code: ::std::option::Option<i32>,
 
-        impl ::pilota::thrift::Message for ThriftTestTestStringMapResultSend {
+            pub message: ::std::option::Option<::pilota::FastStr>,
+        }
+        impl ::pilota::thrift::Message for Xception {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapResultSend",
-                })?;
-                match self {
-                    ThriftTestTestStringMapResultSend::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::Binary,
-                            ::pilota::thrift::TType::Binary,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_faststr((key).clone())?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_faststr((val).clone())?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xception" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.error_code.as_ref() {
+                    __protocol.write_i32_field(1, *value)?;
+                }
+                if let Some(value) = self.message.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -8154,63 +8314,57 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_faststr()?,
-                                            __protocol.read_faststr()?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::Binary,
-                                    ::pilota::thrift::TType::Binary,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.faststr_len(key),
-                                    |__protocol, val| __protocol.faststr_len(val),
-                                );
-                                ret = Some(ThriftTestTestStringMapResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+
+                let mut error_code = None;
+                let mut message = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                error_code = Some(__protocol.read_i32()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                message = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `Xception` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self {
+                    error_code,
+                    message,
+                };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -8224,80 +8378,85 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_faststr().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
+                    let mut error_code = None;
+                    let mut message = None;
 
-                                    ret = Some(ThriftTestTestStringMapResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    error_code = Some(__protocol.read_i32().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    message = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `Xception` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self {
+                        error_code,
+                        message,
+                    };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapResultSend",
-                }) + match self {
-                    ThriftTestTestStringMapResultSend::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::Binary,
-                        ::pilota::thrift::TType::Binary,
-                        value,
-                        |__protocol, key| __protocol.faststr_len(key),
-                        |__protocol, val| __protocol.faststr_len(val),
-                    ),
-                } + __protocol.field_stop_len()
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xception" })
+                    + self
+                        .error_code
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
+                    + self
+                        .message
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestExceptionArgsRecv {
-            pub arg: ::pilota::FastStr,
+        pub struct ThriftTestTestMultiExceptionArgsRecv {
+            pub arg0: ::pilota::FastStr,
+
+            pub arg1: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestExceptionArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -8305,11 +8464,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionArgsRecv",
+                    name: "ThriftTestTestMultiExceptionArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.arg).clone())?;
+                __protocol.write_faststr_field(1, (&self.arg0).clone())?;
+                __protocol.write_faststr_field(2, (&self.arg1).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -8321,7 +8481,8 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg = None;
+                let mut arg0 = None;
+                let mut arg1 = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -8340,7 +8501,12 @@ pub mod apache {
                             Some(1)
                                 if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                arg = Some(__protocol.read_faststr()?);
+                                arg0 = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                arg1 = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -8353,20 +8519,26 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg) = arg else {
+                let Some(arg0) = arg0 else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg is required".to_string(),
+                        "field arg0 is required".to_string(),
+                    ));
+                };
+                let Some(arg1) = arg1 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg1 is required".to_string(),
                     ));
                 };
 
-                let data = Self { arg };
+                let data = Self { arg0, arg1 };
                 ::std::result::Result::Ok(data)
             }
 
@@ -8381,7 +8553,8 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg = None;
+                    let mut arg0 = None;
+                    let mut arg1 = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -8399,13 +8572,19 @@ pub mod apache {
                                     if field_ident.field_type
                                         == ::pilota::thrift::TType::Binary =>
                                 {
-                                    arg = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                                    arg0 = Some(__protocol.read_faststr().await?);
                                 }
-                            }
-
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    arg1 = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
                             __protocol.read_field_end().await?;
                         }
                         ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
@@ -8413,22 +8592,30 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg) = arg else {
+                    let Some(arg0) = arg0 else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg is required".to_string(),
+                                "field arg0 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg1) = arg1 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg1 is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { arg };
+                    let data = Self { arg0, arg1 };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -8437,21 +8624,170 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionArgsRecv",
-                }) + __protocol.faststr_field_len(Some(1), &self.arg)
+                    name: "ThriftTestTestMultiExceptionArgsRecv",
+                }) + __protocol.faststr_field_len(Some(1), &self.arg0)
+                    + __protocol.faststr_field_len(Some(2), &self.arg1)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct OneField {
+            pub field: ::std::option::Option<EmptyStruct>,
+        }
+        impl ::pilota::thrift::Message for OneField {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "OneField" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.field.as_ref() {
+                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut field = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                field = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `OneField` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let data = Self { field };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut field = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    field = Some(
+                                        <EmptyStruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `OneField` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { field };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "OneField" })
+                    + self
+                        .field
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestUuidResultSend {
+        pub enum ThriftTestTestStringMapResultRecv {
             #[derivative(Default)]
-            Ok([u8; 16]),
+            Ok(::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestUuidResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStringMapResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -8459,11 +8795,24 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidResultSend",
+                    name: "ThriftTestTestStringMapResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestUuidResultSend::Ok(ref value) => {
-                        __protocol.write_uuid_field(0, *value)?;
+                    ThriftTestTestStringMapResultRecv::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::Binary,
+                            ::pilota::thrift::TType::Binary,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_faststr((key).clone())?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_faststr((val).clone())?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -8489,9 +8838,26 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_uuid()?;
-                                __protocol.uuid_len(*&field_ident);
-                                ret = Some(ThriftTestTestUuidResultSend::Ok(field_ident));
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_faststr()?,
+                                            __protocol.read_faststr()?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::Binary,
+                                    ::pilota::thrift::TType::Binary,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.faststr_len(key),
+                                    |__protocol, val| __protocol.faststr_len(val),
+                                );
+                                ret = Some(ThriftTestTestStringMapResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -8540,9 +8906,21 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_uuid().await?;
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_faststr().await?,
+                                                __protocol.read_faststr().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
 
-                                    ret = Some(ThriftTestTestUuidResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestStringMapResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -8572,216 +8950,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidResultSend",
+                    name: "ThriftTestTestStringMapResultRecv",
                 }) + match self {
-                    ThriftTestTestUuidResultSend::Ok(ref value) => {
-                        __protocol.uuid_field_len(Some(0), *value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ListTypeVersioningV2 {
-            pub strings: ::std::option::Option<::std::vec::Vec<::pilota::FastStr>>,
-
-            pub hello: ::std::option::Option<::pilota::FastStr>,
-        }
-        impl ::pilota::thrift::Message for ListTypeVersioningV2 {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ListTypeVersioningV2",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.strings.as_ref() {
-                    __protocol.write_list_field(
-                        1,
+                    ThriftTestTestStringMapResultRecv::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
                         ::pilota::thrift::TType::Binary,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.hello.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut strings = None;
-                let mut hello = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                strings = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::pilota::FastStr> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_faststr()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                hello = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `ListTypeVersioningV2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self { strings, hello };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut strings = None;
-                    let mut hello = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    strings = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_faststr().await?);
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    hello = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ListTypeVersioningV2` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { strings, hello };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ListTypeVersioningV2",
-                }) + self.strings.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
                         ::pilota::thrift::TType::Binary,
                         value,
-                        |__protocol, el| __protocol.faststr_len(el),
-                    )
-                }) + self
-                    .hello
-                    .as_ref()
-                    .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
-                    + __protocol.field_stop_len()
+                        |__protocol, key| __protocol.faststr_len(key),
+                        |__protocol, val| __protocol.faststr_len(val),
+                    ),
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestI32ResultSend {
+        pub enum ThriftTestTestOnewayResultSend {
             #[derivative(Default)]
-            Ok(i32),
+            Ok(()),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestI32ResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestOnewayResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -8789,12 +8980,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ResultSend",
+                    name: "ThriftTestTestOnewayResultSend",
                 })?;
                 match self {
-                    ThriftTestTestI32ResultSend::Ok(ref value) => {
-                        __protocol.write_i32_field(0, *value)?;
-                    }
+                    ThriftTestTestOnewayResultSend::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -8817,20 +9006,6 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_i32()?;
-                                __protocol.i32_len(*&field_ident);
-                                ret = Some(ThriftTestTestI32ResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -8841,10 +9016,7 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
+                    ::std::result::Result::Ok(ThriftTestTestOnewayResultSend::Ok(()))
                 }
             }
 
@@ -8868,18 +9040,6 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_i32().await?;
-
-                                    ret = Some(ThriftTestTestI32ResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -8890,10 +9050,7 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
+                        ::std::result::Result::Ok(ThriftTestTestOnewayResultSend::Ok(()))
                     }
                 })
             }
@@ -8902,11 +9059,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ResultSend",
+                    name: "ThriftTestTestOnewayResultSend",
                 }) + match self {
-                    ThriftTestTestI32ResultSend::Ok(ref value) => {
-                        __protocol.i32_field_len(Some(0), *value)
-                    }
+                    ThriftTestTestOnewayResultSend::Ok(ref value) => 0,
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -9013,11 +9168,11 @@ pub mod apache {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestInsanityArgsSend {
-            pub argument: Insanity,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestOnewayArgsRecv {
+            pub seconds_to_sleep: i32,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestInsanityArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestOnewayArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -9025,15 +9180,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityArgsSend",
+                    name: "ThriftTestTestOnewayArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(
-                    1,
-                    &self.argument,
-                    ::pilota::thrift::TType::Struct,
-                )?;
+                __protocol.write_i32_field(1, *&self.seconds_to_sleep)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -9045,7 +9196,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut argument = None;
+                let mut seconds_to_sleep = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -9061,10 +9212,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                argument = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                seconds_to_sleep = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -9077,20 +9226,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(argument) = argument else {
+                let Some(seconds_to_sleep) = seconds_to_sleep else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field argument is required".to_string(),
+                        "field seconds_to_sleep is required".to_string(),
                     ));
                 };
 
-                let data = Self { argument };
+                let data = Self { seconds_to_sleep };
                 ::std::result::Result::Ok(data)
             }
 
@@ -9105,7 +9254,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut argument = None;
+                    let mut seconds_to_sleep = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -9120,15 +9269,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    argument = Some(
-                                        <Insanity as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    seconds_to_sleep = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -9142,22 +9285,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(argument) = argument else {
+                    let Some(seconds_to_sleep) = seconds_to_sleep else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field argument is required".to_string(),
+                                "field seconds_to_sleep is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { argument };
+                    let data = Self { seconds_to_sleep };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -9166,18 +9309,15 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.argument)
+                    name: "ThriftTestTestOnewayArgsRecv",
+                }) + __protocol.i32_field_len(Some(1), *&self.seconds_to_sleep)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct NestedListsBonk {
-            pub bonk:
-                ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::vec::Vec<Bonk>>>>,
-        }
-        impl ::pilota::thrift::Message for NestedListsBonk {
+        pub struct ThriftTestTestVoidArgsRecv {}
+        impl ::pilota::thrift::Message for ThriftTestTestVoidArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -9185,35 +9325,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsBonk",
+                    name: "ThriftTestTestVoidArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.bonk.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::List,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_list(
-                                ::pilota::thrift::TType::List,
-                                &val,
-                                |__protocol, val| {
-                                    __protocol.write_list(
-                                        ::pilota::thrift::TType::Struct,
-                                        &val,
-                                        |__protocol, val| {
-                                            __protocol.write_struct(val)?;
-                                            ::std::result::Result::Ok(())
-                                        },
-                                    )?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -9225,8 +9341,6 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut bonk = None;
-
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
@@ -9241,44 +9355,6 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                bonk = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::std::vec::Vec<::std::vec::Vec<Bonk>>> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                            let list_ident = __protocol.read_list_begin()?;
-                                            let mut val: Vec<::std::vec::Vec<Bonk>> =
-                                                Vec::with_capacity(list_ident.size);
-                                            for i in 0..list_ident.size {
-                                                val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                                    let list_ident =
-                                                        __protocol.read_list_begin()?;
-                                                    let mut val: Vec<Bonk> =
-                                                        Vec::with_capacity(list_ident.size);
-                                                    for i in 0..list_ident.size {
-                                                        val.as_mut_ptr().offset(i as isize).write(
-                                                            ::pilota::thrift::Message::decode(
-                                                                __protocol,
-                                                            )?,
-                                                        );
-                                                    }
-                                                    val.set_len(list_ident.size);
-                                                    __protocol.read_list_end()?;
-                                                    val
-                                                });
-                                            }
-                                            val.set_len(list_ident.size);
-                                            __protocol.read_list_end()?;
-                                            val
-                                        });
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -9290,16 +9366,13 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `NestedListsBonk` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { bonk };
+                let data = Self {};
                 ::std::result::Result::Ok(data)
             }
 
@@ -9314,72 +9387,37 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut bonk = None;
-
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                    loop {
-
-
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
-
-                    break;
-                } else {
-
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    bonk = Some({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push(<Bonk as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
-
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
 
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `NestedListsBonk` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { bonk };
+                    let data = Self {};
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -9388,55 +9426,42 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsBonk",
-                }) + self.bonk.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::List,
-                        value,
-                        |__protocol, el| {
-                            __protocol.list_len(
-                                ::pilota::thrift::TType::List,
-                                el,
-                                |__protocol, el| {
-                                    __protocol.list_len(
-                                        ::pilota::thrift::TType::Struct,
-                                        el,
-                                        |__protocol, el| __protocol.struct_len(el),
-                                    )
-                                },
-                            )
-                        },
-                    )
+                    name: "ThriftTestTestVoidArgsRecv",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestListArgsSend {
-            pub thing: ::std::vec::Vec<i32>,
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestSetResultRecv {
+            #[derivative(Default)]
+            Ok(::pilota::AHashSet<i32>),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestListArgsSend {
+
+        impl ::pilota::thrift::Message for ThriftTestTestSetResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_list_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestSetResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestSetResultRecv::Ok(ref value) => {
+                        __protocol.write_set_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -9447,63 +9472,59 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                thing = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = {
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_i32()?);
                                     }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
+                                    __protocol.read_set_end()?;
                                     val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                };
+                                __protocol.set_len(
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, el| __protocol.i32_len(*el),
+                                );
+                                ret = Some(ThriftTestTestSetResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -9517,62 +9538,51 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    thing = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
                                         for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_i32().await?);
+                                            val.insert(__protocol.read_i32().await?);
                                         }
-                                        __protocol.read_list_end().await?;
+                                        __protocol.read_set_end().await?;
                                         val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                                    };
+
+                                    ret = Some(ThriftTestTestSetResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -9580,25 +9590,27 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListArgsSend",
-                }) + __protocol.list_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, el| __protocol.i32_len(*el),
-                ) + __protocol.field_stop_len()
+                    name: "ThriftTestTestSetResultRecv",
+                }) + match self {
+                    ThriftTestTestSetResultRecv::Ok(ref value) => __protocol.set_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, el| __protocol.i32_len(*el),
+                    ),
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestOnewayResultRecv {
+        pub enum ThriftTestTestStringResultSend {
             #[derivative(Default)]
-            Ok(()),
+            Ok(::pilota::FastStr),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestOnewayResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestStringResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -9606,10 +9618,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayResultRecv",
+                    name: "ThriftTestTestStringResultSend",
                 })?;
                 match self {
-                    ThriftTestTestOnewayResultRecv::Ok(ref value) => {}
+                    ThriftTestTestStringResultSend::Ok(ref value) => {
+                        __protocol.write_faststr_field(0, (value).clone())?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -9632,6 +9646,20 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_faststr()?;
+                                __protocol.faststr_len(&field_ident);
+                                ret = Some(ThriftTestTestStringResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -9642,7 +9670,10 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Ok(ThriftTestTestOnewayResultRecv::Ok(()))
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
                 }
             }
 
@@ -9666,6 +9697,18 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_faststr().await?;
+
+                                    ret = Some(ThriftTestTestStringResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -9676,27 +9719,32 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Ok(ThriftTestTestOnewayResultRecv::Ok(()))
-                    }
-                })
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayResultRecv",
+                    name: "ThriftTestTestStringResultSend",
                 }) + match self {
-                    ThriftTestTestOnewayResultRecv::Ok(ref value) => 0,
+                    ThriftTestTestStringResultSend::Ok(ref value) => {
+                        __protocol.faststr_field_len(Some(0), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestNestArgsSend {
-            pub thing: Xtruct2,
+        pub struct SecondServiceSecondtestStringArgsSend {
+            pub thing: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestNestArgsSend {
+        impl ::pilota::thrift::Message for SecondServiceSecondtestStringArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -9704,11 +9752,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestArgsSend",
+                    name: "SecondServiceSecondtestStringArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_faststr_field(1, (&self.thing).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -9737,9 +9785,9 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                thing = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -9752,7 +9800,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestNestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -9796,14 +9844,9 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    thing = Some(
-                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    thing = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -9817,7 +9860,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestNestArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -9841,27 +9884,17 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.thing)
+                    name: "SecondServiceSecondtestStringArgsSend",
+                }) + __protocol.faststr_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMultiArgsRecv {
-            pub arg0: i8,
-
-            pub arg1: i32,
-
-            pub arg2: i64,
-
-            pub arg3: ::pilota::AHashMap<i16, ::pilota::FastStr>,
-
-            pub arg4: Numberz,
-
-            pub arg5: UserId,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestStringArgsRecv {
+            pub thing: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMultiArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestStringArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -9869,29 +9902,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiArgsRecv",
+                    name: "ThriftTestTestStringArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i8_field(1, *&self.arg0)?;
-                __protocol.write_i32_field(2, *&self.arg1)?;
-                __protocol.write_i64_field(3, *&self.arg2)?;
-                __protocol.write_map_field(
-                    4,
-                    ::pilota::thrift::TType::I16,
-                    ::pilota::thrift::TType::Binary,
-                    &&self.arg3,
-                    |__protocol, key| {
-                        __protocol.write_i16(*key)?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_faststr((val).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                __protocol.write_i32_field(5, (&self.arg4).inner())?;
-                __protocol.write_struct_field(6, &self.arg5, ::pilota::thrift::TType::I64)?;
+                __protocol.write_faststr_field(1, (&self.thing).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -9903,12 +9918,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg0 = None;
-                let mut arg1 = None;
-                let mut arg2 = None;
-                let mut arg3 = None;
-                let mut arg4 = None;
-                let mut arg5 = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -9924,34 +9934,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                arg0 = Some(__protocol.read_i8()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                arg1 = Some(__protocol.read_i32()?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                arg2 = Some(__protocol.read_i64()?);
-                            }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                arg3 = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_i16()?,
-                                            __protocol.read_faststr()?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
-                            }
-                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                arg4 = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(6) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                arg5 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                thing = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -9964,57 +9950,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg0) = arg0 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg0 is required".to_string(),
-                    ));
-                };
-                let Some(arg1) = arg1 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg1 is required".to_string(),
-                    ));
-                };
-                let Some(arg2) = arg2 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg2 is required".to_string(),
-                    ));
-                };
-                let Some(arg3) = arg3 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg3 is required".to_string(),
-                    ));
-                };
-                let Some(arg4) = arg4 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg4 is required".to_string(),
-                    ));
-                };
-                let Some(arg5) = arg5 else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg5 is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self {
-                    arg0,
-                    arg1,
-                    arg2,
-                    arg3,
-                    arg4,
-                    arg5,
-                };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -10029,12 +9978,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg0 = None;
-                    let mut arg1 = None;
-                    let mut arg2 = None;
-                    let mut arg3 = None;
-                    let mut arg4 = None;
-                    let mut arg5 = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -10049,56 +9993,10 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    arg0 = Some(__protocol.read_i8().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    arg1 = Some(__protocol.read_i32().await?);
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    arg2 = Some(__protocol.read_i64().await?);
-                                }
-                                Some(4)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
-                                {
-                                    arg3 = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i16().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(5)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    arg4 = Some(
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                Some(6)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    arg5 = Some(
-                                        <UserId as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    thing = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -10112,69 +10010,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg0) = arg0 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg0 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg1) = arg1 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg1 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg2) = arg2 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg2 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg3) = arg3 else {
+                    let Some(thing) = thing else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg3 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg4) = arg4 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg4 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg5) = arg5 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg5 is required".to_string(),
+                                "field thing is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self {
-                        arg0,
-                        arg1,
-                        arg2,
-                        arg3,
-                        arg4,
-                        arg5,
-                    };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -10183,55 +10034,212 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiArgsRecv",
-                }) + __protocol.i8_field_len(Some(1), *&self.arg0)
-                    + __protocol.i32_field_len(Some(2), *&self.arg1)
-                    + __protocol.i64_field_len(Some(3), *&self.arg2)
-                    + __protocol.map_field_len(
-                        Some(4),
-                        ::pilota::thrift::TType::I16,
-                        ::pilota::thrift::TType::Binary,
-                        &self.arg3,
-                        |__protocol, key| __protocol.i16_len(*key),
-                        |__protocol, val| __protocol.faststr_len(val),
-                    )
-                    + __protocol.i32_field_len(Some(5), (&self.arg4).inner())
-                    + __protocol.struct_field_len(Some(6), &self.arg5)
+                    name: "ThriftTestTestStringArgsRecv",
+                }) + __protocol.faststr_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Xtruct {
-            pub string_thing: ::std::option::Option<::pilota::FastStr>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestListResultRecv {
+            #[derivative(Default)]
+            Ok(::std::vec::Vec<i32>),
+        }
 
-            pub byte_thing: ::std::option::Option<i8>,
+        impl ::pilota::thrift::Message for ThriftTestTestListResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestListResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestListResultRecv::Ok(ref value) => {
+                        __protocol.write_list_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
 
-            pub i32_thing: ::std::option::Option<i32>,
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_i32()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                };
+                                __protocol.list_len(
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, el| __protocol.i32_len(*el),
+                                );
+                                ret = Some(ThriftTestTestListResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
 
-            pub i64_thing: ::std::option::Option<i64>,
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    };
+
+                                    ret = Some(ThriftTestTestListResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestListResultRecv",
+                }) + match self {
+                    ThriftTestTestListResultRecv::Ok(ref value) => __protocol.list_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, el| __protocol.i32_len(*el),
+                    ),
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
         }
-        impl ::pilota::thrift::Message for Xtruct {
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct VersioningTestV1 {
+            pub begin_in_both: ::std::option::Option<i32>,
+
+            pub old_string: ::std::option::Option<::pilota::FastStr>,
+
+            pub end_in_both: ::std::option::Option<i32>,
+        }
+        impl ::pilota::thrift::Message for VersioningTestV1 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "VersioningTestV1",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.string_thing.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                if let Some(value) = self.byte_thing.as_ref() {
-                    __protocol.write_i8_field(4, *value)?;
+                if let Some(value) = self.begin_in_both.as_ref() {
+                    __protocol.write_i32_field(1, *value)?;
                 }
-                if let Some(value) = self.i32_thing.as_ref() {
-                    __protocol.write_i32_field(9, *value)?;
+                if let Some(value) = self.old_string.as_ref() {
+                    __protocol.write_faststr_field(3, (value).clone())?;
                 }
-                if let Some(value) = self.i64_thing.as_ref() {
-                    __protocol.write_i64_field(11, *value)?;
+                if let Some(value) = self.end_in_both.as_ref() {
+                    __protocol.write_i32_field(12, *value)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -10244,10 +10252,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut string_thing = None;
-                let mut byte_thing = None;
-                let mut i32_thing = None;
-                let mut i64_thing = None;
+                let mut begin_in_both = None;
+                let mut old_string = None;
+                let mut end_in_both = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -10263,19 +10270,16 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                begin_in_both = Some(__protocol.read_i32()?);
+                            }
+                            Some(3)
                                 if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                string_thing = Some(__protocol.read_faststr()?);
-                            }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                byte_thing = Some(__protocol.read_i8()?);
-                            }
-                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                i32_thing = Some(__protocol.read_i32()?);
+                                old_string = Some(__protocol.read_faststr()?);
                             }
-                            Some(11) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                i64_thing = Some(__protocol.read_i64()?);
+                            Some(12) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                end_in_both = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -10289,7 +10293,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `Xtruct` field(#{}) failed, caused by: ",
+                            "decode struct `VersioningTestV1` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -10298,10 +10302,9 @@ pub mod apache {
                 __protocol.read_struct_end()?;
 
                 let data = Self {
-                    string_thing,
-                    byte_thing,
-                    i32_thing,
-                    i64_thing,
+                    begin_in_both,
+                    old_string,
+                    end_in_both,
                 };
                 ::std::result::Result::Ok(data)
             }
@@ -10317,10 +10320,9 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut string_thing = None;
-                    let mut byte_thing = None;
-                    let mut i32_thing = None;
-                    let mut i64_thing = None;
+                    let mut begin_in_both = None;
+                    let mut old_string = None;
+                    let mut end_in_both = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -10335,25 +10337,20 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    string_thing = Some(__protocol.read_faststr().await?);
+                                    begin_in_both = Some(__protocol.read_i32().await?);
                                 }
-                                Some(4)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                Some(3)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    byte_thing = Some(__protocol.read_i8().await?);
+                                    old_string = Some(__protocol.read_faststr().await?);
                                 }
-                                Some(9)
+                                Some(12)
                                     if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    i32_thing = Some(__protocol.read_i32().await?);
-                                }
-                                Some(11)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    i64_thing = Some(__protocol.read_i64().await?);
+                                    end_in_both = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -10368,7 +10365,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `Xtruct` field(#{}) failed, caused by: ",
+                                "decode struct `VersioningTestV1` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -10377,10 +10374,9 @@ pub mod apache {
                     __protocol.read_struct_end().await?;
 
                     let data = Self {
-                        string_thing,
-                        byte_thing,
-                        i32_thing,
-                        i64_thing,
+                        begin_in_both,
+                        old_string,
+                        end_in_both,
                     };
                     ::std::result::Result::Ok(data)
                 })
@@ -10389,44 +10385,47 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct" })
-                    + self
-                        .string_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self
-                        .byte_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i8_field_len(Some(4), *value))
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "VersioningTestV1",
+                }) + self
+                    .begin_in_both
+                    .as_ref()
+                    .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
                     + self
-                        .i32_thing
+                        .old_string
                         .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(9), *value))
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(3), value))
                     + self
-                        .i64_thing
+                        .end_in_both
                         .as_ref()
-                        .map_or(0, |value| __protocol.i64_field_len(Some(11), *value))
+                        .map_or(0, |value| __protocol.i32_field_len(Some(12), *value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestDoubleArgsSend {
-            pub thing: f64,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestBoolResultSend {
+            #[derivative(Default)]
+            Ok(bool),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestDoubleArgsSend {
+
+        impl ::pilota::thrift::Message for ThriftTestTestBoolResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_double_field(1, *&self.thing)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestBoolResultSend",
+                })?;
+                match self {
+                    ThriftTestTestBoolResultSend::Ok(ref value) => {
+                        __protocol.write_bool_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -10437,54 +10436,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
-                            {
-                                thing = Some(__protocol.read_double()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_bool()?;
+                                __protocol.bool_len(*&field_ident);
+                                ret = Some(ThriftTestTestBoolResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -10498,55 +10489,42 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Double =>
-                                {
-                                    thing = Some(__protocol.read_double().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_bool().await?;
+
+                                    ret = Some(ThriftTestTestBoolResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -10554,17 +10532,212 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleArgsSend",
-                }) + __protocol.double_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestBoolResultSend",
+                }) + match self {
+                    ThriftTestTestBoolResultSend::Ok(ref value) => {
+                        __protocol.bool_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ListTypeVersioningV2 {
+            pub strings: ::std::option::Option<::std::vec::Vec<::pilota::FastStr>>,
+
+            pub hello: ::std::option::Option<::pilota::FastStr>,
+        }
+        impl ::pilota::thrift::Message for ListTypeVersioningV2 {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ListTypeVersioningV2",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.strings.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.hello.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut strings = None;
+                let mut hello = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                strings = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::pilota::FastStr> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_faststr()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                hello = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `ListTypeVersioningV2` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let data = Self { strings, hello };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut strings = None;
+                    let mut hello = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    strings = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(__protocol.read_faststr().await?);
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    hello = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ListTypeVersioningV2` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { strings, hello };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ListTypeVersioningV2",
+                }) + self.strings.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::Binary,
+                        value,
+                        |__protocol, el| __protocol.faststr_len(el),
+                    )
+                }) + self
+                    .hello
+                    .as_ref()
+                    .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestEnumArgsRecv {
-            pub thing: Numberz,
+        pub struct ThriftTestTestBoolArgsRecv {
+            pub thing: bool,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestEnumArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestBoolArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -10572,11 +10745,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumArgsRecv",
+                    name: "ThriftTestTestBoolArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, (&self.thing).inner())?;
+                __protocol.write_bool_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -10604,8 +10777,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
+                                thing = Some(__protocol.read_bool()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -10618,7 +10791,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -10661,14 +10834,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
                                 {
-                                    thing = Some(
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    thing = Some(__protocol.read_bool().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -10682,7 +10850,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -10706,8 +10874,8 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumArgsRecv",
-                }) + __protocol.i32_field_len(Some(1), (&self.thing).inner())
+                    name: "ThriftTestTestBoolArgsRecv",
+                }) + __protocol.bool_field_len(Some(1), *&self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -10715,12 +10883,12 @@ pub mod apache {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum SecondServiceSecondtestStringResultRecv {
+        pub enum ThriftTestTestEnumResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::FastStr),
+            Ok(Numberz),
         }
 
-        impl ::pilota::thrift::Message for SecondServiceSecondtestStringResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestEnumResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -10728,11 +10896,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringResultRecv",
+                    name: "ThriftTestTestEnumResultRecv",
                 })?;
                 match self {
-                    SecondServiceSecondtestStringResultRecv::Ok(ref value) => {
-                        __protocol.write_faststr_field(0, (value).clone())?;
+                    ThriftTestTestEnumResultRecv::Ok(ref value) => {
+                        __protocol.write_i32_field(0, (value).inner())?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -10758,10 +10926,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_faststr()?;
-                                __protocol.faststr_len(&field_ident);
-                                ret =
-                                    Some(SecondServiceSecondtestStringResultRecv::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestEnumResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -10810,11 +10977,13 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_faststr().await?;
+                                    let field_ident =
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(SecondServiceSecondtestStringResultRecv::Ok(
-                                        field_ident,
-                                    ));
+                                    ret = Some(ThriftTestTestEnumResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -10844,20 +11013,20 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringResultRecv",
+                    name: "ThriftTestTestEnumResultRecv",
                 }) + match self {
-                    SecondServiceSecondtestStringResultRecv::Ok(ref value) => {
-                        __protocol.faststr_field_len(Some(0), value)
+                    ThriftTestTestEnumResultRecv::Ok(ref value) => {
+                        __protocol.i32_field_len(Some(0), (value).inner())
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestBoolArgsSend {
-            pub thing: bool,
+        pub struct NestedListsI32x2 {
+            pub integerlist: ::std::option::Option<::std::vec::Vec<::std::vec::Vec<i32>>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestBoolArgsSend {
+        impl ::pilota::thrift::Message for NestedListsI32x2 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -10865,11 +11034,28 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolArgsSend",
+                    name: "NestedListsI32x2",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_bool_field(1, *&self.thing)?;
+                if let Some(value) = self.integerlist.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::List,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_list(
+                                ::pilota::thrift::TType::I32,
+                                &val,
+                                |__protocol, val| {
+                                    __protocol.write_i32(*val)?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -10881,7 +11067,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut integerlist = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -10897,8 +11083,30 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
-                                thing = Some(__protocol.read_bool()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                integerlist = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::std::vec::Vec<i32>> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                            let list_ident = __protocol.read_list_begin()?;
+                                            let mut val: Vec<i32> =
+                                                Vec::with_capacity(list_ident.size);
+                                            for i in 0..list_ident.size {
+                                                val.as_mut_ptr()
+                                                    .offset(i as isize)
+                                                    .write(__protocol.read_i32()?);
+                                            }
+                                            val.set_len(list_ident.size);
+                                            __protocol.read_list_end()?;
+                                            val
+                                        });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -10911,20 +11119,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `NestedListsI32x2` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
+                let data = Self { integerlist };
                 ::std::result::Result::Ok(data)
             }
 
@@ -10939,7 +11143,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut integerlist = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -10954,9 +11158,26 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
                                 {
-                                    thing = Some(__protocol.read_bool().await?);
+                                    integerlist = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push({
+                                                let list_ident =
+                                                    __protocol.read_list_begin().await?;
+                                                let mut val = Vec::with_capacity(list_ident.size);
+                                                for _ in 0..list_ident.size {
+                                                    val.push(__protocol.read_i32().await?);
+                                                }
+                                                __protocol.read_list_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -10970,22 +11191,16 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `NestedListsI32x2` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
+                    let data = Self { integerlist };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -10994,42 +11209,47 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolArgsSend",
-                }) + __protocol.bool_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
+                    name: "NestedListsI32x2",
+                }) + self.integerlist.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::List,
+                        value,
+                        |__protocol, el| {
+                            __protocol.list_len(
+                                ::pilota::thrift::TType::I32,
+                                el,
+                                |__protocol, el| __protocol.i32_len(*el),
+                            )
+                        },
+                    )
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMapArgsRecv {
-            pub thing: ::pilota::AHashMap<i32, i32>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestByteResultSend {
+            #[derivative(Default)]
+            Ok(i8),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMapArgsRecv {
+
+        impl ::pilota::thrift::Message for ThriftTestTestByteResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_map_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, key| {
-                        __protocol.write_i32(*key)?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestByteResultSend",
+                })?;
+                match self {
+                    ThriftTestTestByteResultSend::Ok(ref value) => {
+                        __protocol.write_i8_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -11040,225 +11260,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                thing = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_i8()?;
+                                __protocol.i8_len(*&field_ident);
+                                ret = Some(ThriftTestTestByteResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
-                                {
-                                    thing = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i32().await?,
-                                                __protocol.read_i32().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapArgsRecv",
-                }) + __protocol.map_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, key| __protocol.i32_len(*key),
-                    |__protocol, val| __protocol.i32_len(*val),
-                ) + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestExceptionException {
-            #[derivative(Default)]
-            Err1(Xception),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestExceptionException {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionException",
-                })?;
-                match self {
-                    ThriftTestTestExceptionException::Err1(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestExceptionException::Err1(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -11281,15 +11322,11 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(1) => {
+                            Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident =
-                                        <Xception as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                                    let field_ident = __protocol.read_i8().await?;
 
-                                    ret = Some(ThriftTestTestExceptionException::Err1(field_ident));
+                                    ret = Some(ThriftTestTestByteResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -11319,32 +11356,40 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionException",
+                    name: "ThriftTestTestByteResultSend",
                 }) + match self {
-                    ThriftTestTestExceptionException::Err1(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
+                    ThriftTestTestByteResultSend::Ok(ref value) => {
+                        __protocol.i8_field_len(Some(0), *value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestBinaryArgsRecv {
-            pub thing: ::pilota::Bytes,
+        pub struct ListBonks {
+            pub bonk: ::std::option::Option<::std::vec::Vec<Bonk>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestBinaryArgsRecv {
+        impl ::pilota::thrift::Message for ListBonks {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryArgsRecv",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ListBonks" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_bytes_field(1, (&self.thing).clone())?;
+                if let Some(value) = self.bonk.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::Struct,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_struct(val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -11356,7 +11401,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut bonk = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -11372,10 +11417,19 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                thing = Some(__protocol.read_bytes()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                bonk = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<Bonk> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(::pilota::thrift::Message::decode(__protocol)?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -11388,20 +11442,16 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `ListBonks` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
+                let data = Self { bonk };
                 ::std::result::Result::Ok(data)
             }
 
@@ -11416,7 +11466,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut bonk = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -11431,10 +11481,22 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
                                 {
-                                    thing = Some(__protocol.read_bytes().await?);
+                                    bonk = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(
+                                                <Bonk as ::pilota::thrift::Message>::decode_async(
+                                                    __protocol,
+                                                )
+                                                .await?,
+                                            );
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -11448,7 +11510,155 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `ListBonks` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { bonk };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ListBonks" })
+                    + self.bonk.as_ref().map_or(0, |value| {
+                        __protocol.list_field_len(
+                            Some(1),
+                            ::pilota::thrift::TType::Struct,
+                            value,
+                            |__protocol, el| __protocol.struct_len(el),
+                        )
+                    })
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestByteArgsRecv {
+            pub thing: i8,
+        }
+        impl ::pilota::thrift::Message for ThriftTestTestByteArgsRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestByteArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_i8_field(1, *&self.thing)?;
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                thing = Some(__protocol.read_i8()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    thing = Some(__protocol.read_i8().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -11472,21 +11682,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryArgsRecv",
-                }) + __protocol.bytes_field_len(Some(1), &self.thing)
+                    name: "ThriftTestTestByteArgsRecv",
+                }) + __protocol.i8_field_len(Some(1), *&self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMapMapResultRecv {
+        pub enum ThriftTestTestTypedefResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::AHashMap<i32, ::pilota::AHashMap<i32, i32>>),
+            Ok(UserId),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestMapMapResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestTypedefResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -11494,36 +11704,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapResultRecv",
+                    name: "ThriftTestTestTypedefResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestMapMapResultRecv::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::Map,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_i32(*key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_map(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::I32,
-                                    &val,
-                                    |__protocol, key| {
-                                        __protocol.write_i32(*key)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                    |__protocol, val| {
-                                        __protocol.write_i32(*val)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
+                    ThriftTestTestTypedefResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::I64)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -11549,43 +11734,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, {
-                                            let map_ident = __protocol.read_map_begin()?;
-                                            let mut val =
-                                                ::pilota::AHashMap::with_capacity(map_ident.size);
-                                            for _ in 0..map_ident.size {
-                                                val.insert(
-                                                    __protocol.read_i32()?,
-                                                    __protocol.read_i32()?,
-                                                );
-                                            }
-                                            __protocol.read_map_end()?;
-                                            val
-                                        });
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::Map,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.i32_len(*key),
-                                    |__protocol, val| {
-                                        __protocol.map_len(
-                                            ::pilota::thrift::TType::I32,
-                                            ::pilota::thrift::TType::I32,
-                                            val,
-                                            |__protocol, key| __protocol.i32_len(*key),
-                                            |__protocol, val| __protocol.i32_len(*val),
-                                        )
-                                    },
-                                );
-                                ret = Some(ThriftTestTestMapMapResultRecv::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestTypedefResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -11634,31 +11785,13 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(__protocol.read_i32().await?, {
-                                                let map_ident = __protocol.read_map_begin().await?;
-                                                let mut val = ::pilota::AHashMap::with_capacity(
-                                                    map_ident.size,
-                                                );
-                                                for _ in 0..map_ident.size {
-                                                    val.insert(
-                                                        __protocol.read_i32().await?,
-                                                        __protocol.read_i32().await?,
-                                                    );
-                                                }
-                                                __protocol.read_map_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
+                                    let field_ident =
+                                        <UserId as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestMapMapResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestTypedefResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -11688,57 +11821,30 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapResultRecv",
+                    name: "ThriftTestTestTypedefResultRecv",
                 }) + match self {
-                    ThriftTestTestMapMapResultRecv::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::Map,
-                        value,
-                        |__protocol, key| __protocol.i32_len(*key),
-                        |__protocol, val| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::I32,
-                                val,
-                                |__protocol, key| __protocol.i32_len(*key),
-                                |__protocol, val| __protocol.i32_len(*val),
-                            )
-                        },
-                    ),
+                    ThriftTestTestTypedefResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct VersioningTestV1 {
-            pub begin_in_both: ::std::option::Option<i32>,
-
-            pub old_string: ::std::option::Option<::pilota::FastStr>,
-
-            pub end_in_both: ::std::option::Option<i32>,
+        pub struct StructA {
+            pub s: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for VersioningTestV1 {
+        impl ::pilota::thrift::Message for StructA {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "VersioningTestV1",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "StructA" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.begin_in_both.as_ref() {
-                    __protocol.write_i32_field(1, *value)?;
-                }
-                if let Some(value) = self.old_string.as_ref() {
-                    __protocol.write_faststr_field(3, (value).clone())?;
-                }
-                if let Some(value) = self.end_in_both.as_ref() {
-                    __protocol.write_i32_field(12, *value)?;
-                }
+                __protocol.write_faststr_field(1, (&self.s).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -11750,9 +11856,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut begin_in_both = None;
-                let mut old_string = None;
-                let mut end_in_both = None;
+                let mut s = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -11768,16 +11872,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                begin_in_both = Some(__protocol.read_i32()?);
-                            }
-                            Some(3)
+                            Some(1)
                                 if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                old_string = Some(__protocol.read_faststr()?);
-                            }
-                            Some(12) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                end_in_both = Some(__protocol.read_i32()?);
+                                s = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -11791,7 +11889,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `VersioningTestV1` field(#{}) failed, caused by: ",
+                            "decode struct `StructA` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -11799,11 +11897,14 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    begin_in_both,
-                    old_string,
-                    end_in_both,
+                let Some(s) = s else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field s is required".to_string(),
+                    ));
                 };
+
+                let data = Self { s };
                 ::std::result::Result::Ok(data)
             }
 
@@ -11818,9 +11919,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut begin_in_both = None;
-                    let mut old_string = None;
-                    let mut end_in_both = None;
+                    let mut s = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -11835,20 +11934,10 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    begin_in_both = Some(__protocol.read_i32().await?);
-                                }
-                                Some(3)
                                     if field_ident.field_type
                                         == ::pilota::thrift::TType::Binary =>
                                 {
-                                    old_string = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(12)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    end_in_both = Some(__protocol.read_i32().await?);
+                                    s = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -11863,7 +11952,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `VersioningTestV1` field(#{}) failed, caused by: ",
+                                "decode struct `StructA` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -11871,11 +11960,16 @@ pub mod apache {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        begin_in_both,
-                        old_string,
-                        end_in_both,
+                    let Some(s) = s else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field s is required".to_string(),
+                            ),
+                        );
                     };
+
+                    let data = Self { s };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -11883,41 +11977,36 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "VersioningTestV1",
-                }) + self
-                    .begin_in_both
-                    .as_ref()
-                    .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
-                    + self
-                        .old_string
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(3), value))
-                    + self
-                        .end_in_both
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(12), *value))
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "StructA" })
+                    + __protocol.faststr_field_len(Some(1), &self.s)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestByteArgsRecv {
-            pub thing: i8,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestI32ResultSend {
+            #[derivative(Default)]
+            Ok(i32),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestByteArgsRecv {
+
+        impl ::pilota::thrift::Message for ThriftTestTestI32ResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i8_field(1, *&self.thing)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestI32ResultSend",
+                })?;
+                match self {
+                    ThriftTestTestI32ResultSend::Ok(ref value) => {
+                        __protocol.write_i32_field(0, *value)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -11928,52 +12017,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                thing = Some(__protocol.read_i8()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_i32()?;
+                                __protocol.i32_len(*&field_ident);
+                                ret = Some(ThriftTestTestI32ResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -11987,203 +12070,26 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    thing = Some(__protocol.read_i8().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteArgsRecv",
-                }) + __protocol.i8_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestSetResultRecv {
-            #[derivative(Default)]
-            Ok(::pilota::AHashSet<i32>),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestSetResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestSetResultRecv::Ok(ref value) => {
-                        __protocol.write_set_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = {
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_i32()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                };
-                                __protocol.set_len(
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, el| __protocol.i32_len(*el),
-                                );
-                                ret = Some(ThriftTestTestSetResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    };
-
-                                    ret = Some(ThriftTestTestSetResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_i32().await?;
+
+                                    ret = Some(ThriftTestTestI32ResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
@@ -12207,34 +12113,57 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetResultRecv",
+                    name: "ThriftTestTestI32ResultSend",
                 }) + match self {
-                    ThriftTestTestSetResultRecv::Ok(ref value) => __protocol.set_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, el| __protocol.i32_len(*el),
-                    ),
+                    ThriftTestTestI32ResultSend::Ok(ref value) => {
+                        __protocol.i32_field_len(Some(0), *value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct OneField {
-            pub field: ::std::option::Option<EmptyStruct>,
+        impl Default for OptionalBinary {
+            fn default() -> Self {
+                OptionalBinary {
+                    bin_map: Some({
+                        let mut map = ::pilota::AHashMap::with_capacity(0);
+
+                        map
+                    }),
+                }
+            }
         }
-        impl ::pilota::thrift::Message for OneField {
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct OptionalBinary {
+            pub bin_map: ::std::option::Option<::pilota::AHashMap<::pilota::Bytes, i32>>,
+        }
+        impl ::pilota::thrift::Message for OptionalBinary {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "OneField" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "OptionalBinary",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.field.as_ref() {
-                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                if let Some(value) = self.bin_map.as_ref() {
+                    __protocol.write_map_field(
+                        2,
+                        ::pilota::thrift::TType::Binary,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, key| {
+                            __protocol.write_bytes(key.clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -12247,7 +12176,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut field = None;
+                let mut bin_map = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -12263,10 +12192,19 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                field = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                bin_map = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            __protocol.read_bytes()?,
+                                            __protocol.read_i32()?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -12280,7 +12218,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `OneField` field(#{}) failed, caused by: ",
+                            "decode struct `OptionalBinary` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -12288,7 +12226,15 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { field };
+                if bin_map.is_none() {
+                    bin_map = Some({
+                        let mut map = ::pilota::AHashMap::with_capacity(0);
+
+                        map
+                    });
+                }
+
+                let data = Self { bin_map };
                 ::std::result::Result::Ok(data)
             }
 
@@ -12303,7 +12249,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut field = None;
+                    let mut bin_map = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -12317,16 +12263,22 @@ pub mod apache {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    field = Some(
-                                        <EmptyStruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    bin_map = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_bytes().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -12341,7 +12293,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `OneField` field(#{}) failed, caused by: ",
+                                "decode struct `OptionalBinary` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -12349,7 +12301,15 @@ pub mod apache {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { field };
+                    if bin_map.is_none() {
+                        bin_map = Some({
+                            let mut map = ::pilota::AHashMap::with_capacity(0);
+
+                            map
+                        });
+                    }
+
+                    let data = Self { bin_map };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -12357,39 +12317,38 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "OneField" })
-                    + self
-                        .field
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "OptionalBinary",
+                }) + self.bin_map.as_ref().map_or(0, |value| {
+                    __protocol.map_field_len(
+                        Some(2),
+                        ::pilota::thrift::TType::Binary,
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, key| __protocol.bytes_len(key),
+                        |__protocol, val| __protocol.i32_len(*val),
+                    )
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStructResultRecv {
-            #[derivative(Default)]
-            Ok(Xtruct),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestI32ArgsRecv {
+            pub thing: i32,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestStructResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestI32ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestStructResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestI32ArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_i32_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -12400,46 +12359,52 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestStructResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                thing = Some(__protocol.read_i32()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -12453,46 +12418,54 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut thing = None;
 
-                                    ret = Some(ThriftTestTestStructResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    thing = Some(__protocol.read_i32().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -12500,56 +12473,59 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructResultRecv",
-                }) + match self {
-                    ThriftTestTestStructResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestI32ArgsRecv",
+                }) + __protocol.i32_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct NestedListsI32x3 {
-            pub integerlist:
-                ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::vec::Vec<i32>>>>,
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMapMapResultRecv {
+            #[derivative(Default)]
+            Ok(::pilota::AHashMap<i32, ::pilota::AHashMap<i32, i32>>),
         }
-        impl ::pilota::thrift::Message for NestedListsI32x3 {
+
+        impl ::pilota::thrift::Message for ThriftTestTestMapMapResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsI32x3",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.integerlist.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::List,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_list(
-                                ::pilota::thrift::TType::List,
-                                &val,
-                                |__protocol, val| {
-                                    __protocol.write_list(
-                                        ::pilota::thrift::TType::I32,
-                                        &val,
-                                        |__protocol, val| {
-                                            __protocol.write_i32(*val)?;
-                                            ::std::result::Result::Ok(())
-                                        },
-                                    )?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapMapResultRecv",
+                })?;
+                match self {
+                    ThriftTestTestMapMapResultRecv::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::Map,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_i32(*key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_map(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::I32,
+                                    &val,
+                                    |__protocol, key| {
+                                        __protocol.write_i32(*key)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                    |__protocol, val| {
+                                        __protocol.write_i32(*val)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -12561,81 +12537,80 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut integerlist = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                integerlist = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::std::vec::Vec<::std::vec::Vec<i32>>> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                            let list_ident = __protocol.read_list_begin()?;
-                                            let mut val: Vec<::std::vec::Vec<i32>> =
-                                                Vec::with_capacity(list_ident.size);
-                                            for i in 0..list_ident.size {
-                                                val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                                    let list_ident =
-                                                        __protocol.read_list_begin()?;
-                                                    let mut val: Vec<i32> =
-                                                        Vec::with_capacity(list_ident.size);
-                                                    for i in 0..list_ident.size {
-                                                        val.as_mut_ptr()
-                                                            .offset(i as isize)
-                                                            .write(__protocol.read_i32()?);
-                                                    }
-                                                    val.set_len(list_ident.size);
-                                                    __protocol.read_list_end()?;
-                                                    val
-                                                });
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, {
+                                            let map_ident = __protocol.read_map_begin()?;
+                                            let mut val =
+                                                ::pilota::AHashMap::with_capacity(map_ident.size);
+                                            for _ in 0..map_ident.size {
+                                                val.insert(
+                                                    __protocol.read_i32()?,
+                                                    __protocol.read_i32()?,
+                                                );
                                             }
-                                            val.set_len(list_ident.size);
-                                            __protocol.read_list_end()?;
+                                            __protocol.read_map_end()?;
                                             val
                                         });
                                     }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
+                                    __protocol.read_map_end()?;
                                     val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::Map,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.i32_len(*key),
+                                    |__protocol, val| {
+                                        __protocol.map_len(
+                                            ::pilota::thrift::TType::I32,
+                                            ::pilota::thrift::TType::I32,
+                                            val,
+                                            |__protocol, key| __protocol.i32_len(*key),
+                                            |__protocol, val| __protocol.i32_len(*val),
+                                        )
+                                    },
+                                );
+                                ret = Some(ThriftTestTestMapMapResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `NestedListsI32x3` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self { integerlist };
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -12649,75 +12624,64 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut integerlist = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(__protocol.read_i32().await?, {
+                                                let map_ident = __protocol.read_map_begin().await?;
+                                                let mut val = ::pilota::AHashMap::with_capacity(
+                                                    map_ident.size,
+                                                );
+                                                for _ in 0..map_ident.size {
+                                                    val.insert(
+                                                        __protocol.read_i32().await?,
+                                                        __protocol.read_i32().await?,
+                                                    );
+                                                }
+                                                __protocol.read_map_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
+
+                                    ret = Some(ThriftTestTestMapMapResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
                             }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    integerlist = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push({
-                                                let list_ident =
-                                                    __protocol.read_list_begin().await?;
-                                                let mut val = Vec::with_capacity(list_ident.size);
-                                                for _ in 0..list_ident.size {
-                                                    val.push({
-                                                        let list_ident =
-                                                            __protocol.read_list_begin().await?;
-                                                        let mut val =
-                                                            Vec::with_capacity(list_ident.size);
-                                                        for _ in 0..list_ident.size {
-                                                            val.push(__protocol.read_i32().await?);
-                                                        }
-                                                        __protocol.read_list_end().await?;
-                                                        val
-                                                    });
-                                                }
-                                                __protocol.read_list_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
                             }
-
-                            __protocol.read_field_end().await?;
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `NestedListsI32x3` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self { integerlist };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -12725,39 +12689,37 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "NestedListsI32x3",
-                }) + self.integerlist.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::List,
+                    name: "ThriftTestTestMapMapResultRecv",
+                }) + match self {
+                    ThriftTestTestMapMapResultRecv::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::Map,
                         value,
-                        |__protocol, el| {
-                            __protocol.list_len(
-                                ::pilota::thrift::TType::List,
-                                el,
-                                |__protocol, el| {
-                                    __protocol.list_len(
-                                        ::pilota::thrift::TType::I32,
-                                        el,
-                                        |__protocol, el| __protocol.i32_len(*el),
-                                    )
-                                },
+                        |__protocol, key| __protocol.i32_len(*key),
+                        |__protocol, val| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::I32,
+                                val,
+                                |__protocol, key| __protocol.i32_len(*key),
+                                |__protocol, val| __protocol.i32_len(*val),
                             )
                         },
-                    )
-                }) + __protocol.field_stop_len()
+                    ),
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestI64ResultRecv {
+        pub enum ThriftTestTestI64ResultSend {
             #[derivative(Default)]
             Ok(i64),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestI64ResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestI64ResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -12765,10 +12727,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ResultRecv",
+                    name: "ThriftTestTestI64ResultSend",
                 })?;
                 match self {
-                    ThriftTestTestI64ResultRecv::Ok(ref value) => {
+                    ThriftTestTestI64ResultSend::Ok(ref value) => {
                         __protocol.write_i64_field(0, *value)?;
                     }
                 }
@@ -12797,7 +12759,7 @@ pub mod apache {
                             if ret.is_none() {
                                 let field_ident = __protocol.read_i64()?;
                                 __protocol.i64_len(*&field_ident);
-                                ret = Some(ThriftTestTestI64ResultRecv::Ok(field_ident));
+                                ret = Some(ThriftTestTestI64ResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -12848,7 +12810,7 @@ pub mod apache {
                                 if ret.is_none() {
                                     let field_ident = __protocol.read_i64().await?;
 
-                                    ret = Some(ThriftTestTestI64ResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestI64ResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -12878,38 +12840,32 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ResultRecv",
+                    name: "ThriftTestTestI64ResultSend",
                 }) + match self {
-                    ThriftTestTestI64ResultRecv::Ok(ref value) => {
+                    ThriftTestTestI64ResultSend::Ok(ref value) => {
                         __protocol.i64_field_len(Some(0), *value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStringResultRecv {
-            #[derivative(Default)]
-            Ok(::pilota::FastStr),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestI64ArgsRecv {
+            pub thing: i64,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestStringResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestI64ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestStringResultRecv::Ok(ref value) => {
-                        __protocol.write_faststr_field(0, (value).clone())?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestI64ArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_i64_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -12920,46 +12876,52 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_faststr()?;
-                                __protocol.faststr_len(&field_ident);
-                                ret = Some(ThriftTestTestStringResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                thing = Some(__protocol.read_i64()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -12973,42 +12935,54 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_faststr().await?;
+                    let mut thing = None;
 
-                                    ret = Some(ThriftTestTestStringResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    thing = Some(__protocol.read_i64().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -13016,24 +12990,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringResultRecv",
-                }) + match self {
-                    ThriftTestTestStringResultRecv::Ok(ref value) => {
-                        __protocol.faststr_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestI64ArgsRecv",
+                }) + __protocol.i64_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMultiResultSend {
+        pub enum ThriftTestTestInsanityResultRecv {
             #[derivative(Default)]
-            Ok(Xtruct),
+            Ok(::pilota::AHashMap<UserId, ::pilota::AHashMap<Numberz, Insanity>>),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestMultiResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestInsanityResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -13041,11 +13012,36 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiResultSend",
+                    name: "ThriftTestTestInsanityResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestMultiResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    ThriftTestTestInsanityResultRecv::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I64,
+                            ::pilota::thrift::TType::Map,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_struct(key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_map(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::Struct,
+                                    &val,
+                                    |__protocol, key| {
+                                        __protocol.write_struct(key)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                    |__protocol, val| {
+                                        __protocol.write_struct(val)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -13071,9 +13067,51 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestMultiResultSend::Ok(field_ident));
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                            {
+                                                let map_ident = __protocol.read_map_begin()?;
+                                                let mut val = ::pilota::AHashMap::with_capacity(
+                                                    map_ident.size,
+                                                );
+                                                for _ in 0..map_ident.size {
+                                                    val.insert(
+                                                        ::pilota::thrift::Message::decode(
+                                                            __protocol,
+                                                        )?,
+                                                        ::pilota::thrift::Message::decode(
+                                                            __protocol,
+                                                        )?,
+                                                    );
+                                                }
+                                                __protocol.read_map_end()?;
+                                                val
+                                            },
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I64,
+                                    ::pilota::thrift::TType::Map,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.struct_len(key),
+                                    |__protocol, val| {
+                                        __protocol.map_len(
+                                            ::pilota::thrift::TType::I32,
+                                            ::pilota::thrift::TType::Struct,
+                                            val,
+                                            |__protocol, key| __protocol.struct_len(key),
+                                            |__protocol, val| __protocol.struct_len(val),
+                                        )
+                                    },
+                                );
+                                ret = Some(ThriftTestTestInsanityResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -13122,13 +13160,26 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(<UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?, {
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                        }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
 
-                                    ret = Some(ThriftTestTestMultiResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestInsanityResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -13158,36 +13209,50 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiResultSend",
+                    name: "ThriftTestTestInsanityResultRecv",
                 }) + match self {
-                    ThriftTestTestMultiResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
+                    ThriftTestTestInsanityResultRecv::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I64,
+                        ::pilota::thrift::TType::Map,
+                        value,
+                        |__protocol, key| __protocol.struct_len(key),
+                        |__protocol, val| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::Struct,
+                                val,
+                                |__protocol, key| __protocol.struct_len(key),
+                                |__protocol, val| __protocol.struct_len(val),
+                            )
+                        },
+                    ),
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Bonk {
-            pub message: ::std::option::Option<::pilota::FastStr>,
-
-            pub r#type: ::std::option::Option<i32>,
+        #[derive(PartialOrd, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestDoubleResultSend {
+            #[derivative(Default)]
+            Ok(f64),
         }
-        impl ::pilota::thrift::Message for Bonk {
+
+        impl ::pilota::thrift::Message for ThriftTestTestDoubleResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Bonk" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.message.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                if let Some(value) = self.r#type.as_ref() {
-                    __protocol.write_i32_field(2, *value)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestDoubleResultSend",
+                })?;
+                match self {
+                    ThriftTestTestDoubleResultSend::Ok(ref value) => {
+                        __protocol.write_double_field(0, *value)?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -13199,54 +13264,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut message = None;
-                let mut r#type = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                message = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                r#type = Some(__protocol.read_i32()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_double()?;
+                                __protocol.double_len(*&field_ident);
+                                ret = Some(ThriftTestTestDoubleResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Bonk` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self { message, r#type };
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -13260,88 +13317,63 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut message = None;
-                    let mut r#type = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    message = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    r#type = Some(__protocol.read_i32().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_double().await?;
+
+                                    ret = Some(ThriftTestTestDoubleResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Bonk` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self { message, r#type };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Bonk" })
-                    + self
-                        .message
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self
-                        .r#type
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(2), *value))
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestDoubleResultSend",
+                }) + match self {
+                    ThriftTestTestDoubleResultSend::Ok(ref value) => {
+                        __protocol.double_field_len(Some(0), *value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        impl Default for OptionalSetDefaultTest {
-            fn default() -> Self {
-                OptionalSetDefaultTest {
-                    with_default: Some(::pilota::AHashSet::from([
-                        ::pilota::FastStr::from_static_str("test"),
-                    ])),
-                }
-            }
-        }
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct OptionalSetDefaultTest {
-            pub with_default: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
+        #[derive(PartialOrd, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestDoubleArgsRecv {
+            pub thing: f64,
         }
-        impl ::pilota::thrift::Message for OptionalSetDefaultTest {
+        impl ::pilota::thrift::Message for ThriftTestTestDoubleArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -13349,21 +13381,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "OptionalSetDefaultTest",
+                    name: "ThriftTestTestDoubleArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.with_default.as_ref() {
-                    __protocol.write_set_field(
-                        1,
-                        ::pilota::thrift::TType::Binary,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+                __protocol.write_double_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -13375,7 +13397,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut with_default = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -13391,17 +13413,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                with_default = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_faststr()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
+                            {
+                                thing = Some(__protocol.read_double()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -13414,22 +13429,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `OptionalSetDefaultTest` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                if with_default.is_none() {
-                    with_default = Some(::pilota::AHashSet::from([
-                        ::pilota::FastStr::from_static_str("test"),
-                    ]));
-                }
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
 
-                let data = Self { with_default };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -13444,7 +13457,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut with_default = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -13459,18 +13472,10 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Double =>
                                 {
-                                    with_default = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_faststr().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
+                                    thing = Some(__protocol.read_double().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -13484,19 +13489,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `OptionalSetDefaultTest` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    if with_default.is_none() {
-                        with_default = Some(::pilota::AHashSet::from([
-                            ::pilota::FastStr::from_static_str("test"),
-                        ]));
-                    }
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
 
-                    let data = Self { with_default };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -13505,27 +13513,21 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "OptionalSetDefaultTest",
-                }) + self.with_default.as_ref().map_or(0, |value| {
-                    __protocol.set_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::Binary,
-                        value,
-                        |__protocol, el| __protocol.faststr_len(el),
-                    )
-                }) + __protocol.field_stop_len()
+                    name: "ThriftTestTestDoubleArgsRecv",
+                }) + __protocol.double_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestEnumResultSend {
+        pub enum ThriftTestTestMultiResultRecv {
             #[derivative(Default)]
-            Ok(Numberz),
+            Ok(Xtruct),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestEnumResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -13533,11 +13535,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumResultSend",
+                    name: "ThriftTestTestMultiResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestEnumResultSend::Ok(ref value) => {
-                        __protocol.write_i32_field(0, (value).inner())?;
+                    ThriftTestTestMultiResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -13565,7 +13567,7 @@ pub mod apache {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestEnumResultSend::Ok(field_ident));
+                                ret = Some(ThriftTestTestMultiResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -13615,12 +13617,12 @@ pub mod apache {
                             Some(0) => {
                                 if ret.is_none() {
                                     let field_ident =
-                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
                                         .await?;
 
-                                    ret = Some(ThriftTestTestEnumResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestMultiResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -13650,20 +13652,158 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestEnumResultSend",
+                    name: "ThriftTestTestMultiResultRecv",
                 }) + match self {
-                    ThriftTestTestEnumResultSend::Ok(ref value) => {
-                        __protocol.i32_field_len(Some(0), (value).inner())
+                    ThriftTestTestMultiResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestOnewayArgsSend {
-            pub seconds_to_sleep: i32,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestBinaryResultSend {
+            #[derivative(Default)]
+            Ok(::pilota::Bytes),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestOnewayArgsSend {
+
+        impl ::pilota::thrift::Message for ThriftTestTestBinaryResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestBinaryResultSend",
+                })?;
+                match self {
+                    ThriftTestTestBinaryResultSend::Ok(ref value) => {
+                        __protocol.write_bytes_field(0, (value).clone())?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_bytes()?;
+                                __protocol.bytes_len(&field_ident);
+                                ret = Some(ThriftTestTestBinaryResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_bytes().await?;
+
+                                    ret = Some(ThriftTestTestBinaryResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestBinaryResultSend",
+                }) + match self {
+                    ThriftTestTestBinaryResultSend::Ok(ref value) => {
+                        __protocol.bytes_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestBinaryArgsRecv {
+            pub thing: ::pilota::Bytes,
+        }
+        impl ::pilota::thrift::Message for ThriftTestTestBinaryArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -13671,11 +13811,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayArgsSend",
+                    name: "ThriftTestTestBinaryArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.seconds_to_sleep)?;
+                __protocol.write_bytes_field(1, (&self.thing).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -13687,7 +13827,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut seconds_to_sleep = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -13703,8 +13843,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                seconds_to_sleep = Some(__protocol.read_i32()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                thing = Some(__protocol.read_bytes()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -13717,20 +13859,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(seconds_to_sleep) = seconds_to_sleep else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field seconds_to_sleep is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self { seconds_to_sleep };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -13745,7 +13887,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut seconds_to_sleep = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -13760,9 +13902,10 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    seconds_to_sleep = Some(__protocol.read_i32().await?);
+                                    thing = Some(__protocol.read_bytes().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -13776,22 +13919,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestBinaryArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(seconds_to_sleep) = seconds_to_sleep else {
+                    let Some(thing) = thing else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field seconds_to_sleep is required".to_string(),
+                                "field thing is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { seconds_to_sleep };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -13800,21 +13943,23 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayArgsSend",
-                }) + __protocol.i32_field_len(Some(1), *&self.seconds_to_sleep)
+                    name: "ThriftTestTestBinaryArgsRecv",
+                }) + __protocol.bytes_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMapResultSend {
+        pub enum ThriftTestTestExceptionResultRecv {
             #[derivative(Default)]
-            Ok(::pilota::AHashMap<i32, i32>),
+            Ok(()),
+
+            Err1(Xception),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestMapResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestExceptionResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -13822,24 +13967,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapResultSend",
+                    name: "ThriftTestTestExceptionResultRecv",
                 })?;
                 match self {
-                    ThriftTestTestMapResultSend::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_i32(*key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
+                    ThriftTestTestExceptionResultRecv::Ok(ref value) => {}
+                    ThriftTestTestExceptionResultRecv::Err1(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -13863,25 +13996,11 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
+                        Some(1) => {
                             if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.i32_len(*key),
-                                    |__protocol, val| __protocol.i32_len(*val),
-                                );
-                                ret = Some(ThriftTestTestMapResultSend::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestExceptionResultRecv::Err1(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -13901,10 +14020,7 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
+                    ::std::result::Result::Ok(ThriftTestTestExceptionResultRecv::Ok(()))
                 }
             }
 
@@ -13928,23 +14044,16 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
+                            Some(1) => {
                                 if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_i32().await?,
-                                                __protocol.read_i32().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
+                                    let field_ident =
+                                        <Xception as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestMapResultSend::Ok(field_ident));
+                                    ret =
+                                        Some(ThriftTestTestExceptionResultRecv::Err1(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -13962,7 +14071,143 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::std::result::Result::Ok(ThriftTestTestExceptionResultRecv::Ok(()))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestExceptionResultRecv",
+                }) + match self {
+                    ThriftTestTestExceptionResultRecv::Ok(ref value) => 0,
+                    ThriftTestTestExceptionResultRecv::Err1(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestUuidResultSend {
+            #[derivative(Default)]
+            Ok([u8; 16]),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestUuidResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestUuidResultSend",
+                })?;
+                match self {
+                    ThriftTestTestUuidResultSend::Ok(ref value) => {
+                        __protocol.write_uuid_field(0, *value)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_uuid()?;
+                                __protocol.uuid_len(*&field_ident);
+                                ret = Some(ThriftTestTestUuidResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_uuid().await?;
+
+                                    ret = Some(ThriftTestTestUuidResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
                             "received empty union from remote Message",
                         ))
@@ -13974,16 +14219,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapResultSend",
+                    name: "ThriftTestTestUuidResultSend",
                 }) + match self {
-                    ThriftTestTestMapResultSend::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, key| __protocol.i32_len(*key),
-                        |__protocol, val| __protocol.i32_len(*val),
-                    ),
+                    ThriftTestTestUuidResultSend::Ok(ref value) => {
+                        __protocol.uuid_field_len(Some(0), *value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -14129,29 +14369,12 @@ pub mod apache {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct CrazyNesting {
-            pub string_field: ::std::option::Option<::pilota::FastStr>,
-
-            pub set_field: ::std::option::Option<::pilota::AHashSet<Insanity>>,
-
-            pub list_field: ::std::vec::Vec<
-                ::pilota::AHashMap<
-                    ::pilota::AHashSet<i32>,
-                    ::pilota::AHashMap<
-                        i32,
-                        ::pilota::AHashSet<
-                            ::std::vec::Vec<::pilota::AHashMap<Insanity, ::pilota::FastStr>>,
-                        >,
-                    >,
-                >,
-            >,
-
-            pub binary_field: ::std::option::Option<::pilota::Bytes>,
-
-            pub uuid_field: ::std::option::Option<[u8; 16]>,
+        pub const MY_NUMBERZ: Numberz = Numberz::ONE;
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestUuidArgsRecv {
+            pub thing: [u8; 16],
         }
-        impl ::pilota::thrift::Message for CrazyNesting {
+        impl ::pilota::thrift::Message for ThriftTestTestUuidArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -14159,97 +14382,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "CrazyNesting",
+                    name: "ThriftTestTestUuidArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.string_field.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                if let Some(value) = self.set_field.as_ref() {
-                    __protocol.write_set_field(
-                        2,
-                        ::pilota::thrift::TType::Struct,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_struct(val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                __protocol.write_list_field(
-                    3,
-                    ::pilota::thrift::TType::Map,
-                    &&self.list_field,
-                    |__protocol, val| {
-                        __protocol.write_map(
-                            ::pilota::thrift::TType::Set,
-                            ::pilota::thrift::TType::Map,
-                            &val,
-                            |__protocol, key| {
-                                __protocol.write_set(
-                                    ::pilota::thrift::TType::I32,
-                                    &key,
-                                    |__protocol, val| {
-                                        __protocol.write_i32(*val)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_map(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::Set,
-                                    &val,
-                                    |__protocol, key| {
-                                        __protocol.write_i32(*key)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                    |__protocol, val| {
-                                        __protocol.write_set(
-                                            ::pilota::thrift::TType::List,
-                                            &val,
-                                            |__protocol, val| {
-                                                __protocol.write_list(
-                                                    ::pilota::thrift::TType::Map,
-                                                    &val,
-                                                    |__protocol, val| {
-                                                        __protocol.write_map(
-                                                            ::pilota::thrift::TType::Struct,
-                                                            ::pilota::thrift::TType::Binary,
-                                                            &val,
-                                                            |__protocol, key| {
-                                                                __protocol.write_struct(key)?;
-                                                                ::std::result::Result::Ok(())
-                                                            },
-                                                            |__protocol, val| {
-                                                                __protocol
-                                                                    .write_faststr((val).clone())?;
-                                                                ::std::result::Result::Ok(())
-                                                            },
-                                                        )?;
-                                                        ::std::result::Result::Ok(())
-                                                    },
-                                                )?;
-                                                ::std::result::Result::Ok(())
-                                            },
-                                        )?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                if let Some(value) = self.binary_field.as_ref() {
-                    __protocol.write_bytes_field(4, (value).clone())?;
-                }
-                if let Some(value) = self.uuid_field.as_ref() {
-                    __protocol.write_uuid_field(5, *value)?;
-                }
+                __protocol.write_uuid_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -14261,11 +14398,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut string_field = None;
-                let mut set_field = None;
-                let mut list_field = None;
-                let mut binary_field = None;
-                let mut uuid_field = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -14281,102 +14414,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                string_field = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                set_field = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(::pilota::thrift::Message::decode(__protocol)?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                list_field = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<
-                                        ::pilota::AHashMap<
-                                            ::pilota::AHashSet<i32>,
-                                            ::pilota::AHashMap<
-                                                i32,
-                                                ::pilota::AHashSet<
-                                                    ::std::vec::Vec<
-                                                        ::pilota::AHashMap<
-                                                            Insanity,
-                                                            ::pilota::FastStr,
-                                                        >,
-                                                    >,
-                                                >,
-                                            >,
-                                        >,
-                                    > = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write({
-                        let map_ident = __protocol.read_map_begin()?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert({let list_ident = __protocol.read_set_begin()?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(__protocol.read_i32()?);
-                    };
-                    __protocol.read_set_end()?;
-                    val}, {
-                        let map_ident = __protocol.read_map_begin()?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(__protocol.read_i32()?, {let list_ident = __protocol.read_set_begin()?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(unsafe {
-                            let list_ident = __protocol.read_list_begin()?;
-                            let mut val: Vec<::pilota::AHashMap<Insanity, ::pilota::FastStr>> = Vec::with_capacity(list_ident.size);
-                            for i in 0..list_ident.size {
-                                val.as_mut_ptr().offset(i as isize).write({
-                        let map_ident = __protocol.read_map_begin()?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(::pilota::thrift::Message::decode(__protocol)?, __protocol.read_faststr()?);
-                        }
-                        __protocol.read_map_end()?;
-                        val
-                    });
-                            };
-                            val.set_len(list_ident.size);
-                            __protocol.read_list_end()?;
-                            val
-                        });
-                    };
-                    __protocol.read_set_end()?;
-                    val});
-                        }
-                        __protocol.read_map_end()?;
-                        val
-                    });
-                        }
-                        __protocol.read_map_end()?;
-                        val
-                    });
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            Some(4)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                binary_field = Some(__protocol.read_bytes()?);
-                            }
-                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
-                                uuid_field = Some(__protocol.read_uuid()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
+                                thing = Some(__protocol.read_uuid()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -14389,29 +14428,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `CrazyNesting` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(list_field) = list_field else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field list_field is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self {
-                    string_field,
-                    set_field,
-                    list_field,
-                    binary_field,
-                    uuid_field,
-                };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -14426,218 +14456,63 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut string_field = None;
-                    let mut set_field = None;
-                    let mut list_field = None;
-                    let mut binary_field = None;
-                    let mut uuid_field = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                    loop {
-
-
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
-
-                    break;
-                } else {
-
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
-                    string_field = Some(__protocol.read_faststr().await?);
-
-                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
-                    set_field = Some({let list_ident = __protocol.read_set_begin().await?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(<Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                    };
-                    __protocol.read_set_end().await?;
-                    val});
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Uuid =>
+                                {
+                                    thing = Some(__protocol.read_uuid().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
 
-                },Some(3) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    list_field = Some({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push({
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert({let list_ident = __protocol.read_set_begin().await?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(__protocol.read_i32().await?);
-                    };
-                    __protocol.read_set_end().await?;
-                    val}, {
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(__protocol.read_i32().await?, {let list_ident = __protocol.read_set_begin().await?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push({
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(<Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?, __protocol.read_faststr().await?);
-                        }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-                    };
-                    __protocol.read_set_end().await?;
-                    val});
+                            __protocol.read_field_end().await?;
                         }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
 
-                },Some(4) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
-                    binary_field = Some(__protocol.read_bytes().await?);
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
 
-                },Some(5) if field_ident.field_type == ::pilota::thrift::TType::Uuid  => {
-                    uuid_field = Some(__protocol.read_uuid().await?);
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
-
-
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `CrazyNesting` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(list_field) = list_field else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field list_field is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self {
-                        string_field,
-                        set_field,
-                        list_field,
-                        binary_field,
-                        uuid_field,
-                    };
-                    ::std::result::Result::Ok(data)
-                })
-            }
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "CrazyNesting",
-                }) + self
-                    .string_field
-                    .as_ref()
-                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self.set_field.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(2),
-                            ::pilota::thrift::TType::Struct,
-                            value,
-                            |__protocol, el| __protocol.struct_len(el),
-                        )
-                    })
-                    + __protocol.list_field_len(
-                        Some(3),
-                        ::pilota::thrift::TType::Map,
-                        &self.list_field,
-                        |__protocol, el| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::Set,
-                                ::pilota::thrift::TType::Map,
-                                el,
-                                |__protocol, key| {
-                                    __protocol.set_len(
-                                        ::pilota::thrift::TType::I32,
-                                        key,
-                                        |__protocol, el| __protocol.i32_len(*el),
-                                    )
-                                },
-                                |__protocol, val| {
-                                    __protocol.map_len(
-                                        ::pilota::thrift::TType::I32,
-                                        ::pilota::thrift::TType::Set,
-                                        val,
-                                        |__protocol, key| __protocol.i32_len(*key),
-                                        |__protocol, val| {
-                                            __protocol.set_len(
-                                                ::pilota::thrift::TType::List,
-                                                val,
-                                                |__protocol, el| {
-                                                    __protocol.list_len(
-                                                        ::pilota::thrift::TType::Map,
-                                                        el,
-                                                        |__protocol, el| {
-                                                            __protocol.map_len(
-                                                                ::pilota::thrift::TType::Struct,
-                                                                ::pilota::thrift::TType::Binary,
-                                                                el,
-                                                                |__protocol, key| {
-                                                                    __protocol.struct_len(key)
-                                                                },
-                                                                |__protocol, val| {
-                                                                    __protocol.faststr_len(val)
-                                                                },
-                                                            )
-                                                        },
-                                                    )
-                                                },
-                                            )
-                                        },
-                                    )
-                                },
-                            )
-                        },
-                    )
-                    + self
-                        .binary_field
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bytes_field_len(Some(4), value))
-                    + self
-                        .uuid_field
-                        .as_ref()
-                        .map_or(0, |value| __protocol.uuid_field_len(Some(5), *value))
+                    name: "ThriftTestTestUuidArgsRecv",
+                }) + __protocol.uuid_field_len(Some(1), *&self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -14645,12 +14520,12 @@ pub mod apache {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestBinaryResultSend {
+        pub enum ThriftTestTestExceptionException {
             #[derivative(Default)]
-            Ok(::pilota::Bytes),
+            Err1(Xception),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestBinaryResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestExceptionException {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -14658,11 +14533,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryResultSend",
+                    name: "ThriftTestTestExceptionException",
                 })?;
                 match self {
-                    ThriftTestTestBinaryResultSend::Ok(ref value) => {
-                        __protocol.write_bytes_field(0, (value).clone())?;
+                    ThriftTestTestExceptionException::Err1(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -14686,11 +14561,11 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
+                        Some(1) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_bytes()?;
-                                __protocol.bytes_len(&field_ident);
-                                ret = Some(ThriftTestTestBinaryResultSend::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestExceptionException::Err1(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -14737,11 +14612,15 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
+                            Some(1) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_bytes().await?;
+                                    let field_ident =
+                                        <Xception as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestBinaryResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestExceptionException::Err1(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -14771,34 +14650,52 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBinaryResultSend",
+                    name: "ThriftTestTestExceptionException",
                 }) + match self {
-                    ThriftTestTestBinaryResultSend::Ok(ref value) => {
-                        __protocol.bytes_field_len(Some(0), value)
+                    ThriftTestTestExceptionException::Err1(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct SecondServiceSecondtestStringArgsSend {
-            pub thing: ::pilota::FastStr,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct MapType(pub ::pilota::AHashMap<::pilota::FastStr, Bonk>);
+
+        impl ::std::ops::Deref for MapType {
+            type Target = ::pilota::AHashMap<::pilota::FastStr, Bonk>;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
         }
-        impl ::pilota::thrift::Message for SecondServiceSecondtestStringArgsSend {
+
+        impl From<::pilota::AHashMap<::pilota::FastStr, Bonk>> for MapType {
+            fn from(v: ::pilota::AHashMap<::pilota::FastStr, Bonk>) -> Self {
+                Self(v)
+            }
+        }
+
+        impl ::pilota::thrift::Message for MapType {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.thing).clone())?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
+                __protocol.write_map(
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Struct,
+                    &(&**self),
+                    |__protocol, key| {
+                        __protocol.write_faststr((key).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_struct(val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 ::std::result::Result::Ok(())
             }
 
@@ -14807,54 +14704,18 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                thing = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsSend` field(#{}) failed, caused by: ", field_id));
+                ::std::result::Result::Ok(MapType({
+                    let map_ident = __protocol.read_map_begin()?;
+                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                    for _ in 0..map_ident.size {
+                        val.insert(
+                            __protocol.read_faststr()?,
+                            ::pilota::thrift::Message::decode(__protocol)?,
+                        );
                     }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                    __protocol.read_map_end()?;
+                    val
+                }))
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -14868,77 +14729,43 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    thing = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsSend` field(#{}) failed, caused by: ", field_id));
+                    ::std::result::Result::Ok(MapType({
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(
+                                __protocol.read_faststr().await?,
+                                <Bonk as ::pilota::thrift::Message>::decode_async(__protocol)
+                                    .await?,
+                            );
                         }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                        __protocol.read_map_end().await?;
+                        val
+                    }))
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringArgsSend",
-                }) + __protocol.faststr_field_len(Some(1), &self.thing)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
+                __protocol.map_len(
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Struct,
+                    &**self,
+                    |__protocol, key| __protocol.faststr_len(key),
+                    |__protocol, val| __protocol.struct_len(val),
+                )
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestByteResultSend {
+        pub enum ThriftTestTestStructResultSend {
             #[derivative(Default)]
-            Ok(i8),
+            Ok(Xtruct),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestByteResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStructResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -14946,11 +14773,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteResultSend",
+                    name: "ThriftTestTestStructResultSend",
                 })?;
                 match self {
-                    ThriftTestTestByteResultSend::Ok(ref value) => {
-                        __protocol.write_i8_field(0, *value)?;
+                    ThriftTestTestStructResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -14976,9 +14803,9 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_i8()?;
-                                __protocol.i8_len(*&field_ident);
-                                ret = Some(ThriftTestTestByteResultSend::Ok(field_ident));
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestStructResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -15027,9 +14854,13 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_i8().await?;
+                                    let field_ident =
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
 
-                                    ret = Some(ThriftTestTestByteResultSend::Ok(field_ident));
+                                    ret = Some(ThriftTestTestStructResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -15059,48 +14890,32 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestByteResultSend",
+                    name: "ThriftTestTestStructResultSend",
                 }) + match self {
-                    ThriftTestTestByteResultSend::Ok(ref value) => {
-                        __protocol.i8_field_len(Some(0), *value)
+                    ThriftTestTestStructResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMultiExceptionResultRecv {
-            #[derivative(Default)]
-            Ok(Xtruct),
-
-            Err1(Xception),
-
-            Err2(Xception2),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestExceptionArgsRecv {
+            pub arg: ::pilota::FastStr,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestExceptionArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestMultiExceptionResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    ThriftTestTestMultiExceptionResultRecv::Err1(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    ThriftTestTestMultiExceptionResultRecv::Err2(ref value) => {
-                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestExceptionArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_faststr_field(1, (&self.arg).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -15111,76 +14926,54 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut arg = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestMultiExceptionResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionResultRecv::Err1(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                arg = Some(__protocol.read_faststr()?);
                             }
-                        }
-                        Some(2) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionResultRecv::Err2(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(arg) = arg else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field arg is required".to_string(),
+                    ));
+                };
+
+                let data = Self { arg };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -15194,84 +14987,55 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut arg = None;
 
-                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Ok(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Err1(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            Some(2) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(ThriftTestTestMultiExceptionResultRecv::Err2(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    arg = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(arg) = arg else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { arg };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -15279,42 +15043,38 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionResultRecv",
-                }) + match self {
-                    ThriftTestTestMultiExceptionResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    ThriftTestTestMultiExceptionResultRecv::Err1(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                    ThriftTestTestMultiExceptionResultRecv::Err2(ref value) => {
-                        __protocol.struct_field_len(Some(2), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestExceptionArgsRecv",
+                }) + __protocol.faststr_field_len(Some(1), &self.arg)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Xception {
-            pub error_code: ::std::option::Option<i32>,
+        pub struct Xtruct2 {
+            pub byte_thing: ::std::option::Option<i8>,
 
-            pub message: ::std::option::Option<::pilota::FastStr>,
+            pub struct_thing: ::std::option::Option<Xtruct>,
+
+            pub i32_thing: ::std::option::Option<i32>,
         }
-        impl ::pilota::thrift::Message for Xception {
+        impl ::pilota::thrift::Message for Xtruct2 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xception" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct2" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.error_code.as_ref() {
-                    __protocol.write_i32_field(1, *value)?;
+                if let Some(value) = self.byte_thing.as_ref() {
+                    __protocol.write_i8_field(1, *value)?;
                 }
-                if let Some(value) = self.message.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
+                if let Some(value) = self.struct_thing.as_ref() {
+                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.i32_thing.as_ref() {
+                    __protocol.write_i32_field(3, *value)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -15327,8 +15087,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut error_code = None;
-                let mut message = None;
+                let mut byte_thing = None;
+                let mut struct_thing = None;
+                let mut i32_thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -15344,13 +15105,16 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                error_code = Some(__protocol.read_i32()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                byte_thing = Some(__protocol.read_i8()?);
                             }
                             Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                message = Some(__protocol.read_faststr()?);
+                                struct_thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                i32_thing = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -15364,7 +15128,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `Xception` field(#{}) failed, caused by: ",
+                            "decode struct `Xtruct2` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -15373,8 +15137,9 @@ pub mod apache {
                 __protocol.read_struct_end()?;
 
                 let data = Self {
-                    error_code,
-                    message,
+                    byte_thing,
+                    struct_thing,
+                    i32_thing,
                 };
                 ::std::result::Result::Ok(data)
             }
@@ -15390,8 +15155,9 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut error_code = None;
-                    let mut message = None;
+                    let mut byte_thing = None;
+                    let mut struct_thing = None;
+                    let mut i32_thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -15406,15 +15172,25 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
                                 {
-                                    error_code = Some(__protocol.read_i32().await?);
+                                    byte_thing = Some(__protocol.read_i8().await?);
                                 }
                                 Some(2)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    message = Some(__protocol.read_faststr().await?);
+                                    struct_thing = Some(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    i32_thing = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -15429,7 +15205,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `Xception` field(#{}) failed, caused by: ",
+                                "decode struct `Xtruct2` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -15438,8 +15214,9 @@ pub mod apache {
                     __protocol.read_struct_end().await?;
 
                     let data = Self {
-                        error_code,
-                        message,
+                        byte_thing,
+                        struct_thing,
+                        i32_thing,
                     };
                     ::std::result::Result::Ok(data)
                 })
@@ -15449,24 +15226,28 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xception" })
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct2" })
                     + self
-                        .error_code
+                        .byte_thing
                         .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
+                        .map_or(0, |value| __protocol.i8_field_len(Some(1), *value))
                     + self
-                        .message
+                        .struct_thing
                         .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
+                    + self
+                        .i32_thing
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(3), *value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMapMapArgsSend {
-            pub hello: i32,
+        pub struct ThriftTestTestStructArgsRecv {
+            pub thing: Xtruct,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMapMapArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStructArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -15474,11 +15255,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapArgsSend",
+                    name: "ThriftTestTestStructArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.hello)?;
+                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -15490,7 +15271,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut hello = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -15506,8 +15287,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                hello = Some(__protocol.read_i32()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -15520,20 +15303,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(hello) = hello else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field hello is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self { hello };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -15548,7 +15331,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut hello = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -15563,9 +15346,15 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    hello = Some(__protocol.read_i32().await?);
+                                    thing = Some(
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -15579,22 +15368,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(hello) = hello else {
+                    let Some(thing) = thing else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field hello is required".to_string(),
+                                "field thing is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { hello };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -15603,45 +15392,133 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapArgsSend",
-                }) + __protocol.i32_field_len(Some(1), *&self.hello)
+                    name: "ThriftTestTestStructArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct GuessProtocolStruct {
-            pub map_field:
-                ::std::option::Option<::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>>,
-        }
-        impl ::pilota::thrift::Message for GuessProtocolStruct {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+        pub struct CrazyNesting {
+            pub string_field: ::std::option::Option<::pilota::FastStr>,
+
+            pub set_field: ::std::option::Option<::pilota::AHashSet<Insanity>>,
+
+            pub list_field: ::std::vec::Vec<
+                ::pilota::AHashMap<
+                    ::pilota::AHashSet<i32>,
+                    ::pilota::AHashMap<
+                        i32,
+                        ::pilota::AHashSet<
+                            ::std::vec::Vec<::pilota::AHashMap<Insanity, ::pilota::FastStr>>,
+                        >,
+                    >,
+                >,
+            >,
+
+            pub binary_field: ::std::option::Option<::pilota::Bytes>,
+
+            pub uuid_field: ::std::option::Option<[u8; 16]>,
+        }
+        impl ::pilota::thrift::Message for CrazyNesting {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "GuessProtocolStruct",
+                    name: "CrazyNesting",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.map_field.as_ref() {
-                    __protocol.write_map_field(
-                        7,
-                        ::pilota::thrift::TType::Binary,
-                        ::pilota::thrift::TType::Binary,
+                if let Some(value) = self.string_field.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
+                if let Some(value) = self.set_field.as_ref() {
+                    __protocol.write_set_field(
+                        2,
+                        ::pilota::thrift::TType::Struct,
                         &value,
-                        |__protocol, key| {
-                            __protocol.write_faststr((key).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
                         |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
+                            __protocol.write_struct(val)?;
                             ::std::result::Result::Ok(())
                         },
                     )?;
                 }
+                __protocol.write_list_field(
+                    3,
+                    ::pilota::thrift::TType::Map,
+                    &&self.list_field,
+                    |__protocol, val| {
+                        __protocol.write_map(
+                            ::pilota::thrift::TType::Set,
+                            ::pilota::thrift::TType::Map,
+                            &val,
+                            |__protocol, key| {
+                                __protocol.write_set(
+                                    ::pilota::thrift::TType::I32,
+                                    &key,
+                                    |__protocol, val| {
+                                        __protocol.write_i32(*val)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_map(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::Set,
+                                    &val,
+                                    |__protocol, key| {
+                                        __protocol.write_i32(*key)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                    |__protocol, val| {
+                                        __protocol.write_set(
+                                            ::pilota::thrift::TType::List,
+                                            &val,
+                                            |__protocol, val| {
+                                                __protocol.write_list(
+                                                    ::pilota::thrift::TType::Map,
+                                                    &val,
+                                                    |__protocol, val| {
+                                                        __protocol.write_map(
+                                                            ::pilota::thrift::TType::Struct,
+                                                            ::pilota::thrift::TType::Binary,
+                                                            &val,
+                                                            |__protocol, key| {
+                                                                __protocol.write_struct(key)?;
+                                                                ::std::result::Result::Ok(())
+                                                            },
+                                                            |__protocol, val| {
+                                                                __protocol
+                                                                    .write_faststr((val).clone())?;
+                                                                ::std::result::Result::Ok(())
+                                                            },
+                                                        )?;
+                                                        ::std::result::Result::Ok(())
+                                                    },
+                                                )?;
+                                                ::std::result::Result::Ok(())
+                                            },
+                                        )?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                if let Some(value) = self.binary_field.as_ref() {
+                    __protocol.write_bytes_field(4, (value).clone())?;
+                }
+                if let Some(value) = self.uuid_field.as_ref() {
+                    __protocol.write_uuid_field(5, *value)?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -15653,7 +15530,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut map_field = None;
+                let mut string_field = None;
+                let mut set_field = None;
+                let mut list_field = None;
+                let mut binary_field = None;
+                let mut uuid_field = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -15669,20 +15550,103 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(7) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                map_field = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_faststr()?,
-                                            __protocol.read_faststr()?,
-                                        );
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                string_field = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                set_field = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(::pilota::thrift::Message::decode(__protocol)?);
                                     }
-                                    __protocol.read_map_end()?;
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                list_field = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<
+                                        ::pilota::AHashMap<
+                                            ::pilota::AHashSet<i32>,
+                                            ::pilota::AHashMap<
+                                                i32,
+                                                ::pilota::AHashSet<
+                                                    ::std::vec::Vec<
+                                                        ::pilota::AHashMap<
+                                                            Insanity,
+                                                            ::pilota::FastStr,
+                                                        >,
+                                                    >,
+                                                >,
+                                            >,
+                                        >,
+                                    > = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write({
+                        let map_ident = __protocol.read_map_begin()?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert({let list_ident = __protocol.read_set_begin()?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(__protocol.read_i32()?);
+                    };
+                    __protocol.read_set_end()?;
+                    val}, {
+                        let map_ident = __protocol.read_map_begin()?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(__protocol.read_i32()?, {let list_ident = __protocol.read_set_begin()?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(unsafe {
+                            let list_ident = __protocol.read_list_begin()?;
+                            let mut val: Vec<::pilota::AHashMap<Insanity, ::pilota::FastStr>> = Vec::with_capacity(list_ident.size);
+                            for i in 0..list_ident.size {
+                                val.as_mut_ptr().offset(i as isize).write({
+                        let map_ident = __protocol.read_map_begin()?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(::pilota::thrift::Message::decode(__protocol)?, __protocol.read_faststr()?);
+                        }
+                        __protocol.read_map_end()?;
+                        val
+                    });
+                            };
+                            val.set_len(list_ident.size);
+                            __protocol.read_list_end()?;
+                            val
+                        });
+                    };
+                    __protocol.read_set_end()?;
+                    val});
+                        }
+                        __protocol.read_map_end()?;
+                        val
+                    });
+                        }
+                        __protocol.read_map_end()?;
+                        val
+                    });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
                                     val
                                 });
                             }
+                            Some(4)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                binary_field = Some(__protocol.read_bytes()?);
+                            }
+                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
+                                uuid_field = Some(__protocol.read_uuid()?);
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -15695,7 +15659,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `GuessProtocolStruct` field(#{}) failed, caused by: ",
+                            "decode struct `CrazyNesting` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -15703,7 +15667,20 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { map_field };
+                let Some(list_field) = list_field else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field list_field is required".to_string(),
+                    ));
+                };
+
+                let data = Self {
+                    string_field,
+                    set_field,
+                    list_field,
+                    binary_field,
+                    uuid_field,
+                };
                 ::std::result::Result::Ok(data)
             }
 
@@ -15718,1046 +15695,137 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut map_field = None;
+                    let mut string_field = None;
+                    let mut set_field = None;
+                    let mut list_field = None;
+                    let mut binary_field = None;
+                    let mut uuid_field = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(7)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
-                                {
-                                    map_field = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_faststr().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `GuessProtocolStruct` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { map_field };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "GuessProtocolStruct",
-                }) + self.map_field.as_ref().map_or(0, |value| {
-                    __protocol.map_field_len(
-                        Some(7),
-                        ::pilota::thrift::TType::Binary,
-                        ::pilota::thrift::TType::Binary,
-                        value,
-                        |__protocol, key| __protocol.faststr_len(key),
-                        |__protocol, val| __protocol.faststr_len(val),
-                    )
-                }) + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestSetArgsSend {
-            pub thing: ::pilota::AHashSet<i32>,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestSetArgsSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_set_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                thing = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_i32()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsSend` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
-                                {
-                                    thing = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestSetArgsSend",
-                }) + __protocol.set_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, el| __protocol.i32_len(*el),
-                ) + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStructArgsSend {
-            pub thing: Xtruct,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestStructArgsSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::Struct)?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsSend` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    thing = Some(
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStructArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStructArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.thing)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestInsanityArgsRecv {
-            pub argument: Insanity,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestInsanityArgsRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(
-                    1,
-                    &self.argument,
-                    ::pilota::thrift::TType::Struct,
-                )?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut argument = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                argument = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsRecv` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(argument) = argument else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field argument is required".to_string(),
-                    ));
-                };
-
-                let data = Self { argument };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut argument = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    argument = Some(
-                                        <Insanity as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(argument) = argument else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field argument is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { argument };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityArgsRecv",
-                }) + __protocol.struct_field_len(Some(1), &self.argument)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        impl Default for BoolTest {
-            fn default() -> Self {
-                BoolTest {
-                    b: Some(true),
-                    s: Some(::pilota::FastStr::from_static_str("true")),
-                }
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
-        pub struct BoolTest {
-            pub b: ::std::option::Option<bool>,
-
-            pub s: ::std::option::Option<::pilota::FastStr>,
-        }
-        impl ::pilota::thrift::Message for BoolTest {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "BoolTest" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.b.as_ref() {
-                    __protocol.write_bool_field(1, *value)?;
-                }
-                if let Some(value) = self.s.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut b = Some(true);
-                let mut s = Some(::pilota::FastStr::from_static_str("true"));
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
-                                b = Some(__protocol.read_bool()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                s = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `BoolTest` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self { b, s };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut b = Some(true);
-                    let mut s = Some(::pilota::FastStr::from_static_str("true"));
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
-                                {
-                                    b = Some(__protocol.read_bool().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    s = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `BoolTest` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { b, s };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "BoolTest" })
-                    + self
-                        .b
-                        .as_ref()
-                        .map_or(0, |value| __protocol.bool_field_len(Some(1), *value))
-                    + self
-                        .s
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestI64ArgsSend {
-            pub thing: i64,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestI64ArgsSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i64_field(1, *&self.thing)?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                thing = Some(__protocol.read_i64()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsSend` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    thing = Some(__protocol.read_i64().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
-                })
-            }
+                    loop {
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI64ArgsSend",
-                }) + __protocol.i64_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestListArgsRecv {
-            pub thing: ::std::vec::Vec<i32>,
-        }
-        impl ::pilota::thrift::Message for ThriftTestTestListArgsRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListArgsRecv",
-                };
 
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_list_field(
-                    1,
-                    ::pilota::thrift::TType::I32,
-                    &&self.thing,
-                    |__protocol, val| {
-                        __protocol.write_i32(*val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
 
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                    break;
+                } else {
 
-                let mut thing = None;
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
+                    string_field = Some(__protocol.read_faststr().await?);
 
-                let mut __pilota_decoding_field_id = None;
+                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
+                    set_field = Some({let list_ident = __protocol.read_set_begin().await?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(<Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                    };
+                    __protocol.read_set_end().await?;
+                    val});
 
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                },Some(3) if field_ident.field_type == ::pilota::thrift::TType::List  => {
+                    list_field = Some({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push({
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert({let list_ident = __protocol.read_set_begin().await?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(__protocol.read_i32().await?);
+                    };
+                    __protocol.read_set_end().await?;
+                    val}, {
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(__protocol.read_i32().await?, {let list_ident = __protocol.read_set_begin().await?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push({
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(<Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?, __protocol.read_faststr().await?);
                         }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                thing = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+                    };
+                    __protocol.read_set_end().await?;
+                    val});
                         }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+                        }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
 
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsRecv` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
+                },Some(4) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
+                    binary_field = Some(__protocol.read_bytes().await?);
 
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    thing = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                },Some(5) if field_ident.field_type == ::pilota::thrift::TType::Uuid  => {
+                    uuid_field = Some(__protocol.read_uuid().await?);
 
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
+
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `CrazyNesting` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(list_field) = list_field else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field list_field is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self {
+                        string_field,
+                        set_field,
+                        list_field,
+                        binary_field,
+                        uuid_field,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -16766,33 +15834,106 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListArgsRecv",
-                }) + __protocol.list_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::I32,
-                    &self.thing,
-                    |__protocol, el| __protocol.i32_len(*el),
-                ) + __protocol.field_stop_len()
+                    name: "CrazyNesting",
+                }) + self
+                    .string_field
+                    .as_ref()
+                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + self.set_field.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(2),
+                            ::pilota::thrift::TType::Struct,
+                            value,
+                            |__protocol, el| __protocol.struct_len(el),
+                        )
+                    })
+                    + __protocol.list_field_len(
+                        Some(3),
+                        ::pilota::thrift::TType::Map,
+                        &self.list_field,
+                        |__protocol, el| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::Set,
+                                ::pilota::thrift::TType::Map,
+                                el,
+                                |__protocol, key| {
+                                    __protocol.set_len(
+                                        ::pilota::thrift::TType::I32,
+                                        key,
+                                        |__protocol, el| __protocol.i32_len(*el),
+                                    )
+                                },
+                                |__protocol, val| {
+                                    __protocol.map_len(
+                                        ::pilota::thrift::TType::I32,
+                                        ::pilota::thrift::TType::Set,
+                                        val,
+                                        |__protocol, key| __protocol.i32_len(*key),
+                                        |__protocol, val| {
+                                            __protocol.set_len(
+                                                ::pilota::thrift::TType::List,
+                                                val,
+                                                |__protocol, el| {
+                                                    __protocol.list_len(
+                                                        ::pilota::thrift::TType::Map,
+                                                        el,
+                                                        |__protocol, el| {
+                                                            __protocol.map_len(
+                                                                ::pilota::thrift::TType::Struct,
+                                                                ::pilota::thrift::TType::Binary,
+                                                                el,
+                                                                |__protocol, key| {
+                                                                    __protocol.struct_len(key)
+                                                                },
+                                                                |__protocol, val| {
+                                                                    __protocol.faststr_len(val)
+                                                                },
+                                                            )
+                                                        },
+                                                    )
+                                                },
+                                            )
+                                        },
+                                    )
+                                },
+                            )
+                        },
+                    )
+                    + self
+                        .binary_field
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bytes_field_len(Some(4), value))
+                    + self
+                        .uuid_field
+                        .as_ref()
+                        .map_or(0, |value| __protocol.uuid_field_len(Some(5), *value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStringArgsSend {
-            pub thing: ::pilota::FastStr,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestNestResultSend {
+            #[derivative(Default)]
+            Ok(Xtruct2),
         }
-        impl ::pilota::thrift::Message for ThriftTestTestStringArgsSend {
+
+        impl ::pilota::thrift::Message for ThriftTestTestNestResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.thing).clone())?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestNestResultSend",
+                })?;
+                match self {
+                    ThriftTestTestNestResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -16803,54 +15944,46 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                thing = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestNestResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -16864,55 +15997,46 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    thing = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestNestResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -16920,9 +16044,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringArgsSend",
-                }) + __protocol.faststr_field_len(Some(1), &self.thing)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestNestResultSend",
+                }) + match self {
+                    ThriftTestTestNestResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
@@ -17084,14 +16211,14 @@ pub mod apache {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestExceptionResultRecv {
+        pub enum ThriftTestTestMultiExceptionException {
             #[derivative(Default)]
-            Ok(()),
-
             Err1(Xception),
+
+            Err2(Xception2),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestExceptionResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionException {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -17099,13 +16226,209 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionResultRecv",
+                    name: "ThriftTestTestMultiExceptionException",
                 })?;
                 match self {
-                    ThriftTestTestExceptionResultRecv::Ok(ref value) => {}
-                    ThriftTestTestExceptionResultRecv::Err1(ref value) => {
+                    ThriftTestTestMultiExceptionException::Err1(ref value) => {
                         __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
                     }
+                    ThriftTestTestMultiExceptionException::Err2(ref value) => {
+                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionException::Err1(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(2) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret =
+                                    Some(ThriftTestTestMultiExceptionException::Err2(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionException::Err1(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(2) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiExceptionException::Err2(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMultiExceptionException",
+                }) + match self {
+                    ThriftTestTestMultiExceptionException::Err1(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                    ThriftTestTestMultiExceptionException::Err2(ref value) => {
+                        __protocol.struct_field_len(Some(2), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMapResultSend {
+            #[derivative(Default)]
+            Ok(::pilota::AHashMap<i32, i32>),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestMapResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapResultSend",
+                })?;
+                match self {
+                    ThriftTestTestMapResultSend::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_i32(*key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -17128,11 +16451,25 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(1) => {
+                        Some(0) => {
                             if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestExceptionResultRecv::Err1(field_ident));
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.i32_len(*key),
+                                    |__protocol, val| __protocol.i32_len(*val),
+                                );
+                                ret = Some(ThriftTestTestMapResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -17152,7 +16489,10 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Ok(ThriftTestTestExceptionResultRecv::Ok(()))
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
                 }
             }
 
@@ -17176,16 +16516,23 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
-                            Some(1) => {
+                            Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident =
-                                        <Xception as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i32().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
 
-                                    ret =
-                                        Some(ThriftTestTestExceptionResultRecv::Err1(field_ident));
+                                    ret = Some(ThriftTestTestMapResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -17195,232 +16542,47 @@ pub mod apache {
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Ok(ThriftTestTestExceptionResultRecv::Ok(()))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestExceptionResultRecv",
-                }) + match self {
-                    ThriftTestTestExceptionResultRecv::Ok(ref value) => 0,
-                    ThriftTestTestExceptionResultRecv::Err1(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Xtruct2 {
-            pub byte_thing: ::std::option::Option<i8>,
-
-            pub struct_thing: ::std::option::Option<Xtruct>,
-
-            pub i32_thing: ::std::option::Option<i32>,
-        }
-        impl ::pilota::thrift::Message for Xtruct2 {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xtruct2" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.byte_thing.as_ref() {
-                    __protocol.write_i8_field(1, *value)?;
-                }
-                if let Some(value) = self.struct_thing.as_ref() {
-                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.i32_thing.as_ref() {
-                    __protocol.write_i32_field(3, *value)?;
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut byte_thing = None;
-                let mut struct_thing = None;
-                let mut i32_thing = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                byte_thing = Some(__protocol.read_i8()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                struct_thing = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                i32_thing = Some(__protocol.read_i32()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Xtruct2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self {
-                    byte_thing,
-                    struct_thing,
-                    i32_thing,
-                };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut byte_thing = None;
-                    let mut struct_thing = None;
-                    let mut i32_thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    byte_thing = Some(__protocol.read_i8().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    struct_thing = Some(
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    i32_thing = Some(__protocol.read_i32().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Xtruct2` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self {
-                        byte_thing,
-                        struct_thing,
-                        i32_thing,
-                    };
-                    ::std::result::Result::Ok(data)
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xtruct2" })
-                    + self
-                        .byte_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i8_field_len(Some(1), *value))
-                    + self
-                        .struct_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
-                    + self
-                        .i32_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(3), *value))
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapResultSend",
+                }) + match self {
+                    ThriftTestTestMapResultSend::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, key| __protocol.i32_len(*key),
+                        |__protocol, val| __protocol.i32_len(*val),
+                    ),
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestDoubleArgsRecv {
-            pub thing: f64,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMultiExceptionArgsSend {
+            pub arg0: ::pilota::FastStr,
+
+            pub arg1: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestDoubleArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -17428,11 +16590,12 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleArgsRecv",
+                    name: "ThriftTestTestMultiExceptionArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_double_field(1, *&self.thing)?;
+                __protocol.write_faststr_field(1, (&self.arg0).clone())?;
+                __protocol.write_faststr_field(2, (&self.arg1).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -17444,7 +16607,8 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut thing = None;
+                let mut arg0 = None;
+                let mut arg1 = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -17461,9 +16625,14 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                thing = Some(__protocol.read_double()?);
+                                arg0 = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                arg1 = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -17476,20 +16645,26 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(thing) = thing else {
+                let Some(arg0) = arg0 else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
+                        "field arg0 is required".to_string(),
+                    ));
+                };
+                let Some(arg1) = arg1 else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field arg1 is required".to_string(),
                     ));
                 };
 
-                let data = Self { thing };
+                let data = Self { arg0, arg1 };
                 ::std::result::Result::Ok(data)
             }
 
@@ -17504,7 +16679,8 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
+                    let mut arg0 = None;
+                    let mut arg1 = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -17520,9 +16696,15 @@ pub mod apache {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Double =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    thing = Some(__protocol.read_double().await?);
+                                    arg0 = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    arg1 = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -17536,22 +16718,30 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(thing) = thing else {
+                    let Some(arg0) = arg0 else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
+                                "field arg0 is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(arg1) = arg1 else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field arg1 is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { thing };
+                    let data = Self { arg0, arg1 };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -17560,35 +16750,28 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleArgsRecv",
-                }) + __protocol.double_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestMultiExceptionArgsSend",
+                }) + __protocol.faststr_field_len(Some(1), &self.arg0)
+                    + __protocol.faststr_field_len(Some(2), &self.arg1)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestTypedefResultRecv {
-            #[derivative(Default)]
-            Ok(UserId),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestTypedefResultRecv {
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct EmptyStruct {}
+        impl ::pilota::thrift::Message for EmptyStruct {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestTypedefResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::I64)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "EmptyStruct",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -17599,46 +16782,43 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestTypedefResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `EmptyStruct` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self {};
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -17652,46 +16832,41 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <UserId as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret = Some(ThriftTestTestTypedefResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `EmptyStruct` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
-                    }
-                    __protocol.read_field_end().await?;
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self {};
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -17699,20 +16874,16 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefResultRecv",
-                }) + match self {
-                    ThriftTestTestTypedefResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "EmptyStruct",
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestBoolArgsRecv {
-            pub thing: bool,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestMapArgsRecv {
+            pub thing: ::pilota::AHashMap<i32, i32>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestBoolArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestMapArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -17720,11 +16891,24 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolArgsRecv",
+                    name: "ThriftTestTestMapArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_bool_field(1, *&self.thing)?;
+                __protocol.write_map_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, key| {
+                        __protocol.write_i32(*key)?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -17752,8 +16936,16 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
-                                thing = Some(__protocol.read_bool()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                thing = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -17766,7 +16958,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -17809,9 +17001,21 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    thing = Some(__protocol.read_bool().await?);
+                                    thing = Some({
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(
+                                                __protocol.read_i32().await?,
+                                                __protocol.read_i32().await?,
+                                            );
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -17825,7 +17029,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -17849,21 +17053,27 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolArgsRecv",
-                }) + __protocol.bool_field_len(Some(1), *&self.thing)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestMapArgsRecv",
+                }) + __protocol.map_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, key| __protocol.i32_len(*key),
+                    |__protocol, val| __protocol.i32_len(*val),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestStringMapResultRecv {
+        pub enum ThriftTestTestStringMapResultSend {
             #[derivative(Default)]
             Ok(::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestStringMapResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestStringMapResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -17871,10 +17081,10 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapResultRecv",
+                    name: "ThriftTestTestStringMapResultSend",
                 })?;
                 match self {
-                    ThriftTestTestStringMapResultRecv::Ok(ref value) => {
+                    ThriftTestTestStringMapResultSend::Ok(ref value) => {
                         __protocol.write_map_field(
                             0,
                             ::pilota::thrift::TType::Binary,
@@ -17933,7 +17143,7 @@ pub mod apache {
                                     |__protocol, key| __protocol.faststr_len(key),
                                     |__protocol, val| __protocol.faststr_len(val),
                                 );
-                                ret = Some(ThriftTestTestStringMapResultRecv::Ok(field_ident));
+                                ret = Some(ThriftTestTestStringMapResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -17996,7 +17206,7 @@ pub mod apache {
                                         val
                                     };
 
-                                    ret = Some(ThriftTestTestStringMapResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestStringMapResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -18026,9 +17236,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapResultRecv",
+                    name: "ThriftTestTestStringMapResultSend",
                 }) + match self {
-                    ThriftTestTestStringMapResultRecv::Ok(ref value) => __protocol.map_field_len(
+                    ThriftTestTestStringMapResultSend::Ok(ref value) => __protocol.map_field_len(
                         Some(0),
                         ::pilota::thrift::TType::Binary,
                         ::pilota::thrift::TType::Binary,
@@ -18040,29 +17250,168 @@ pub mod apache {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestUuidResultRecv {
-            #[derivative(Default)]
-            Ok([u8; 16]),
-        }
-
-        impl ::pilota::thrift::Message for ThriftTestTestUuidResultRecv {
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestOnewayArgsSend {
+            pub seconds_to_sleep: i32,
+        }
+        impl ::pilota::thrift::Message for ThriftTestTestOnewayArgsSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestOnewayArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_i32_field(1, *&self.seconds_to_sleep)?;
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut seconds_to_sleep = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                seconds_to_sleep = Some(__protocol.read_i32()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(seconds_to_sleep) = seconds_to_sleep else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field seconds_to_sleep is required".to_string(),
+                    ));
+                };
+
+                let data = Self { seconds_to_sleep };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut seconds_to_sleep = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                {
+                                    seconds_to_sleep = Some(__protocol.read_i32().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(seconds_to_sleep) = seconds_to_sleep else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field seconds_to_sleep is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { seconds_to_sleep };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestOnewayArgsSend",
+                }) + __protocol.i32_field_len(Some(1), *&self.seconds_to_sleep)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestVoidArgsSend {}
+        impl ::pilota::thrift::Message for ThriftTestTestVoidArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidResultRecv",
-                })?;
-                match self {
-                    ThriftTestTestUuidResultRecv::Ok(ref value) => {
-                        __protocol.write_uuid_field(0, *value)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestVoidArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -18073,46 +17422,40 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_uuid()?;
-                                __protocol.uuid_len(*&field_ident);
-                                ret = Some(ThriftTestTestUuidResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self {};
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -18126,161 +17469,80 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_uuid().await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret = Some(ThriftTestTestUuidResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidResultRecv",
-                }) + match self {
-                    ThriftTestTestUuidResultRecv::Ok(ref value) => {
-                        __protocol.uuid_field_len(Some(0), *value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct VersioningTestV2 {
-            pub begin_in_both: ::std::option::Option<i32>,
-
-            pub newint: ::std::option::Option<i32>,
-
-            pub newbyte: ::std::option::Option<i8>,
 
-            pub newshort: ::std::option::Option<i16>,
-
-            pub newlong: ::std::option::Option<i64>,
-
-            pub newdouble: ::std::option::Option<f64>,
-
-            pub newstruct: ::std::option::Option<Bonk>,
-
-            pub newlist: ::std::option::Option<::std::vec::Vec<i32>>,
-
-            pub newset: ::std::option::Option<::pilota::AHashSet<i32>>,
-
-            pub newmap: ::std::option::Option<::pilota::AHashMap<i32, i32>>,
-
-            pub newstring: ::std::option::Option<::pilota::FastStr>,
-
-            pub end_in_both: ::std::option::Option<i32>,
-        }
-        impl ::pilota::thrift::Message for VersioningTestV2 {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "VersioningTestV2",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.begin_in_both.as_ref() {
-                    __protocol.write_i32_field(1, *value)?;
-                }
-                if let Some(value) = self.newint.as_ref() {
-                    __protocol.write_i32_field(2, *value)?;
-                }
-                if let Some(value) = self.newbyte.as_ref() {
-                    __protocol.write_i8_field(3, *value)?;
-                }
-                if let Some(value) = self.newshort.as_ref() {
-                    __protocol.write_i16_field(4, *value)?;
-                }
-                if let Some(value) = self.newlong.as_ref() {
-                    __protocol.write_i64_field(5, *value)?;
-                }
-                if let Some(value) = self.newdouble.as_ref() {
-                    __protocol.write_double_field(6, *value)?;
-                }
-                if let Some(value) = self.newstruct.as_ref() {
-                    __protocol.write_struct_field(7, value, ::pilota::thrift::TType::Struct)?;
-                }
-                if let Some(value) = self.newlist.as_ref() {
-                    __protocol.write_list_field(
-                        8,
-                        ::pilota::thrift::TType::I32,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_i32(*val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.newset.as_ref() {
-                    __protocol.write_set_field(
-                        9,
-                        ::pilota::thrift::TType::I32,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_i32(*val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.newmap.as_ref() {
-                    __protocol.write_map_field(
-                        10,
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::I32,
-                        &value,
-                        |__protocol, key| {
-                            __protocol.write_i32(*key)?;
-                            ::std::result::Result::Ok(())
-                        },
-                        |__protocol, val| {
-                            __protocol.write_i32(*val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.newstring.as_ref() {
-                    __protocol.write_faststr_field(11, (value).clone())?;
-                }
-                if let Some(value) = self.end_in_both.as_ref() {
-                    __protocol.write_i32_field(12, *value)?;
-                }
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestVoidArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self {};
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestVoidArgsSend",
+                }) + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestStringMapArgsRecv {
+            pub thing: ::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>,
+        }
+        impl ::pilota::thrift::Message for ThriftTestTestStringMapArgsRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestStringMapArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_map_field(
+                    1,
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Binary,
+                    &&self.thing,
+                    |__protocol, key| {
+                        __protocol.write_faststr((key).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_faststr((val).clone())?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -18292,18 +17554,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut begin_in_both = None;
-                let mut newint = None;
-                let mut newbyte = None;
-                let mut newshort = None;
-                let mut newlong = None;
-                let mut newdouble = None;
-                let mut newstruct = None;
-                let mut newlist = None;
-                let mut newset = None;
-                let mut newmap = None;
-                let mut newstring = None;
-                let mut end_in_both = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -18319,76 +17570,20 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                begin_in_both = Some(__protocol.read_i32()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                newint = Some(__protocol.read_i32()?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                newbyte = Some(__protocol.read_i8()?);
-                            }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::I16 => {
-                                newshort = Some(__protocol.read_i16()?);
-                            }
-                            Some(5) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                newlong = Some(__protocol.read_i64()?);
-                            }
-                            Some(6)
-                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
-                            {
-                                newdouble = Some(__protocol.read_double()?);
-                            }
-                            Some(7)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                newstruct = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
-                            Some(8) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                newlist = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(__protocol.read_i32()?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            Some(9) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                newset = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_i32()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
-                            }
-                            Some(10) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                newmap = Some({
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                thing = Some({
                                     let map_ident = __protocol.read_map_begin()?;
                                     let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
                                     for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, __protocol.read_i32()?);
+                                        val.insert(
+                                            __protocol.read_faststr()?,
+                                            __protocol.read_faststr()?,
+                                        );
                                     }
                                     __protocol.read_map_end()?;
                                     val
                                 });
                             }
-                            Some(11)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                newstring = Some(__protocol.read_faststr()?);
-                            }
-                            Some(12) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                end_in_both = Some(__protocol.read_i32()?);
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -18400,29 +17595,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `VersioningTestV2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    begin_in_both,
-                    newint,
-                    newbyte,
-                    newshort,
-                    newlong,
-                    newdouble,
-                    newstruct,
-                    newlist,
-                    newset,
-                    newmap,
-                    newstring,
-                    end_in_both,
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
                 };
+
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -18437,128 +17623,37 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut begin_in_both = None;
-                    let mut newint = None;
-                    let mut newbyte = None;
-                    let mut newshort = None;
-                    let mut newlong = None;
-                    let mut newdouble = None;
-                    let mut newstruct = None;
-                    let mut newlist = None;
-                    let mut newset = None;
-                    let mut newmap = None;
-                    let mut newstring = None;
-                    let mut end_in_both = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    begin_in_both = Some(__protocol.read_i32().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    newint = Some(__protocol.read_i32().await?);
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    newbyte = Some(__protocol.read_i8().await?);
-                                }
-                                Some(4)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I16 =>
-                                {
-                                    newshort = Some(__protocol.read_i16().await?);
-                                }
-                                Some(5)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
-                                {
-                                    newlong = Some(__protocol.read_i64().await?);
-                                }
-                                Some(6)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Double =>
-                                {
-                                    newdouble = Some(__protocol.read_double().await?);
-                                }
-                                Some(7)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    newstruct = Some(
-                                        <Bonk as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                Some(8)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    newlist = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(9)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
-                                {
-                                    newset = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_i32().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(10)
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
                                     if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    newmap = Some({
+                                    thing = Some({
                                         let map_ident = __protocol.read_map_begin().await?;
                                         let mut val =
                                             ::pilota::AHashMap::with_capacity(map_ident.size);
                                         for _ in 0..map_ident.size {
                                             val.insert(
-                                                __protocol.read_i32().await?,
-                                                __protocol.read_i32().await?,
+                                                __protocol.read_faststr().await?,
+                                                __protocol.read_faststr().await?,
                                             );
                                         }
                                         __protocol.read_map_end().await?;
                                         val
                                     });
                                 }
-                                Some(11)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    newstring = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(12)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    end_in_both = Some(__protocol.read_i32().await?);
-                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -18571,29 +17666,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `VersioningTestV2` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        begin_in_both,
-                        newint,
-                        newbyte,
-                        newshort,
-                        newlong,
-                        newdouble,
-                        newstruct,
-                        newlist,
-                        newset,
-                        newmap,
-                        newstring,
-                        end_in_both,
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
                     };
+
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -18602,82 +17690,168 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "VersioningTestV2",
-                }) + self
-                    .begin_in_both
-                    .as_ref()
-                    .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
-                    + self
-                        .newint
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(2), *value))
-                    + self
-                        .newbyte
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i8_field_len(Some(3), *value))
-                    + self
-                        .newshort
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i16_field_len(Some(4), *value))
-                    + self
-                        .newlong
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i64_field_len(Some(5), *value))
-                    + self
-                        .newdouble
-                        .as_ref()
-                        .map_or(0, |value| __protocol.double_field_len(Some(6), *value))
-                    + self
-                        .newstruct
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(7), value))
-                    + self.newlist.as_ref().map_or(0, |value| {
-                        __protocol.list_field_len(
-                            Some(8),
-                            ::pilota::thrift::TType::I32,
-                            value,
-                            |__protocol, el| __protocol.i32_len(*el),
-                        )
-                    })
-                    + self.newset.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(9),
-                            ::pilota::thrift::TType::I32,
-                            value,
-                            |__protocol, el| __protocol.i32_len(*el),
-                        )
-                    })
-                    + self.newmap.as_ref().map_or(0, |value| {
-                        __protocol.map_field_len(
-                            Some(10),
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I32,
-                            value,
-                            |__protocol, key| __protocol.i32_len(*key),
-                            |__protocol, val| __protocol.i32_len(*val),
-                        )
-                    })
-                    + self
-                        .newstring
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(11), value))
-                    + self
-                        .end_in_both
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(12), *value))
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestStringMapArgsRecv",
+                }) + __protocol.map_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::Binary,
+                    ::pilota::thrift::TType::Binary,
+                    &self.thing,
+                    |__protocol, key| __protocol.faststr_len(key),
+                    |__protocol, val| __protocol.faststr_len(val),
+                ) + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum SecondServiceSecondtestStringResultRecv {
+            #[derivative(Default)]
+            Ok(::pilota::FastStr),
+        }
+
+        impl ::pilota::thrift::Message for SecondServiceSecondtestStringResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "SecondServiceSecondtestStringResultRecv",
+                })?;
+                match self {
+                    SecondServiceSecondtestStringResultRecv::Ok(ref value) => {
+                        __protocol.write_faststr_field(0, (value).clone())?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = __protocol.read_faststr()?;
+                                __protocol.faststr_len(&field_ident);
+                                ret =
+                                    Some(SecondServiceSecondtestStringResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = __protocol.read_faststr().await?;
+
+                                    ret = Some(SecondServiceSecondtestStringResultRecv::Ok(
+                                        field_ident,
+                                    ));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "SecondServiceSecondtestStringResultRecv",
+                }) + match self {
+                    SecondServiceSecondtestStringResultRecv::Ok(ref value) => {
+                        __protocol.faststr_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestI32ResultRecv {
+        pub enum ThriftTestTestSetResultSend {
             #[derivative(Default)]
-            Ok(i32),
+            Ok(::pilota::AHashSet<i32>),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestI32ResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestSetResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -18685,11 +17859,19 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ResultRecv",
+                    name: "ThriftTestTestSetResultSend",
                 })?;
                 match self {
-                    ThriftTestTestI32ResultRecv::Ok(ref value) => {
-                        __protocol.write_i32_field(0, *value)?;
+                    ThriftTestTestSetResultSend::Ok(ref value) => {
+                        __protocol.write_set_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -18715,9 +17897,22 @@ pub mod apache {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = __protocol.read_i32()?;
-                                __protocol.i32_len(*&field_ident);
-                                ret = Some(ThriftTestTestI32ResultRecv::Ok(field_ident));
+                                let field_ident = {
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_i32()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                };
+                                __protocol.set_len(
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, el| __protocol.i32_len(*el),
+                                );
+                                ret = Some(ThriftTestTestSetResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -18766,9 +17961,18 @@ pub mod apache {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = __protocol.read_i32().await?;
+                                    let field_ident = {
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    };
 
-                                    ret = Some(ThriftTestTestI32ResultRecv::Ok(field_ident));
+                                    ret = Some(ThriftTestTestSetResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -18798,48 +18002,193 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestI32ResultRecv",
+                    name: "ThriftTestTestSetResultSend",
                 }) + match self {
-                    ThriftTestTestI32ResultRecv::Ok(ref value) => {
-                        __protocol.i32_field_len(Some(0), *value)
-                    }
+                    ThriftTestTestSetResultSend::Ok(ref value) => __protocol.set_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, el| __protocol.i32_len(*el),
+                    ),
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestMultiExceptionResultSend {
-            #[derivative(Default)]
-            Ok(Xtruct),
-
-            Err1(Xception),
-
-            Err2(Xception2),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestStringArgsSend {
+            pub thing: ::pilota::FastStr,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestStringArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionResultSend",
-                })?;
-                match self {
-                    ThriftTestTestMultiExceptionResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestStringArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_faststr_field(1, (&self.thing).clone())?;
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                thing = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                    ThriftTestTestMultiExceptionResultSend::Err1(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
-                    ThriftTestTestMultiExceptionResultSend::Err2(ref value) => {
-                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    thing = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestStringArgsSend",
+                }) + __protocol.faststr_field_len(Some(1), &self.thing)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestSetArgsRecv {
+            pub thing: ::pilota::AHashSet<i32>,
+        }
+        impl ::pilota::thrift::Message for ThriftTestTestSetArgsRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestSetArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_set_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -18850,76 +18199,61 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestMultiExceptionResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionResultSend::Err1(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                thing = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_i32()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
                             }
-                        }
-                        Some(2) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret =
-                                    Some(ThriftTestTestMultiExceptionResultSend::Err2(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -18933,115 +18267,90 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut thing = None;
 
-                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Ok(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Err1(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            Some(2) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xception2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(ThriftTestTestMultiExceptionResultSend::Err2(
-                                        field_ident,
-                                    ));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                {
+                                    thing = Some({
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestSetArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionResultSend",
-                }) + match self {
-                    ThriftTestTestMultiExceptionResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    ThriftTestTestMultiExceptionResultSend::Err1(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                    ThriftTestTestMultiExceptionResultSend::Err2(ref value) => {
-                        __protocol.struct_field_len(Some(2), value)
-                    }
-                } + __protocol.field_stop_len()
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestSetArgsRecv",
+                }) + __protocol.set_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, el| __protocol.i32_len(*el),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        pub trait SecondService {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestVoidResultRecv {
+        pub enum ThriftTestTestListResultSend {
             #[derivative(Default)]
-            Ok(()),
+            Ok(::std::vec::Vec<i32>),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestVoidResultRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestListResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -19049,10 +18358,20 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidResultRecv",
+                    name: "ThriftTestTestListResultSend",
                 })?;
                 match self {
-                    ThriftTestTestVoidResultRecv::Ok(ref value) => {}
+                    ThriftTestTestListResultSend::Ok(ref value) => {
+                        __protocol.write_list_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            &value,
+                            |__protocol, val| {
+                                __protocol.write_i32(*val)?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -19075,6 +18394,35 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_i32()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                };
+                                __protocol.list_len(
+                                    ::pilota::thrift::TType::I32,
+                                    &field_ident,
+                                    |__protocol, el| __protocol.i32_len(*el),
+                                );
+                                ret = Some(ThriftTestTestListResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -19085,7 +18433,10 @@ pub mod apache {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Ok(ThriftTestTestVoidResultRecv::Ok(()))
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
                 }
             }
 
@@ -19109,6 +18460,26 @@ pub mod apache {
                         } else {
                         }
                         match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(__protocol.read_i32().await?);
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    };
+
+                                    ret = Some(ThriftTestTestListResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -19119,7 +18490,10 @@ pub mod apache {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Ok(ThriftTestTestVoidResultRecv::Ok(()))
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
                     }
                 })
             }
@@ -19128,60 +18502,49 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestVoidResultRecv",
+                    name: "ThriftTestTestListResultSend",
                 }) + match self {
-                    ThriftTestTestVoidResultRecv::Ok(ref value) => 0,
+                    ThriftTestTestListResultSend::Ok(ref value) => __protocol.list_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        value,
+                        |__protocol, el| __protocol.i32_len(*el),
+                    ),
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestInsanityResultSend {
-            #[derivative(Default)]
-            Ok(::pilota::AHashMap<UserId, ::pilota::AHashMap<Numberz, Insanity>>),
-        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ListTypeVersioningV1 {
+            pub myints: ::std::option::Option<::std::vec::Vec<i32>>,
 
-        impl ::pilota::thrift::Message for ThriftTestTestInsanityResultSend {
+            pub hello: ::std::option::Option<::pilota::FastStr>,
+        }
+        impl ::pilota::thrift::Message for ListTypeVersioningV1 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityResultSend",
-                })?;
-                match self {
-                    ThriftTestTestInsanityResultSend::Ok(ref value) => {
-                        __protocol.write_map_field(
-                            0,
-                            ::pilota::thrift::TType::I64,
-                            ::pilota::thrift::TType::Map,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_struct(key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_map(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::Struct,
-                                    &val,
-                                    |__protocol, key| {
-                                        __protocol.write_struct(key)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                    |__protocol, val| {
-                                        __protocol.write_struct(val)?;
-                                        ::std::result::Result::Ok(())
-                                    },
-                                )?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ListTypeVersioningV1",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.myints.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.hello.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -19193,88 +18556,65 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut myints = None;
+                let mut hello = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                            {
-                                                let map_ident = __protocol.read_map_begin()?;
-                                                let mut val = ::pilota::AHashMap::with_capacity(
-                                                    map_ident.size,
-                                                );
-                                                for _ in 0..map_ident.size {
-                                                    val.insert(
-                                                        ::pilota::thrift::Message::decode(
-                                                            __protocol,
-                                                        )?,
-                                                        ::pilota::thrift::Message::decode(
-                                                            __protocol,
-                                                        )?,
-                                                    );
-                                                }
-                                                __protocol.read_map_end()?;
-                                                val
-                                            },
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I64,
-                                    ::pilota::thrift::TType::Map,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.struct_len(key),
-                                    |__protocol, val| {
-                                        __protocol.map_len(
-                                            ::pilota::thrift::TType::I32,
-                                            ::pilota::thrift::TType::Struct,
-                                            val,
-                                            |__protocol, key| __protocol.struct_len(key),
-                                            |__protocol, val| __protocol.struct_len(val),
-                                        )
-                                    },
-                                );
-                                ret = Some(ThriftTestTestInsanityResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                myints = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_i32()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                hello = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `ListTypeVersioningV1` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self { myints, hello };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -19288,59 +18628,60 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut myints = None;
+                    let mut hello = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(<UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?, {
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                        }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    myints = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push(__protocol.read_i32().await?);
                                         }
-                                        __protocol.read_map_end().await?;
+                                        __protocol.read_list_end().await?;
                                         val
-                                    };
-
-                                    ret = Some(ThriftTestTestInsanityResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                    });
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    hello = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ListTypeVersioningV1` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self { myints, hello };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -19348,41 +18689,27 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestInsanityResultSend",
-                }) + match self {
-                    ThriftTestTestInsanityResultSend::Ok(ref value) => __protocol.map_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I64,
-                        ::pilota::thrift::TType::Map,
+                    name: "ListTypeVersioningV1",
+                }) + self.myints.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::I32,
                         value,
-                        |__protocol, key| __protocol.struct_len(key),
-                        |__protocol, val| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::Struct,
-                                val,
-                                |__protocol, key| __protocol.struct_len(key),
-                                |__protocol, val| __protocol.struct_len(val),
-                            )
-                        },
-                    ),
-                } + __protocol.field_stop_len()
+                        |__protocol, el| __protocol.i32_len(*el),
+                    )
+                }) + self
+                    .hello
+                    .as_ref()
+                    .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct NestedMixedx2 {
-            pub int_set_list: ::std::option::Option<::std::vec::Vec<::pilota::AHashSet<i32>>>,
-
-            pub map_int_strset: ::std::option::Option<
-                ::pilota::AHashMap<i32, ::pilota::AHashSet<::pilota::FastStr>>,
-            >,
-
-            pub map_int_strset_list: ::std::option::Option<
-                ::std::vec::Vec<::pilota::AHashMap<i32, ::pilota::AHashSet<::pilota::FastStr>>>,
-            >,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestBoolArgsSend {
+            pub thing: bool,
         }
-        impl ::pilota::thrift::Message for NestedMixedx2 {
+        impl ::pilota::thrift::Message for ThriftTestTestBoolArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -19390,81 +18717,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "NestedMixedx2",
+                    name: "ThriftTestTestBoolArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.int_set_list.as_ref() {
-                    __protocol.write_list_field(
-                        1,
-                        ::pilota::thrift::TType::Set,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_set(
-                                ::pilota::thrift::TType::I32,
-                                &val,
-                                |__protocol, val| {
-                                    __protocol.write_i32(*val)?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.map_int_strset.as_ref() {
-                    __protocol.write_map_field(
-                        2,
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::Set,
-                        &value,
-                        |__protocol, key| {
-                            __protocol.write_i32(*key)?;
-                            ::std::result::Result::Ok(())
-                        },
-                        |__protocol, val| {
-                            __protocol.write_set(
-                                ::pilota::thrift::TType::Binary,
-                                &val,
-                                |__protocol, val| {
-                                    __protocol.write_faststr((val).clone())?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                if let Some(value) = self.map_int_strset_list.as_ref() {
-                    __protocol.write_list_field(
-                        3,
-                        ::pilota::thrift::TType::Map,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_map(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::Set,
-                                &val,
-                                |__protocol, key| {
-                                    __protocol.write_i32(*key)?;
-                                    ::std::result::Result::Ok(())
-                                },
-                                |__protocol, val| {
-                                    __protocol.write_set(
-                                        ::pilota::thrift::TType::Binary,
-                                        &val,
-                                        |__protocol, val| {
-                                            __protocol.write_faststr((val).clone())?;
-                                            ::std::result::Result::Ok(())
-                                        },
-                                    )?;
-                                    ::std::result::Result::Ok(())
-                                },
-                            )?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
+                __protocol.write_bool_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -19476,9 +18733,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut int_set_list = None;
-                let mut map_int_strset = None;
-                let mut map_int_strset_list = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -19494,83 +18749,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                int_set_list = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::pilota::AHashSet<i32>> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write({
-                                            let list_ident = __protocol.read_set_begin()?;
-                                            let mut val =
-                                                ::pilota::AHashSet::with_capacity(list_ident.size);
-                                            for _ in 0..list_ident.size {
-                                                val.insert(__protocol.read_i32()?);
-                                            }
-                                            __protocol.read_set_end()?;
-                                            val
-                                        });
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                map_int_strset = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(__protocol.read_i32()?, {
-                                            let list_ident = __protocol.read_set_begin()?;
-                                            let mut val =
-                                                ::pilota::AHashSet::with_capacity(list_ident.size);
-                                            for _ in 0..list_ident.size {
-                                                val.insert(__protocol.read_faststr()?);
-                                            }
-                                            __protocol.read_set_end()?;
-                                            val
-                                        });
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                map_int_strset_list = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<
-                                        ::pilota::AHashMap<
-                                            i32,
-                                            ::pilota::AHashSet<::pilota::FastStr>,
-                                        >,
-                                    > = Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write({
-                                            let map_ident = __protocol.read_map_begin()?;
-                                            let mut val =
-                                                ::pilota::AHashMap::with_capacity(map_ident.size);
-                                            for _ in 0..map_ident.size {
-                                                val.insert(__protocol.read_i32()?, {
-                                                    let list_ident = __protocol.read_set_begin()?;
-                                                    let mut val = ::pilota::AHashSet::with_capacity(
-                                                        list_ident.size,
-                                                    );
-                                                    for _ in 0..list_ident.size {
-                                                        val.insert(__protocol.read_faststr()?);
-                                                    }
-                                                    __protocol.read_set_end()?;
-                                                    val
-                                                });
-                                            }
-                                            __protocol.read_map_end()?;
-                                            val
-                                        });
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
+                                thing = Some(__protocol.read_bool()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -19583,20 +18763,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `NestedMixedx2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    int_set_list,
-                    map_int_strset,
-                    map_int_strset_list,
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
                 };
+
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -19611,9 +18791,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut int_set_list = None;
-                    let mut map_int_strset = None;
-                    let mut map_int_strset_list = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -19628,90 +18806,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    int_set_list = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push({
-                                                let list_ident =
-                                                    __protocol.read_set_begin().await?;
-                                                let mut val = ::pilota::AHashSet::with_capacity(
-                                                    list_ident.size,
-                                                );
-                                                for _ in 0..list_ident.size {
-                                                    val.insert(__protocol.read_i32().await?);
-                                                }
-                                                __protocol.read_set_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
-                                {
-                                    map_int_strset = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(__protocol.read_i32().await?, {
-                                                let list_ident =
-                                                    __protocol.read_set_begin().await?;
-                                                let mut val = ::pilota::AHashSet::with_capacity(
-                                                    list_ident.size,
-                                                );
-                                                for _ in 0..list_ident.size {
-                                                    val.insert(__protocol.read_faststr().await?);
-                                                }
-                                                __protocol.read_set_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
                                 {
-                                    map_int_strset_list = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push({
-                                                let map_ident = __protocol.read_map_begin().await?;
-                                                let mut val = ::pilota::AHashMap::with_capacity(
-                                                    map_ident.size,
-                                                );
-                                                for _ in 0..map_ident.size {
-                                                    val.insert(__protocol.read_i32().await?, {
-                                                        let list_ident =
-                                                            __protocol.read_set_begin().await?;
-                                                        let mut val =
-                                                            ::pilota::AHashSet::with_capacity(
-                                                                list_ident.size,
-                                                            );
-                                                        for _ in 0..list_ident.size {
-                                                            val.insert(
-                                                                __protocol.read_faststr().await?,
-                                                            );
-                                                        }
-                                                        __protocol.read_set_end().await?;
-                                                        val
-                                                    });
-                                                }
-                                                __protocol.read_map_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
+                                    thing = Some(__protocol.read_bool().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -19725,113 +18822,61 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `NestedMixedx2` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestBoolArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        int_set_list,
-                        map_int_strset,
-                        map_int_strset_list,
-                    };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "NestedMixedx2",
-                }) + self.int_set_list.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(1),
-                        ::pilota::thrift::TType::Set,
-                        value,
-                        |__protocol, el| {
-                            __protocol.set_len(
-                                ::pilota::thrift::TType::I32,
-                                el,
-                                |__protocol, el| __protocol.i32_len(*el),
-                            )
-                        },
-                    )
-                }) + self.map_int_strset.as_ref().map_or(0, |value| {
-                    __protocol.map_field_len(
-                        Some(2),
-                        ::pilota::thrift::TType::I32,
-                        ::pilota::thrift::TType::Set,
-                        value,
-                        |__protocol, key| __protocol.i32_len(*key),
-                        |__protocol, val| {
-                            __protocol.set_len(
-                                ::pilota::thrift::TType::Binary,
-                                val,
-                                |__protocol, el| __protocol.faststr_len(el),
-                            )
-                        },
-                    )
-                }) + self.map_int_strset_list.as_ref().map_or(0, |value| {
-                    __protocol.list_field_len(
-                        Some(3),
-                        ::pilota::thrift::TType::Map,
-                        value,
-                        |__protocol, el| {
-                            __protocol.map_len(
-                                ::pilota::thrift::TType::I32,
-                                ::pilota::thrift::TType::Set,
-                                el,
-                                |__protocol, key| __protocol.i32_len(*key),
-                                |__protocol, val| {
-                                    __protocol.set_len(
-                                        ::pilota::thrift::TType::Binary,
-                                        val,
-                                        |__protocol, el| __protocol.faststr_len(el),
-                                    )
-                                },
-                            )
-                        },
-                    )
-                }) + __protocol.field_stop_len()
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestBoolArgsSend",
+                }) + __protocol.bool_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestListResultSend {
-            #[derivative(Default)]
-            Ok(::std::vec::Vec<i32>),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestListArgsRecv {
+            pub thing: ::std::vec::Vec<i32>,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestListResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestListArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListResultSend",
-                })?;
-                match self {
-                    ThriftTestTestListResultSend::Ok(ref value) => {
-                        __protocol.write_list_field(
-                            0,
-                            ::pilota::thrift::TType::I32,
-                            &value,
-                            |__protocol, val| {
-                                __protocol.write_i32(*val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestListArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_list_field(
+                    1,
+                    ::pilota::thrift::TType::I32,
+                    &&self.thing,
+                    |__protocol, val| {
+                        __protocol.write_i32(*val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -19842,20 +18887,25 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = unsafe {
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                thing = Some(unsafe {
                                     let list_ident = __protocol.read_list_begin()?;
                                     let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
                                     for i in 0..list_ident.size {
@@ -19866,37 +18916,34 @@ pub mod apache {
                                     val.set_len(list_ident.size);
                                     __protocol.read_list_end()?;
                                     val
-                                };
-                                __protocol.list_len(
-                                    ::pilota::thrift::TType::I32,
-                                    &field_ident,
-                                    |__protocol, el| __protocol.i32_len(*el),
-                                );
-                                ret = Some(ThriftTestTestListResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -19910,18 +18957,24 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = {
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    thing = Some({
                                         let list_ident = __protocol.read_list_begin().await?;
                                         let mut val = Vec::with_capacity(list_ident.size);
                                         for _ in 0..list_ident.size {
@@ -19929,31 +18982,37 @@ pub mod apache {
                                         }
                                         __protocol.read_list_end().await?;
                                         val
-                                    };
-
-                                    ret = Some(ThriftTestTestListResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestListArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -19961,25 +19020,39 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestListResultSend",
-                }) + match self {
-                    ThriftTestTestListResultSend::Ok(ref value) => __protocol.list_field_len(
-                        Some(0),
-                        ::pilota::thrift::TType::I32,
-                        value,
-                        |__protocol, el| __protocol.i32_len(*el),
-                    ),
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestListArgsRecv",
+                }) + __protocol.list_field_len(
+                    Some(1),
+                    ::pilota::thrift::TType::I32,
+                    &self.thing,
+                    |__protocol, el| __protocol.i32_len(*el),
+                ) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMultiExceptionArgsSend {
-            pub arg0: ::pilota::FastStr,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct LargeDeltas {
+            pub b1: ::std::option::Option<Bools>,
 
-            pub arg1: ::pilota::FastStr,
+            pub b10: ::std::option::Option<Bools>,
+
+            pub b100: ::std::option::Option<Bools>,
+
+            pub check_true: ::std::option::Option<bool>,
+
+            pub b1000: ::std::option::Option<Bools>,
+
+            pub check_false: ::std::option::Option<bool>,
+
+            pub vertwo2000: ::std::option::Option<VersioningTestV2>,
+
+            pub a_set2500: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
+
+            pub vertwo3000: ::std::option::Option<VersioningTestV2>,
+
+            pub big_numbers: ::std::option::Option<::std::vec::Vec<i32>>,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMultiExceptionArgsSend {
+        impl ::pilota::thrift::Message for LargeDeltas {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -19987,12 +19060,56 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionArgsSend",
+                    name: "LargeDeltas",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.arg0).clone())?;
-                __protocol.write_faststr_field(2, (&self.arg1).clone())?;
+                if let Some(value) = self.b1.as_ref() {
+                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.b10.as_ref() {
+                    __protocol.write_struct_field(10, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.b100.as_ref() {
+                    __protocol.write_struct_field(100, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.check_true.as_ref() {
+                    __protocol.write_bool_field(500, *value)?;
+                }
+                if let Some(value) = self.b1000.as_ref() {
+                    __protocol.write_struct_field(1000, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.check_false.as_ref() {
+                    __protocol.write_bool_field(1500, *value)?;
+                }
+                if let Some(value) = self.vertwo2000.as_ref() {
+                    __protocol.write_struct_field(2000, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.a_set2500.as_ref() {
+                    __protocol.write_set_field(
+                        2500,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.vertwo3000.as_ref() {
+                    __protocol.write_struct_field(3000, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.big_numbers.as_ref() {
+                    __protocol.write_list_field(
+                        4000,
+                        ::pilota::thrift::TType::I32,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_i32(*val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -20004,8 +19121,16 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut arg0 = None;
-                let mut arg1 = None;
+                let mut b1 = None;
+                let mut b10 = None;
+                let mut b100 = None;
+                let mut check_true = None;
+                let mut b1000 = None;
+                let mut check_false = None;
+                let mut vertwo2000 = None;
+                let mut a_set2500 = None;
+                let mut vertwo3000 = None;
+                let mut big_numbers = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -20022,14 +19147,74 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                arg0 = Some(__protocol.read_faststr()?);
+                                b1 = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            Some(10)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                arg1 = Some(__protocol.read_faststr()?);
+                                b10 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(100)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                b100 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(500)
+                                if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                            {
+                                check_true = Some(__protocol.read_bool()?);
+                            }
+                            Some(1000)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                b1000 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(1500)
+                                if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                            {
+                                check_false = Some(__protocol.read_bool()?);
+                            }
+                            Some(2000)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                vertwo2000 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(2500)
+                                if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                            {
+                                a_set2500 = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_faststr()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
+                            }
+                            Some(3000)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                vertwo3000 = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            Some(4000)
+                                if field_ident.field_type == ::pilota::thrift::TType::List =>
+                            {
+                                big_numbers = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<i32> = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(__protocol.read_i32()?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -20042,26 +19227,27 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `LargeDeltas` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(arg0) = arg0 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg0 is required".to_string(),
-                    ));
-                };
-                let Some(arg1) = arg1 else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field arg1 is required".to_string(),
-                    ));
+                let data = Self {
+                    b1,
+                    b10,
+                    b100,
+                    check_true,
+                    b1000,
+                    check_false,
+                    vertwo2000,
+                    a_set2500,
+                    vertwo3000,
+                    big_numbers,
                 };
-
-                let data = Self { arg0, arg1 };
                 ::std::result::Result::Ok(data)
             }
 
@@ -20076,69 +19262,109 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut arg0 = None;
-                    let mut arg1 = None;
+                    let mut b1 = None;
+                    let mut b10 = None;
+                    let mut b100 = None;
+                    let mut check_true = None;
+                    let mut b1000 = None;
+                    let mut check_false = None;
+                    let mut vertwo2000 = None;
+                    let mut a_set2500 = None;
+                    let mut vertwo3000 = None;
+                    let mut big_numbers = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    arg0 = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    arg1 = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                    loop {
+
+
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
+
+                    break;
+                } else {
+
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    b1 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(10) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    b10 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(100) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    b100 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(500) if field_ident.field_type == ::pilota::thrift::TType::Bool  => {
+                    check_true = Some(__protocol.read_bool().await?);
+
+                },Some(1000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    b1000 = Some(<Bools as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(1500) if field_ident.field_type == ::pilota::thrift::TType::Bool  => {
+                    check_false = Some(__protocol.read_bool().await?);
+
+                },Some(2000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    vertwo2000 = Some(<VersioningTestV2 as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(2500) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
+                    a_set2500 = Some({let list_ident = __protocol.read_set_begin().await?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(__protocol.read_faststr().await?);
+                    };
+                    __protocol.read_set_end().await?;
+                    val});
+
+                },Some(3000) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    vertwo3000 = Some(<VersioningTestV2 as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(4000) if field_ident.field_type == ::pilota::thrift::TType::List  => {
+                    big_numbers = Some({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push(__protocol.read_i32().await?);
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
 
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMultiExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `LargeDeltas` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
                     __protocol.read_struct_end().await?;
 
-                    let Some(arg0) = arg0 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg0 is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(arg1) = arg1 else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field arg1 is required".to_string(),
-                            ),
-                        );
+                    let data = Self {
+                        b1,
+                        b10,
+                        b100,
+                        check_true,
+                        b1000,
+                        check_false,
+                        vertwo2000,
+                        a_set2500,
+                        vertwo3000,
+                        big_numbers,
                     };
-
-                    let data = Self { arg0, arg1 };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -20147,9 +19373,55 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMultiExceptionArgsSend",
-                }) + __protocol.faststr_field_len(Some(1), &self.arg0)
-                    + __protocol.faststr_field_len(Some(2), &self.arg1)
+                    name: "LargeDeltas",
+                }) + self
+                    .b1
+                    .as_ref()
+                    .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                    + self
+                        .b10
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(10), value))
+                    + self
+                        .b100
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(100), value))
+                    + self
+                        .check_true
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bool_field_len(Some(500), *value))
+                    + self
+                        .b1000
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(1000), value))
+                    + self
+                        .check_false
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bool_field_len(Some(1500), *value))
+                    + self
+                        .vertwo2000
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(2000), value))
+                    + self.a_set2500.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(2500),
+                            ::pilota::thrift::TType::Binary,
+                            value,
+                            |__protocol, el| __protocol.faststr_len(el),
+                        )
+                    })
+                    + self
+                        .vertwo3000
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(3000), value))
+                    + self.big_numbers.as_ref().map_or(0, |value| {
+                        __protocol.list_field_len(
+                            Some(4000),
+                            ::pilota::thrift::TType::I32,
+                            value,
+                            |__protocol, el| __protocol.i32_len(*el),
+                        )
+                    })
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -20157,12 +19429,12 @@ pub mod apache {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestNestResultSend {
+        pub enum ThriftTestTestEnumResultSend {
             #[derivative(Default)]
-            Ok(Xtruct2),
+            Ok(Numberz),
         }
 
-        impl ::pilota::thrift::Message for ThriftTestTestNestResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestEnumResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -20170,11 +19442,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestResultSend",
+                    name: "ThriftTestTestEnumResultSend",
                 })?;
                 match self {
-                    ThriftTestTestNestResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    ThriftTestTestEnumResultSend::Ok(ref value) => {
+                        __protocol.write_i32_field(0, (value).inner())?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -20202,7 +19474,7 @@ pub mod apache {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(ThriftTestTestNestResultSend::Ok(field_ident));
+                                ret = Some(ThriftTestTestEnumResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -20239,177 +19511,76 @@ pub mod apache {
                         + 'a,
                 >,
             > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(ThriftTestTestNestResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestNestResultSend",
-                }) + match self {
-                    ThriftTestTestNestResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct MapType(pub ::pilota::AHashMap<::pilota::FastStr, Bonk>);
-
-        impl ::std::ops::Deref for MapType {
-            type Target = ::pilota::AHashMap<::pilota::FastStr, Bonk>;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-
-        impl From<::pilota::AHashMap<::pilota::FastStr, Bonk>> for MapType {
-            fn from(v: ::pilota::AHashMap<::pilota::FastStr, Bonk>) -> Self {
-                Self(v)
-            }
-        }
-
-        impl ::pilota::thrift::Message for MapType {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_map(
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Struct,
-                    &(&**self),
-                    |__protocol, key| {
-                        __protocol.write_faststr((key).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_struct(val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                ::std::result::Result::Ok(MapType({
-                    let map_ident = __protocol.read_map_begin()?;
-                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                    for _ in 0..map_ident.size {
-                        val.insert(
-                            __protocol.read_faststr()?,
-                            ::pilota::thrift::Message::decode(__protocol)?,
-                        );
-                    }
-                    __protocol.read_map_end()?;
-                    val
-                }))
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    ::std::result::Result::Ok(MapType({
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(
-                                __protocol.read_faststr().await?,
-                                <Bonk as ::pilota::thrift::Message>::decode_async(__protocol)
-                                    .await?,
-                            );
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
                         }
-                        __protocol.read_map_end().await?;
-                        val
-                    }))
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestEnumResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.map_len(
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Struct,
-                    &**self,
-                    |__protocol, key| __protocol.faststr_len(key),
-                    |__protocol, val| __protocol.struct_len(val),
-                )
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestEnumResultSend",
+                }) + match self {
+                    ThriftTestTestEnumResultSend::Ok(ref value) => {
+                        __protocol.i32_field_len(Some(0), (value).inner())
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
             }
         }
-        impl Default for OptionalBinary {
-            fn default() -> Self {
-                OptionalBinary {
-                    bin_map: Some({
-                        let mut map = ::pilota::AHashMap::with_capacity(0);
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct NestedMixedx2 {
+            pub int_set_list: ::std::option::Option<::std::vec::Vec<::pilota::AHashSet<i32>>>,
 
-                        map
-                    }),
-                }
-            }
-        }
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct OptionalBinary {
-            pub bin_map: ::std::option::Option<::pilota::AHashMap<::pilota::Bytes, i32>>,
+            pub map_int_strset: ::std::option::Option<
+                ::pilota::AHashMap<i32, ::pilota::AHashSet<::pilota::FastStr>>,
+            >,
+
+            pub map_int_strset_list: ::std::option::Option<
+                ::std::vec::Vec<::pilota::AHashMap<i32, ::pilota::AHashSet<::pilota::FastStr>>>,
+            >,
         }
-        impl ::pilota::thrift::Message for OptionalBinary {
+        impl ::pilota::thrift::Message for NestedMixedx2 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -20417,22 +19588,77 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "OptionalBinary",
+                    name: "NestedMixedx2",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.bin_map.as_ref() {
+                if let Some(value) = self.int_set_list.as_ref() {
+                    __protocol.write_list_field(
+                        1,
+                        ::pilota::thrift::TType::Set,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_set(
+                                ::pilota::thrift::TType::I32,
+                                &val,
+                                |__protocol, val| {
+                                    __protocol.write_i32(*val)?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.map_int_strset.as_ref() {
                     __protocol.write_map_field(
                         2,
-                        ::pilota::thrift::TType::Binary,
                         ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::Set,
                         &value,
                         |__protocol, key| {
-                            __protocol.write_bytes(key.clone())?;
+                            __protocol.write_i32(*key)?;
                             ::std::result::Result::Ok(())
                         },
                         |__protocol, val| {
-                            __protocol.write_i32(*val)?;
+                            __protocol.write_set(
+                                ::pilota::thrift::TType::Binary,
+                                &val,
+                                |__protocol, val| {
+                                    __protocol.write_faststr((val).clone())?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                if let Some(value) = self.map_int_strset_list.as_ref() {
+                    __protocol.write_list_field(
+                        3,
+                        ::pilota::thrift::TType::Map,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_map(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::Set,
+                                &val,
+                                |__protocol, key| {
+                                    __protocol.write_i32(*key)?;
+                                    ::std::result::Result::Ok(())
+                                },
+                                |__protocol, val| {
+                                    __protocol.write_set(
+                                        ::pilota::thrift::TType::Binary,
+                                        &val,
+                                        |__protocol, val| {
+                                            __protocol.write_faststr((val).clone())?;
+                                            ::std::result::Result::Ok(())
+                                        },
+                                    )?;
+                                    ::std::result::Result::Ok(())
+                                },
+                            )?;
                             ::std::result::Result::Ok(())
                         },
                     )?;
@@ -20448,7 +19674,9 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut bin_map = None;
+                let mut int_set_list = None;
+                let mut map_int_strset = None;
+                let mut map_int_strset_list = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -20464,20 +19692,84 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                int_set_list = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::pilota::AHashSet<i32>> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write({
+                                            let list_ident = __protocol.read_set_begin()?;
+                                            let mut val =
+                                                ::pilota::AHashSet::with_capacity(list_ident.size);
+                                            for _ in 0..list_ident.size {
+                                                val.insert(__protocol.read_i32()?);
+                                            }
+                                            __protocol.read_set_end()?;
+                                            val
+                                        });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
                             Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                bin_map = Some({
+                                map_int_strset = Some({
                                     let map_ident = __protocol.read_map_begin()?;
                                     let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
                                     for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_bytes()?,
-                                            __protocol.read_i32()?,
-                                        );
+                                        val.insert(__protocol.read_i32()?, {
+                                            let list_ident = __protocol.read_set_begin()?;
+                                            let mut val =
+                                                ::pilota::AHashSet::with_capacity(list_ident.size);
+                                            for _ in 0..list_ident.size {
+                                                val.insert(__protocol.read_faststr()?);
+                                            }
+                                            __protocol.read_set_end()?;
+                                            val
+                                        });
                                     }
                                     __protocol.read_map_end()?;
                                     val
                                 });
                             }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                map_int_strset_list = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<
+                                        ::pilota::AHashMap<
+                                            i32,
+                                            ::pilota::AHashSet<::pilota::FastStr>,
+                                        >,
+                                    > = Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write({
+                                            let map_ident = __protocol.read_map_begin()?;
+                                            let mut val =
+                                                ::pilota::AHashMap::with_capacity(map_ident.size);
+                                            for _ in 0..map_ident.size {
+                                                val.insert(__protocol.read_i32()?, {
+                                                    let list_ident = __protocol.read_set_begin()?;
+                                                    let mut val = ::pilota::AHashSet::with_capacity(
+                                                        list_ident.size,
+                                                    );
+                                                    for _ in 0..list_ident.size {
+                                                        val.insert(__protocol.read_faststr()?);
+                                                    }
+                                                    __protocol.read_set_end()?;
+                                                    val
+                                                });
+                                            }
+                                            __protocol.read_map_end()?;
+                                            val
+                                        });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -20490,7 +19782,7 @@ pub mod apache {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `OptionalBinary` field(#{}) failed, caused by: ",
+                            "decode struct `NestedMixedx2` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -20498,15 +19790,11 @@ pub mod apache {
                 };
                 __protocol.read_struct_end()?;
 
-                if bin_map.is_none() {
-                    bin_map = Some({
-                        let mut map = ::pilota::AHashMap::with_capacity(0);
-
-                        map
-                    });
-                }
-
-                let data = Self { bin_map };
+                let data = Self {
+                    int_set_list,
+                    map_int_strset,
+                    map_int_strset_list,
+                };
                 ::std::result::Result::Ok(data)
             }
 
@@ -20521,7 +19809,9 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut bin_map = None;
+                    let mut int_set_list = None;
+                    let mut map_int_strset = None;
+                    let mut map_int_strset_list = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -20535,23 +19825,92 @@ pub mod apache {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    int_set_list = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push({
+                                                let list_ident =
+                                                    __protocol.read_set_begin().await?;
+                                                let mut val = ::pilota::AHashSet::with_capacity(
+                                                    list_ident.size,
+                                                );
+                                                for _ in 0..list_ident.size {
+                                                    val.insert(__protocol.read_i32().await?);
+                                                }
+                                                __protocol.read_set_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
+                                }
                                 Some(2)
                                     if field_ident.field_type == ::pilota::thrift::TType::Map =>
                                 {
-                                    bin_map = Some({
+                                    map_int_strset = Some({
                                         let map_ident = __protocol.read_map_begin().await?;
                                         let mut val =
                                             ::pilota::AHashMap::with_capacity(map_ident.size);
                                         for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_bytes().await?,
-                                                __protocol.read_i32().await?,
-                                            );
+                                            val.insert(__protocol.read_i32().await?, {
+                                                let list_ident =
+                                                    __protocol.read_set_begin().await?;
+                                                let mut val = ::pilota::AHashSet::with_capacity(
+                                                    list_ident.size,
+                                                );
+                                                for _ in 0..list_ident.size {
+                                                    val.insert(__protocol.read_faststr().await?);
+                                                }
+                                                __protocol.read_set_end().await?;
+                                                val
+                                            });
                                         }
                                         __protocol.read_map_end().await?;
                                         val
                                     });
                                 }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    map_int_strset_list = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push({
+                                                let map_ident = __protocol.read_map_begin().await?;
+                                                let mut val = ::pilota::AHashMap::with_capacity(
+                                                    map_ident.size,
+                                                );
+                                                for _ in 0..map_ident.size {
+                                                    val.insert(__protocol.read_i32().await?, {
+                                                        let list_ident =
+                                                            __protocol.read_set_begin().await?;
+                                                        let mut val =
+                                                            ::pilota::AHashSet::with_capacity(
+                                                                list_ident.size,
+                                                            );
+                                                        for _ in 0..list_ident.size {
+                                                            val.insert(
+                                                                __protocol.read_faststr().await?,
+                                                            );
+                                                        }
+                                                        __protocol.read_set_end().await?;
+                                                        val
+                                                    });
+                                                }
+                                                __protocol.read_map_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
+                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -20565,7 +19924,7 @@ pub mod apache {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `OptionalBinary` field(#{}) failed, caused by: ",
+                                "decode struct `NestedMixedx2` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -20573,15 +19932,11 @@ pub mod apache {
                     };
                     __protocol.read_struct_end().await?;
 
-                    if bin_map.is_none() {
-                        bin_map = Some({
-                            let mut map = ::pilota::AHashMap::with_capacity(0);
-
-                            map
-                        });
-                    }
-
-                    let data = Self { bin_map };
+                    let data = Self {
+                        int_set_list,
+                        map_int_strset,
+                        map_int_strset_list,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -20590,43 +19945,77 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "OptionalBinary",
-                }) + self.bin_map.as_ref().map_or(0, |value| {
+                    name: "NestedMixedx2",
+                }) + self.int_set_list.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::Set,
+                        value,
+                        |__protocol, el| {
+                            __protocol.set_len(
+                                ::pilota::thrift::TType::I32,
+                                el,
+                                |__protocol, el| __protocol.i32_len(*el),
+                            )
+                        },
+                    )
+                }) + self.map_int_strset.as_ref().map_or(0, |value| {
                     __protocol.map_field_len(
                         Some(2),
-                        ::pilota::thrift::TType::Binary,
                         ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::Set,
                         value,
-                        |__protocol, key| __protocol.bytes_len(key),
-                        |__protocol, val| __protocol.i32_len(*val),
+                        |__protocol, key| __protocol.i32_len(*key),
+                        |__protocol, val| {
+                            __protocol.set_len(
+                                ::pilota::thrift::TType::Binary,
+                                val,
+                                |__protocol, el| __protocol.faststr_len(el),
+                            )
+                        },
+                    )
+                }) + self.map_int_strset_list.as_ref().map_or(0, |value| {
+                    __protocol.list_field_len(
+                        Some(3),
+                        ::pilota::thrift::TType::Map,
+                        value,
+                        |__protocol, el| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::Set,
+                                el,
+                                |__protocol, key| __protocol.i32_len(*key),
+                                |__protocol, val| {
+                                    __protocol.set_len(
+                                        ::pilota::thrift::TType::Binary,
+                                        val,
+                                        |__protocol, el| __protocol.faststr_len(el),
+                                    )
+                                },
+                            )
+                        },
                     )
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestDoubleResultSend {
-            #[derivative(Default)]
-            Ok(f64),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestByteArgsSend {
+            pub thing: i8,
         }
-
-        impl ::pilota::thrift::Message for ThriftTestTestDoubleResultSend {
+        impl ::pilota::thrift::Message for ThriftTestTestByteArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleResultSend",
-                })?;
-                match self {
-                    ThriftTestTestDoubleResultSend::Ok(ref value) => {
-                        __protocol.write_double_field(0, *value)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestByteArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_i8_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -20637,46 +20026,52 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut thing = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_double()?;
-                                __protocol.double_len(*&field_ident);
-                                ret = Some(ThriftTestTestDoubleResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                thing = Some(__protocol.read_i8()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -20690,42 +20085,54 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_double().await?;
+                    let mut thing = None;
 
-                                    ret = Some(ThriftTestTestDoubleResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    thing = Some(__protocol.read_i8().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestByteArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -20733,20 +20140,17 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestDoubleResultSend",
-                }) + match self {
-                    ThriftTestTestDoubleResultSend::Ok(ref value) => {
-                        __protocol.double_field_len(Some(0), *value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "ThriftTestTestByteArgsSend",
+                }) + __protocol.i8_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestOnewayArgsRecv {
-            pub seconds_to_sleep: i32,
+        pub struct ThriftTestTestEnumArgsRecv {
+            pub thing: Numberz,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestOnewayArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestEnumArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -20754,11 +20158,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayArgsRecv",
+                    name: "ThriftTestTestEnumArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.seconds_to_sleep)?;
+                __protocol.write_i32_field(1, (&self.thing).inner())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -20770,7 +20174,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut seconds_to_sleep = None;
+                let mut thing = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -20787,7 +20191,7 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                seconds_to_sleep = Some(__protocol.read_i32()?);
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -20800,20 +20204,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(seconds_to_sleep) = seconds_to_sleep else {
+                let Some(thing) = thing else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field seconds_to_sleep is required".to_string(),
+                        "field thing is required".to_string(),
                     ));
                 };
 
-                let data = Self { seconds_to_sleep };
+                let data = Self { thing };
                 ::std::result::Result::Ok(data)
             }
 
@@ -20828,7 +20232,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut seconds_to_sleep = None;
+                    let mut thing = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -20845,7 +20249,12 @@ pub mod apache {
                                 Some(1)
                                     if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    seconds_to_sleep = Some(__protocol.read_i32().await?);
+                                    thing = Some(
+                                        <Numberz as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -20859,22 +20268,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestOnewayArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestEnumArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(seconds_to_sleep) = seconds_to_sleep else {
+                    let Some(thing) = thing else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field seconds_to_sleep is required".to_string(),
+                                "field thing is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { seconds_to_sleep };
+                    let data = Self { thing };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -20883,34 +20292,41 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestOnewayArgsRecv",
-                }) + __protocol.i32_field_len(Some(1), *&self.seconds_to_sleep)
+                    name: "ThriftTestTestEnumArgsRecv",
+                }) + __protocol.i32_field_len(Some(1), (&self.thing).inner())
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum ThriftTestTestBoolResultSend {
-            #[derivative(Default)]
-            Ok(bool),
+        impl Default for BoolTest {
+            fn default() -> Self {
+                BoolTest {
+                    b: Some(true),
+                    s: Some(::pilota::FastStr::from_static_str("true")),
+                }
+            }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
+        pub struct BoolTest {
+            pub b: ::std::option::Option<bool>,
 
-        impl ::pilota::thrift::Message for ThriftTestTestBoolResultSend {
+            pub s: ::std::option::Option<::pilota::FastStr>,
+        }
+        impl ::pilota::thrift::Message for BoolTest {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolResultSend",
-                })?;
-                match self {
-                    ThriftTestTestBoolResultSend::Ok(ref value) => {
-                        __protocol.write_bool_field(0, *value)?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "BoolTest" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.b.as_ref() {
+                    __protocol.write_bool_field(1, *value)?;
+                }
+                if let Some(value) = self.s.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -20922,46 +20338,54 @@ pub mod apache {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut b = Some(true);
+                let mut s = Some(::pilota::FastStr::from_static_str("true"));
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_bool()?;
-                                __protocol.bool_len(*&field_ident);
-                                ret = Some(ThriftTestTestBoolResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Bool => {
+                                b = Some(__protocol.read_bool()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                s = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `BoolTest` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self { b, s };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -20975,75 +20399,84 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_bool().await?;
+                    let mut b = Some(true);
+                    let mut s = Some(::pilota::FastStr::from_static_str("true"));
 
-                                    ret = Some(ThriftTestTestBoolResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Bool =>
+                                {
+                                    b = Some(__protocol.read_bool().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    s = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `BoolTest` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self { b, s };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestBoolResultSend",
-                }) + match self {
-                    ThriftTestTestBoolResultSend::Ok(ref value) => {
-                        __protocol.bool_field_len(Some(0), *value)
-                    }
-                } + __protocol.field_stop_len()
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "BoolTest" })
+                    + self
+                        .b
+                        .as_ref()
+                        .map_or(0, |value| __protocol.bool_field_len(Some(1), *value))
+                    + self
+                        .s
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum SomeUnion {
+        pub enum ThriftTestTestTypedefResultSend {
             #[derivative(Default)]
-            MapThing(::pilota::AHashMap<Numberz, UserId>),
-
-            StringThing(::pilota::FastStr),
-
-            I32Thing(i32),
-
-            XtructThing(Xtruct3),
-
-            InsanityThing(Insanity),
+            Ok(UserId),
         }
 
-        impl ::pilota::thrift::Message for SomeUnion {
+        impl ::pilota::thrift::Message for ThriftTestTestTypedefResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -21051,36 +20484,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "SomeUnion",
+                    name: "ThriftTestTestTypedefResultSend",
                 })?;
                 match self {
-                    SomeUnion::MapThing(ref value) => {
-                        __protocol.write_map_field(
-                            1,
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I64,
-                            &value,
-                            |__protocol, key| {
-                                __protocol.write_struct(key)?;
-                                ::std::result::Result::Ok(())
-                            },
-                            |__protocol, val| {
-                                __protocol.write_struct(val)?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                    }
-                    SomeUnion::StringThing(ref value) => {
-                        __protocol.write_faststr_field(2, (value).clone())?;
-                    }
-                    SomeUnion::I32Thing(ref value) => {
-                        __protocol.write_i32_field(3, *value)?;
-                    }
-                    SomeUnion::XtructThing(ref value) => {
-                        __protocol.write_struct_field(4, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    SomeUnion::InsanityThing(ref value) => {
-                        __protocol.write_struct_field(5, value, ::pilota::thrift::TType::Struct)?;
+                    ThriftTestTestTypedefResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::I64)?;
                     }
                 }
                 __protocol.write_field_stop()?;
@@ -21104,84 +20512,11 @@ pub mod apache {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = {
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                };
-                                __protocol.map_len(
-                                    ::pilota::thrift::TType::I32,
-                                    ::pilota::thrift::TType::I64,
-                                    &field_ident,
-                                    |__protocol, key| __protocol.struct_len(key),
-                                    |__protocol, val| __protocol.struct_len(val),
-                                );
-                                ret = Some(SomeUnion::MapThing(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(2) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_faststr()?;
-                                __protocol.faststr_len(&field_ident);
-                                ret = Some(SomeUnion::StringThing(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(3) => {
-                            if ret.is_none() {
-                                let field_ident = __protocol.read_i32()?;
-                                __protocol.i32_len(*&field_ident);
-                                ret = Some(SomeUnion::I32Thing(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(4) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(SomeUnion::XtructThing(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(5) => {
+                        Some(0) => {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(SomeUnion::InsanityThing(field_ident));
+                                ret = Some(ThriftTestTestTypedefResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -21199,105 +20534,44 @@ pub mod apache {
                 __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
                 if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident = {
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    };
-
-                                    ret = Some(SomeUnion::MapThing(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(2) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_faststr().await?;
-
-                                    ret = Some(SomeUnion::StringThing(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(3) => {
-                                if ret.is_none() {
-                                    let field_ident = __protocol.read_i32().await?;
-
-                                    ret = Some(SomeUnion::I32Thing(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(4) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Xtruct3 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
 
-                                    ret = Some(SomeUnion::XtructThing(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(5) => {
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
                                 if ret.is_none() {
                                     let field_ident =
-                                        <Insanity as ::pilota::thrift::Message>::decode_async(
+                                        <UserId as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
                                         .await?;
 
-                                    ret = Some(SomeUnion::InsanityThing(field_ident));
+                                    ret = Some(ThriftTestTestTypedefResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -21326,37 +20600,210 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SomeUnion" })
-                    + match self {
-                        SomeUnion::MapThing(ref value) => __protocol.map_field_len(
-                            Some(1),
-                            ::pilota::thrift::TType::I32,
-                            ::pilota::thrift::TType::I64,
-                            value,
-                            |__protocol, key| __protocol.struct_len(key),
-                            |__protocol, val| __protocol.struct_len(val),
-                        ),
-                        SomeUnion::StringThing(ref value) => {
-                            __protocol.faststr_field_len(Some(2), value)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestTypedefResultSend",
+                }) + match self {
+                    ThriftTestTestTypedefResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        impl Default for OptionalSetDefaultTest {
+            fn default() -> Self {
+                OptionalSetDefaultTest {
+                    with_default: Some(::pilota::AHashSet::from([
+                        ::pilota::FastStr::from_static_str("test"),
+                    ])),
+                }
+            }
+        }
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct OptionalSetDefaultTest {
+            pub with_default: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
+        }
+        impl ::pilota::thrift::Message for OptionalSetDefaultTest {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "OptionalSetDefaultTest",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.with_default.as_ref() {
+                    __protocol.write_set_field(
+                        1,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut with_default = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        SomeUnion::I32Thing(ref value) => __protocol.i32_field_len(Some(3), *value),
-                        SomeUnion::XtructThing(ref value) => {
-                            __protocol.struct_field_len(Some(4), value)
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                with_default = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_faststr()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
-                        SomeUnion::InsanityThing(ref value) => {
-                            __protocol.struct_field_len(Some(5), value)
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `OptionalSetDefaultTest` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                if with_default.is_none() {
+                    with_default = Some(::pilota::AHashSet::from([
+                        ::pilota::FastStr::from_static_str("test"),
+                    ]));
+                }
+
+                let data = Self { with_default };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut with_default = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                {
+                                    with_default = Some({
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_faststr().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    + __protocol.field_stop_len()
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `OptionalSetDefaultTest` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    if with_default.is_none() {
+                        with_default = Some(::pilota::AHashSet::from([
+                            ::pilota::FastStr::from_static_str("test"),
+                        ]));
+                    }
+
+                    let data = Self { with_default };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "OptionalSetDefaultTest",
+                }) + self.with_default.as_ref().map_or(0, |value| {
+                    __protocol.set_field_len(
+                        Some(1),
+                        ::pilota::thrift::TType::Binary,
+                        value,
+                        |__protocol, el| __protocol.faststr_len(el),
+                    )
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestTypedefArgsSend {
-            pub thing: UserId,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestI32ArgsSend {
+            pub thing: i32,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestTypedefArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestI32ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -21364,11 +20811,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefArgsSend",
+                    name: "ThriftTestTestI32ArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::I64)?;
+                __protocol.write_i32_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -21396,8 +20843,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
-                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                thing = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -21410,7 +20857,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -21453,14 +20900,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    thing = Some(
-                                        <UserId as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    thing = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -21474,7 +20916,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestI32ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -21498,17 +20940,17 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestTypedefArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.thing)
+                    name: "ThriftTestTestI32ArgsSend",
+                }) + __protocol.i32_field_len(Some(1), *&self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct SecondServiceSecondtestStringArgsRecv {
-            pub thing: ::pilota::FastStr,
+        pub struct ThriftTestTestTypedefArgsRecv {
+            pub thing: UserId,
         }
-        impl ::pilota::thrift::Message for SecondServiceSecondtestStringArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestTypedefArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -21516,11 +20958,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringArgsRecv",
+                    name: "ThriftTestTestTypedefArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.thing).clone())?;
+                __protocol.write_struct_field(1, &self.thing, ::pilota::thrift::TType::I64)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -21548,10 +20990,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                thing = Some(__protocol.read_faststr()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                thing = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -21564,21 +21004,232 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(thing) = thing else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field thing is required".to_string(),
+                    ));
+                };
+
+                let data = Self { thing };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut thing = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
+                                {
+                                    thing = Some(
+                                        <UserId as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestTypedefArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(thing) = thing else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field thing is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { thing };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestTypedefArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.thing)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMapMapResultSend {
+            #[derivative(Default)]
+            Ok(::pilota::AHashMap<i32, ::pilota::AHashMap<i32, i32>>),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestMapMapResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapMapResultSend",
+                })?;
+                match self {
+                    ThriftTestTestMapMapResultSend::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I32,
+                            ::pilota::thrift::TType::Map,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_i32(*key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_map(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::I32,
+                                    &val,
+                                    |__protocol, key| {
+                                        __protocol.write_i32(*key)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                    |__protocol, val| {
+                                        __protocol.write_i32(*val)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(__protocol.read_i32()?, {
+                                            let map_ident = __protocol.read_map_begin()?;
+                                            let mut val =
+                                                ::pilota::AHashMap::with_capacity(map_ident.size);
+                                            for _ in 0..map_ident.size {
+                                                val.insert(
+                                                    __protocol.read_i32()?,
+                                                    __protocol.read_i32()?,
+                                                );
+                                            }
+                                            __protocol.read_map_end()?;
+                                            val
+                                        });
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::Map,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.i32_len(*key),
+                                    |__protocol, val| {
+                                        __protocol.map_len(
+                                            ::pilota::thrift::TType::I32,
+                                            ::pilota::thrift::TType::I32,
+                                            val,
+                                            |__protocol, key| __protocol.i32_len(*key),
+                                            |__protocol, val| __protocol.i32_len(*val),
+                                        )
+                                    },
+                                );
+                                ret = Some(ThriftTestTestMapMapResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(thing) = thing else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field thing is required".to_string(),
-                    ));
-                };
-
-                let data = Self { thing };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -21592,55 +21243,64 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut thing = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    thing = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(__protocol.read_i32().await?, {
+                                                let map_ident = __protocol.read_map_begin().await?;
+                                                let mut val = ::pilota::AHashMap::with_capacity(
+                                                    map_ident.size,
+                                                );
+                                                for _ in 0..map_ident.size {
+                                                    val.insert(
+                                                        __protocol.read_i32().await?,
+                                                        __protocol.read_i32().await?,
+                                                    );
+                                                }
+                                                __protocol.read_map_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
+
+                                    ret = Some(ThriftTestTestMapMapResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `SecondServiceSecondtestStringArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(thing) = thing else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field thing is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { thing };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -21648,17 +21308,33 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "SecondServiceSecondtestStringArgsRecv",
-                }) + __protocol.faststr_field_len(Some(1), &self.thing)
-                    + __protocol.field_stop_len()
+                    name: "ThriftTestTestMapMapResultSend",
+                }) + match self {
+                    ThriftTestTestMapMapResultSend::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I32,
+                        ::pilota::thrift::TType::Map,
+                        value,
+                        |__protocol, key| __protocol.i32_len(*key),
+                        |__protocol, val| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::I32,
+                                val,
+                                |__protocol, key| __protocol.i32_len(*key),
+                                |__protocol, val| __protocol.i32_len(*val),
+                            )
+                        },
+                    ),
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestStringMapArgsSend {
-            pub thing: ::pilota::AHashMap<::pilota::FastStr, ::pilota::FastStr>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestI64ArgsSend {
+            pub thing: i64,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestStringMapArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestI64ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -21666,24 +21342,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapArgsSend",
+                    name: "ThriftTestTestI64ArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_map_field(
-                    1,
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Binary,
-                    &&self.thing,
-                    |__protocol, key| {
-                        __protocol.write_faststr((key).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_faststr((val).clone())?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_i64_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -21711,19 +21374,8 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                thing = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            __protocol.read_faststr()?,
-                                            __protocol.read_faststr()?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I64 => {
+                                thing = Some(__protocol.read_i64()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -21736,7 +21388,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -21779,21 +21431,9 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Map =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I64 =>
                                 {
-                                    thing = Some({
-                                        let map_ident = __protocol.read_map_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashMap::with_capacity(map_ident.size);
-                                        for _ in 0..map_ident.size {
-                                            val.insert(
-                                                __protocol.read_faststr().await?,
-                                                __protocol.read_faststr().await?,
-                                            );
-                                        }
-                                        __protocol.read_map_end().await?;
-                                        val
-                                    });
+                                    thing = Some(__protocol.read_i64().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -21807,7 +21447,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestStringMapArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestI64ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -21831,40 +21471,29 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestStringMapArgsSend",
-                }) + __protocol.map_field_len(
-                    Some(1),
-                    ::pilota::thrift::TType::Binary,
-                    ::pilota::thrift::TType::Binary,
-                    &self.thing,
-                    |__protocol, key| __protocol.faststr_len(key),
-                    |__protocol, val| __protocol.faststr_len(val),
-                ) + __protocol.field_stop_len()
+                    name: "ThriftTestTestI64ArgsSend",
+                }) + __protocol.i64_field_len(Some(1), *&self.thing)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Xception2 {
-            pub error_code: ::std::option::Option<i32>,
-
-            pub struct_thing: ::std::option::Option<Xtruct>,
+        pub struct ThriftTestTestMapMapArgsRecv {
+            pub hello: i32,
         }
-        impl ::pilota::thrift::Message for Xception2 {
+        impl ::pilota::thrift::Message for ThriftTestTestMapMapArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Xception2" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapMapArgsRecv",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.error_code.as_ref() {
-                    __protocol.write_i32_field(1, *value)?;
-                }
-                if let Some(value) = self.struct_thing.as_ref() {
-                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                }
+                __protocol.write_i32_field(1, *&self.hello)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -21876,8 +21505,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut error_code = None;
-                let mut struct_thing = None;
+                let mut hello = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -21894,12 +21522,7 @@ pub mod apache {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                error_code = Some(__protocol.read_i32()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                struct_thing = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                hello = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -21912,19 +21535,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Xception2` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    error_code,
-                    struct_thing,
+                let Some(hello) = hello else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field hello is required".to_string(),
+                    ));
                 };
+
+                let data = Self { hello };
                 ::std::result::Result::Ok(data)
             }
 
@@ -21939,8 +21563,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut error_code = None;
-                    let mut struct_thing = None;
+                    let mut hello = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -21957,18 +21580,7 @@ pub mod apache {
                                 Some(1)
                                     if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    error_code = Some(__protocol.read_i32().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    struct_thing = Some(
-                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    hello = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -21982,19 +21594,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Xception2` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        error_code,
-                        struct_thing,
+                    let Some(hello) = hello else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field hello is required".to_string(),
+                            ),
+                        );
                     };
+
+                    let data = Self { hello };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -22002,25 +21617,253 @@ pub mod apache {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Xception2" })
-                    + self
-                        .error_code
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
-                    + self
-                        .struct_thing
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMapMapArgsRecv",
+                }) + __protocol.i32_field_len(Some(1), *&self.hello)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestUuidArgsSend {
-            pub thing: [u8; 16],
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestInsanityResultSend {
+            #[derivative(Default)]
+            Ok(::pilota::AHashMap<UserId, ::pilota::AHashMap<Numberz, Insanity>>),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestInsanityResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestInsanityResultSend",
+                })?;
+                match self {
+                    ThriftTestTestInsanityResultSend::Ok(ref value) => {
+                        __protocol.write_map_field(
+                            0,
+                            ::pilota::thrift::TType::I64,
+                            ::pilota::thrift::TType::Map,
+                            &value,
+                            |__protocol, key| {
+                                __protocol.write_struct(key)?;
+                                ::std::result::Result::Ok(())
+                            },
+                            |__protocol, val| {
+                                __protocol.write_map(
+                                    ::pilota::thrift::TType::I32,
+                                    ::pilota::thrift::TType::Struct,
+                                    &val,
+                                    |__protocol, key| {
+                                        __protocol.write_struct(key)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                    |__protocol, val| {
+                                        __protocol.write_struct(val)?;
+                                        ::std::result::Result::Ok(())
+                                    },
+                                )?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = {
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                            {
+                                                let map_ident = __protocol.read_map_begin()?;
+                                                let mut val = ::pilota::AHashMap::with_capacity(
+                                                    map_ident.size,
+                                                );
+                                                for _ in 0..map_ident.size {
+                                                    val.insert(
+                                                        ::pilota::thrift::Message::decode(
+                                                            __protocol,
+                                                        )?,
+                                                        ::pilota::thrift::Message::decode(
+                                                            __protocol,
+                                                        )?,
+                                                    );
+                                                }
+                                                __protocol.read_map_end()?;
+                                                val
+                                            },
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                };
+                                __protocol.map_len(
+                                    ::pilota::thrift::TType::I64,
+                                    ::pilota::thrift::TType::Map,
+                                    &field_ident,
+                                    |__protocol, key| __protocol.struct_len(key),
+                                    |__protocol, val| {
+                                        __protocol.map_len(
+                                            ::pilota::thrift::TType::I32,
+                                            ::pilota::thrift::TType::Struct,
+                                            val,
+                                            |__protocol, key| __protocol.struct_len(key),
+                                            |__protocol, val| __protocol.struct_len(val),
+                                        )
+                                    },
+                                );
+                                ret = Some(ThriftTestTestInsanityResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = {
+                                        let map_ident = __protocol.read_map_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashMap::with_capacity(map_ident.size);
+                                        for _ in 0..map_ident.size {
+                                            val.insert(<UserId as ::pilota::thrift::Message>::decode_async(__protocol).await?, {
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(<Numberz as ::pilota::thrift::Message>::decode_async(__protocol).await?, <Insanity as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                        }
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+                                        }
+                                        __protocol.read_map_end().await?;
+                                        val
+                                    };
+
+                                    ret = Some(ThriftTestTestInsanityResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestInsanityResultSend",
+                }) + match self {
+                    ThriftTestTestInsanityResultSend::Ok(ref value) => __protocol.map_field_len(
+                        Some(0),
+                        ::pilota::thrift::TType::I64,
+                        ::pilota::thrift::TType::Map,
+                        value,
+                        |__protocol, key| __protocol.struct_len(key),
+                        |__protocol, val| {
+                            __protocol.map_len(
+                                ::pilota::thrift::TType::I32,
+                                ::pilota::thrift::TType::Struct,
+                                val,
+                                |__protocol, key| __protocol.struct_len(key),
+                                |__protocol, val| __protocol.struct_len(val),
+                            )
+                        },
+                    ),
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestDoubleArgsSend {
+            pub thing: f64,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestUuidArgsSend {
+        impl ::pilota::thrift::Message for ThriftTestTestDoubleArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -22028,11 +21871,11 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidArgsSend",
+                    name: "ThriftTestTestDoubleArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_uuid_field(1, *&self.thing)?;
+                __protocol.write_double_field(1, *&self.thing)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -22060,8 +21903,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
-                                thing = Some(__protocol.read_uuid()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Double =>
+                            {
+                                thing = Some(__protocol.read_double()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -22074,7 +21919,7 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -22117,9 +21962,10 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Uuid =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Double =>
                                 {
-                                    thing = Some(__protocol.read_uuid().await?);
+                                    thing = Some(__protocol.read_double().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -22133,7 +21979,7 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestUuidArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestDoubleArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -22157,17 +22003,17 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestUuidArgsSend",
-                }) + __protocol.uuid_field_len(Some(1), *&self.thing)
+                    name: "ThriftTestTestDoubleArgsSend",
+                }) + __protocol.double_field_len(Some(1), *&self.thing)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct ThriftTestTestMapMapArgsRecv {
-            pub hello: i32,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ThriftTestTestInsanityArgsRecv {
+            pub argument: Insanity,
         }
-        impl ::pilota::thrift::Message for ThriftTestTestMapMapArgsRecv {
+        impl ::pilota::thrift::Message for ThriftTestTestInsanityArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -22175,11 +22021,15 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapArgsRecv",
+                    name: "ThriftTestTestInsanityArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_i32_field(1, *&self.hello)?;
+                __protocol.write_struct_field(
+                    1,
+                    &self.argument,
+                    ::pilota::thrift::TType::Struct,
+                )?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -22191,7 +22041,7 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut hello = None;
+                let mut argument = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -22207,8 +22057,10 @@ pub mod apache {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                hello = Some(__protocol.read_i32()?);
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                argument = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -22221,20 +22073,20 @@ pub mod apache {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(hello) = hello else {
+                let Some(argument) = argument else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field hello is required".to_string(),
+                        "field argument is required".to_string(),
                     ));
                 };
 
-                let data = Self { hello };
+                let data = Self { argument };
                 ::std::result::Result::Ok(data)
             }
 
@@ -22249,7 +22101,7 @@ pub mod apache {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut hello = None;
+                    let mut argument = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -22264,9 +22116,15 @@ pub mod apache {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    hello = Some(__protocol.read_i32().await?);
+                                    argument = Some(
+                                        <Insanity as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -22280,22 +22138,22 @@ pub mod apache {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `ThriftTestTestMapMapArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `ThriftTestTestInsanityArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(hello) = hello else {
+                    let Some(argument) = argument else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field hello is required".to_string(),
+                                "field argument is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { hello };
+                    let data = Self { argument };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -22304,11 +22162,153 @@ pub mod apache {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "ThriftTestTestMapMapArgsRecv",
-                }) + __protocol.i32_field_len(Some(1), *&self.hello)
+                    name: "ThriftTestTestInsanityArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.argument)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum ThriftTestTestMultiResultSend {
+            #[derivative(Default)]
+            Ok(Xtruct),
+        }
+
+        impl ::pilota::thrift::Message for ThriftTestTestMultiResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMultiResultSend",
+                })?;
+                match self {
+                    ThriftTestTestMultiResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(ThriftTestTestMultiResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Xtruct as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(ThriftTestTestMultiResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "ThriftTestTestMultiResultSend",
+                }) + match self {
+                    ThriftTestTestMultiResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
     }
 }
diff --git a/pilota-build/test_data/thrift/auto_name.rs b/pilota-build/test_data/thrift/auto_name.rs
index 939af74a..b2bb986f 100644
--- a/pilota-build/test_data/thrift/auto_name.rs
+++ b/pilota-build/test_data/thrift/auto_name.rs
@@ -156,29 +156,23 @@ pub mod auto_name {
             }
         }
         pub trait TestService {}
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultRecv {
-            #[derivative(Default)]
-            Ok(Test),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct TestServicetestArgsSend {
+            pub req: TEST,
         }
-
-        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
+        impl ::pilota::thrift::Message for TestServicetestArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
-                })?;
-                match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestServicetestArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -189,188 +183,54 @@ pub mod auto_name {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
 
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
+                let mut req = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
-                        let field_ident = __protocol.read_field_begin().await?;
+                        let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
                             break;
                         } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
+                        __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Test as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
-                }) + match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestServicetestResultRecv {
-            #[derivative(Default)]
-            Ok(Test),
-        }
-
-        impl ::pilota::thrift::Message for TestServicetestResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestResultRecv",
-                })?;
-                match self {
-                    TestServicetestResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestServicetestResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `TestServicetestArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
-                }
-                __protocol.read_field_end()?;
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(req) = req else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field req is required".to_string(),
+                    ));
+                };
+
+                let data = Self { req };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -384,171 +244,91 @@ pub mod auto_name {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut req = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Test as ::pilota::thrift::Message>::decode_async(
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    req = Some(
+                                        <TEST as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
-                                        .await?;
-
-                                    ret = Some(TestServicetestResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `TestServicetestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestResultRecv",
-                }) + match self {
-                    TestServicetestResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct Index(i32);
 
-        impl Index {
-            pub const A: Self = Self(0);
-            pub const a: Self = Self(1);
-
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(0) => ::std::string::String::from("A"),
-                    Self(1) => ::std::string::String::from("a"),
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
-
-        impl ::std::convert::From<i32> for Index {
-            fn from(value: i32) -> Self {
-                Self(value)
-            }
-        }
-
-        impl ::std::convert::From<Index> for i32 {
-            fn from(value: Index) -> i32 {
-                value.0
-            }
-        }
-
-        impl ::pilota::thrift::Message for Index {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(self.inner())?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let value = __protocol.read_i32()?;
-                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                    |err| {
-                        ::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for Index, value: {}", value),
-                        )
-                    },
-                )?)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let value = __protocol.read_i32().await?;
-                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                        |err| {
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for Index, value: {}", value),
-                            )
-                        },
-                    )?)
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(self.inner())
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServicetestArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
             }
         }
-        pub const ip: &'static str = "ip";
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestServiceTestArgsSend {
-            pub req: TEST,
+        pub struct Test {
+            pub ID: ::pilota::FastStr,
+
+            pub Id: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
+        impl ::pilota::thrift::Message for Test {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Test" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_faststr_field(1, (&self.ID).clone())?;
+                __protocol.write_faststr_field(2, (&self.Id).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -560,7 +340,8 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut req = None;
+                let mut ID = None;
+                let mut Id = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -577,9 +358,14 @@ pub mod auto_name {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                ID = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                Id = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -592,20 +378,29 @@ pub mod auto_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `Test` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(req) = req else {
+                let Some(ID) = ID else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
+                        "field ID is required".to_string(),
+                    ));
+                };
+                let Some(Id) = Id else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field Id is required".to_string(),
                     ));
                 };
 
-                let data = Self { req };
+                let data = Self { ID, Id };
                 ::std::result::Result::Ok(data)
             }
 
@@ -620,7 +415,8 @@ pub mod auto_name {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut req = None;
+                    let mut ID = None;
+                    let mut Id = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -636,14 +432,15 @@ pub mod auto_name {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    req = Some(
-                                        <TEST as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    ID = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    Id = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -657,22 +454,33 @@ pub mod auto_name {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `Test` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(req) = req else {
+                    let Some(ID) = ID else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
+                                "field ID is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(Id) = Id else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field Id is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { req };
+                    let data = Self { ID, Id };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -680,18 +488,18 @@ pub mod auto_name {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Test" })
+                    + __protocol.faststr_field_len(Some(1), &self.ID)
+                    + __protocol.faststr_field_len(Some(2), &self.Id)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestServicetestArgsSend {
+        pub struct TestServiceTestArgsSend {
             pub req: TEST,
         }
-        impl ::pilota::thrift::Message for TestServicetestArgsSend {
+        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -699,7 +507,7 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestArgsSend",
+                    name: "TestServiceTestArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -747,7 +555,7 @@ pub mod auto_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServicetestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -812,23 +620,162 @@ pub mod auto_name {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServicetestArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
-
-                    let Some(req) = req else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { req };
-                    ::std::result::Result::Ok(data)
+
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestServicetestResultSend {
+            #[derivative(Default)]
+            Ok(Test),
+        }
+
+        impl ::pilota::thrift::Message for TestServicetestResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServicetestResultSend",
+                })?;
+                match self {
+                    TestServicetestResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestServicetestResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Test as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestServicetestResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -836,18 +783,21 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
+                    name: "TestServicetestResultSend",
+                }) + match self {
+                    TestServicetestResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        pub const IP: &'static str = "IP";
+        pub const ip: &'static str = "ip";
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestServiceTestArgsRecv {
+        pub struct TestServicetestArgsRecv {
             pub req: TEST,
         }
-        impl ::pilota::thrift::Message for TestServiceTestArgsRecv {
+        impl ::pilota::thrift::Message for TestServicetestArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -855,7 +805,7 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsRecv",
+                    name: "TestServicetestArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -903,7 +853,7 @@ pub mod auto_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `TestServicetestArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -968,7 +918,7 @@ pub mod auto_name {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestServicetestArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -992,21 +942,254 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsRecv",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
+                    name: "TestServicetestArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct Index(i32);
+
+        impl Index {
+            pub const A: Self = Self(0);
+            pub const a: Self = Self(1);
+
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(0) => ::std::string::String::from("A"),
+                    Self(1) => ::std::string::String::from("a"),
+                    Self(val) => val.to_string(),
+                }
+            }
+        }
+
+        impl ::std::convert::From<i32> for Index {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
+
+        impl ::std::convert::From<Index> for i32 {
+            fn from(value: Index) -> i32 {
+                value.0
+            }
+        }
+
+        impl ::pilota::thrift::Message for Index {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i32(self.inner())?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let value = __protocol.read_i32()?;
+                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                    |err| {
+                        ::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            format!("invalid enum value for Index, value: {}", value),
+                        )
+                    },
+                )?)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let value = __protocol.read_i32().await?;
+                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                        |err| {
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                format!("invalid enum value for Index, value: {}", value),
+                            )
+                        },
+                    )?)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.i32_len(self.inner())
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestServiceTestResultSend {
+            #[derivative(Default)]
+            Ok(Test),
+        }
+
+        impl ::pilota::thrift::Message for TestServiceTestResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestResultSend",
+                })?;
+                match self {
+                    TestServiceTestResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Test as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestResultSend",
+                }) + match self {
+                    TestServiceTestResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultSend {
+        pub enum TestServicetestResultRecv {
             #[derivative(Default)]
             Ok(Test),
         }
 
-        impl ::pilota::thrift::Message for TestServiceTestResultSend {
+        impl ::pilota::thrift::Message for TestServicetestResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1014,10 +1197,10 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
+                    name: "TestServicetestResultRecv",
                 })?;
                 match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
+                    TestServicetestResultRecv::Ok(ref value) => {
                         __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
@@ -1046,7 +1229,7 @@ pub mod auto_name {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                ret = Some(TestServicetestResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -1101,7 +1284,7 @@ pub mod auto_name {
                                         )
                                         .await?;
 
-                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                    ret = Some(TestServicetestResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -1131,9 +1314,9 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
+                    name: "TestServicetestResultRecv",
                 }) + match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
+                    TestServicetestResultRecv::Ok(ref value) => {
                         __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
@@ -1141,10 +1324,10 @@ pub mod auto_name {
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestServicetestArgsRecv {
+        pub struct TestServiceTestArgsRecv {
             pub req: TEST,
         }
-        impl ::pilota::thrift::Message for TestServicetestArgsRecv {
+        impl ::pilota::thrift::Message for TestServiceTestArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1152,7 +1335,7 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestArgsRecv",
+                    name: "TestServiceTestArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -1200,7 +1383,7 @@ pub mod auto_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServicetestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -1265,7 +1448,7 @@ pub mod auto_name {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServicetestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -1289,21 +1472,22 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestArgsRecv",
+                    name: "TestServiceTestArgsRecv",
                 }) + __protocol.struct_field_len(Some(1), &self.req)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        pub const IP: &'static str = "IP";
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestServicetestResultSend {
+        pub enum TestServiceTestResultRecv {
             #[derivative(Default)]
             Ok(Test),
         }
 
-        impl ::pilota::thrift::Message for TestServicetestResultSend {
+        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1311,10 +1495,10 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestResultSend",
+                    name: "TestServiceTestResultRecv",
                 })?;
                 match self {
-                    TestServicetestResultSend::Ok(ref value) => {
+                    TestServiceTestResultRecv::Ok(ref value) => {
                         __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
@@ -1343,7 +1527,7 @@ pub mod auto_name {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(TestServicetestResultSend::Ok(field_ident));
+                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -1398,7 +1582,7 @@ pub mod auto_name {
                                         )
                                         .await?;
 
-                                    ret = Some(TestServicetestResultSend::Ok(field_ident));
+                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -1428,198 +1612,14 @@ pub mod auto_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServicetestResultSend",
+                    name: "TestServiceTestResultRecv",
                 }) + match self {
-                    TestServicetestResultSend::Ok(ref value) => {
+                    TestServiceTestResultRecv::Ok(ref value) => {
                         __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Test {
-            pub ID: ::pilota::FastStr,
-
-            pub Id: ::pilota::FastStr,
-        }
-        impl ::pilota::thrift::Message for Test {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Test" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.ID).clone())?;
-                __protocol.write_faststr_field(2, (&self.Id).clone())?;
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut ID = None;
-                let mut Id = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                ID = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                Id = Some(__protocol.read_faststr()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Test` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let Some(ID) = ID else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field ID is required".to_string(),
-                    ));
-                };
-                let Some(Id) = Id else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field Id is required".to_string(),
-                    ));
-                };
-
-                let data = Self { ID, Id };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ID = None;
-                    let mut Id = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    ID = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    Id = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Test` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(ID) = ID else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field ID is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(Id) = Id else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field Id is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { ID, Id };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Test" })
-                    + __protocol.faststr_field_len(Some(1), &self.ID)
-                    + __protocol.faststr_field_len(Some(2), &self.Id)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
     }
 }
diff --git a/pilota-build/test_data/thrift/const_val.rs b/pilota-build/test_data/thrift/const_val.rs
index aff6bf27..25da2643 100644
--- a/pilota-build/test_data/thrift/const_val.rs
+++ b/pilota-build/test_data/thrift/const_val.rs
@@ -94,19 +94,20 @@ pub mod const_val {
             }
         }
         ::pilota::lazy_static::lazy_static! {
-            pub static ref TEST_MAP_LIST: ::pilota::AHashMap<i32, ::std::vec::Vec<&'static str>> = {
-            let mut map = ::pilota::AHashMap::with_capacity(1);
-            map.insert(1i32, ::std::vec!["hello"]);
+            pub static ref TEST_MAP: ::pilota::AHashMap<Index, &'static str> = {
+            let mut map = ::pilota::AHashMap::with_capacity(2);
+            map.insert(Index::A, "hello");map.insert(Index::B, "world");
             map
         };
         }
-        pub const TEST_LIST: [&'static str; 2] = ["hello", "world"];
+
         ::pilota::lazy_static::lazy_static! {
-            pub static ref TEST_MAP: ::pilota::AHashMap<Index, &'static str> = {
-            let mut map = ::pilota::AHashMap::with_capacity(2);
-            map.insert(Index::A, "hello");map.insert(Index::B, "world");
+            pub static ref TEST_MAP_LIST: ::pilota::AHashMap<i32, ::std::vec::Vec<&'static str>> = {
+            let mut map = ::pilota::AHashMap::with_capacity(1);
+            map.insert(1i32, ::std::vec!["hello"]);
             map
         };
         }
+        pub const TEST_LIST: [&'static str; 2] = ["hello", "world"];
     }
 }
diff --git a/pilota-build/test_data/thrift/decode_error.rs b/pilota-build/test_data/thrift/decode_error.rs
index f986a90b..a0088547 100644
--- a/pilota-build/test_data/thrift/decode_error.rs
+++ b/pilota-build/test_data/thrift/decode_error.rs
@@ -159,20 +159,20 @@ pub mod decode_error {
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct C {
-            pub a: ::pilota::FastStr,
+        pub struct B {
+            pub c: C,
         }
-        impl ::pilota::thrift::Message for C {
+        impl ::pilota::thrift::Message for B {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(3, (&self.a).clone())?;
+                __protocol.write_struct_field(2, &self.c, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -184,7 +184,7 @@ pub mod decode_error {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut a = None;
+                let mut c = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -200,10 +200,10 @@ pub mod decode_error {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(3)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                a = Some(__protocol.read_faststr()?);
+                                c = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -217,7 +217,7 @@ pub mod decode_error {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `C` field(#{}) failed, caused by: ",
+                            "decode struct `B` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -225,14 +225,14 @@ pub mod decode_error {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(a) = a else {
+                let Some(c) = c else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field a is required".to_string(),
+                        "field c is required".to_string(),
                     ));
                 };
 
-                let data = Self { a };
+                let data = Self { c };
                 ::std::result::Result::Ok(data)
             }
 
@@ -247,7 +247,7 @@ pub mod decode_error {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut a = None;
+                    let mut c = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -261,11 +261,14 @@ pub mod decode_error {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(3)
+                                Some(2)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    a = Some(__protocol.read_faststr().await?);
+                                    c = Some(
+                                        <C as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -280,7 +283,7 @@ pub mod decode_error {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `C` field(#{}) failed, caused by: ",
+                                "decode struct `B` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -288,16 +291,16 @@ pub mod decode_error {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(a) = a else {
+                    let Some(c) = c else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field a is required".to_string(),
+                                "field c is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { a };
+                    let data = Self { c };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -305,27 +308,27 @@ pub mod decode_error {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
-                    + __protocol.faststr_field_len(Some(3), &self.a)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
+                    + __protocol.struct_field_len(Some(2), &self.c)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct B {
-            pub c: C,
+        pub struct C {
+            pub a: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for B {
+        impl ::pilota::thrift::Message for C {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(2, &self.c, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_faststr_field(3, (&self.a).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -337,7 +340,7 @@ pub mod decode_error {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut c = None;
+                let mut a = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -353,10 +356,10 @@ pub mod decode_error {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            Some(3)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                c = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                a = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -370,7 +373,7 @@ pub mod decode_error {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `B` field(#{}) failed, caused by: ",
+                            "decode struct `C` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -378,14 +381,14 @@ pub mod decode_error {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(c) = c else {
+                let Some(a) = a else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field c is required".to_string(),
+                        "field a is required".to_string(),
                     ));
                 };
 
-                let data = Self { c };
+                let data = Self { a };
                 ::std::result::Result::Ok(data)
             }
 
@@ -400,7 +403,7 @@ pub mod decode_error {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut c = None;
+                    let mut a = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -414,14 +417,11 @@ pub mod decode_error {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(2)
+                                Some(3)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    c = Some(
-                                        <C as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?,
-                                    );
+                                    a = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -436,7 +436,7 @@ pub mod decode_error {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `B` field(#{}) failed, caused by: ",
+                                "decode struct `C` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -444,16 +444,16 @@ pub mod decode_error {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(c) = c else {
+                    let Some(a) = a else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field c is required".to_string(),
+                                "field a is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { c };
+                    let data = Self { a };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -461,8 +461,8 @@ pub mod decode_error {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
-                    + __protocol.struct_field_len(Some(2), &self.c)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+                    + __protocol.faststr_field_len(Some(3), &self.a)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
diff --git a/pilota-build/test_data/thrift/default_value.rs b/pilota-build/test_data/thrift/default_value.rs
index 56b5c020..5d2c2b0c 100644
--- a/pilota-build/test_data/thrift/default_value.rs
+++ b/pilota-build/test_data/thrift/default_value.rs
@@ -93,6 +93,7 @@ pub mod default_value {
                 __protocol.i32_len(self.inner())
             }
         }
+        pub const A_S: &'static str = "string";
         impl Default for C {
             fn default() -> Self {
                 C {
@@ -846,6 +847,5 @@ pub mod default_value {
                     + __protocol.struct_end_len()
             }
         }
-        pub const A_S: &'static str = "string";
     }
 }
diff --git a/pilota-build/test_data/thrift/enum_test.rs b/pilota-build/test_data/thrift/enum_test.rs
index 99376989..d5692a6d 100644
--- a/pilota-build/test_data/thrift/enum_test.rs
+++ b/pilota-build/test_data/thrift/enum_test.rs
@@ -97,12 +97,12 @@ pub mod enum_test {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestTestEnumResultRecv {
+        pub enum TestTestEnumResultSend {
             #[derivative(Default)]
             Ok(Err),
         }
 
-        impl ::pilota::thrift::Message for TestTestEnumResultRecv {
+        impl ::pilota::thrift::Message for TestTestEnumResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -110,10 +110,10 @@ pub mod enum_test {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestEnumResultRecv",
+                    name: "TestTestEnumResultSend",
                 })?;
                 match self {
-                    TestTestEnumResultRecv::Ok(ref value) => {
+                    TestTestEnumResultSend::Ok(ref value) => {
                         __protocol.write_i32_field(0, (value).inner())?;
                     }
                 }
@@ -142,7 +142,7 @@ pub mod enum_test {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestEnumResultRecv::Ok(field_ident));
+                                ret = Some(TestTestEnumResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -197,7 +197,7 @@ pub mod enum_test {
                                         )
                                         .await?;
 
-                                    ret = Some(TestTestEnumResultRecv::Ok(field_ident));
+                                    ret = Some(TestTestEnumResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -227,15 +227,99 @@ pub mod enum_test {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestEnumResultRecv",
+                    name: "TestTestEnumResultSend",
                 }) + match self {
-                    TestTestEnumResultRecv::Ok(ref value) => {
+                    TestTestEnumResultSend::Ok(ref value) => {
                         __protocol.i32_field_len(Some(0), (value).inner())
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct Err(i32);
+
+        impl Err {
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(val) => val.to_string(),
+                }
+            }
+        }
+
+        impl ::std::convert::From<i32> for Err {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
+
+        impl ::std::convert::From<Err> for i32 {
+            fn from(value: Err) -> i32 {
+                value.0
+            }
+        }
+
+        impl ::pilota::thrift::Message for Err {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i32(self.inner())?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let value = __protocol.read_i32()?;
+                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                    |err| {
+                        ::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            format!("invalid enum value for Err, value: {}", value),
+                        )
+                    },
+                )?)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let value = __protocol.read_i32().await?;
+                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                        |err| {
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                format!("invalid enum value for Err, value: {}", value),
+                            )
+                        },
+                    )?)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.i32_len(self.inner())
+            }
+        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
         pub struct TestTestEnumArgsRecv {
             pub req: Ok,
@@ -389,232 +473,6 @@ pub mod enum_test {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestTestEnumResultSend {
-            #[derivative(Default)]
-            Ok(Err),
-        }
-
-        impl ::pilota::thrift::Message for TestTestEnumResultSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestEnumResultSend",
-                })?;
-                match self {
-                    TestTestEnumResultSend::Ok(ref value) => {
-                        __protocol.write_i32_field(0, (value).inner())?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestEnumResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Err as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(TestTestEnumResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestEnumResultSend",
-                }) + match self {
-                    TestTestEnumResultSend::Ok(ref value) => {
-                        __protocol.i32_field_len(Some(0), (value).inner())
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct Ok(i32);
-
-        impl Ok {
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
-
-        impl ::std::convert::From<i32> for Ok {
-            fn from(value: i32) -> Self {
-                Self(value)
-            }
-        }
-
-        impl ::std::convert::From<Ok> for i32 {
-            fn from(value: Ok) -> i32 {
-                value.0
-            }
-        }
-
-        impl ::pilota::thrift::Message for Ok {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(self.inner())?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let value = __protocol.read_i32()?;
-                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                    |err| {
-                        ::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for Ok, value: {}", value),
-                        )
-                    },
-                )?)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let value = __protocol.read_i32().await?;
-                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                        |err| {
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for Ok, value: {}", value),
-                            )
-                        },
-                    )?)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(self.inner())
-            }
-        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
         pub struct TestTestEnumArgsSend {
             pub req: Ok,
@@ -768,11 +626,153 @@ pub mod enum_test {
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestTestEnumResultRecv {
+            #[derivative(Default)]
+            Ok(Err),
+        }
+
+        impl ::pilota::thrift::Message for TestTestEnumResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestEnumResultRecv",
+                })?;
+                match self {
+                    TestTestEnumResultRecv::Ok(ref value) => {
+                        __protocol.write_i32_field(0, (value).inner())?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestEnumResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Err as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestTestEnumResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestEnumResultRecv",
+                }) + match self {
+                    TestTestEnumResultRecv::Ok(ref value) => {
+                        __protocol.i32_field_len(Some(0), (value).inner())
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq, Copy)]
         #[repr(transparent)]
-        pub struct Err(i32);
+        pub struct Ok(i32);
 
-        impl Err {
+        impl Ok {
             pub fn inner(&self) -> i32 {
                 self.0
             }
@@ -784,19 +784,19 @@ pub mod enum_test {
             }
         }
 
-        impl ::std::convert::From<i32> for Err {
+        impl ::std::convert::From<i32> for Ok {
             fn from(value: i32) -> Self {
                 Self(value)
             }
         }
 
-        impl ::std::convert::From<Err> for i32 {
-            fn from(value: Err) -> i32 {
+        impl ::std::convert::From<Ok> for i32 {
+            fn from(value: Ok) -> i32 {
                 value.0
             }
         }
 
-        impl ::pilota::thrift::Message for Err {
+        impl ::pilota::thrift::Message for Ok {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -817,7 +817,7 @@ pub mod enum_test {
                     |err| {
                         ::pilota::thrift::new_protocol_exception(
                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for Err, value: {}", value),
+                            format!("invalid enum value for Ok, value: {}", value),
                         )
                     },
                 )?)
@@ -839,7 +839,7 @@ pub mod enum_test {
                         |err| {
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for Err, value: {}", value),
+                                format!("invalid enum value for Ok, value: {}", value),
                             )
                         },
                     )?)
diff --git a/pilota-build/test_data/thrift/multi.rs b/pilota-build/test_data/thrift/multi.rs
index 820e6e9d..de1752de 100644
--- a/pilota-build/test_data/thrift/multi.rs
+++ b/pilota-build/test_data/thrift/multi.rs
@@ -3,267 +3,6 @@ pub mod multi {
 
     pub mod default_value {
 
-        impl Default for C {
-            fn default() -> Self {
-                C {
-                    off: Some(::pilota::FastStr::from_static_str("off")),
-                    test_byte: Some(0i8),
-                }
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
-        pub struct C {
-            pub off: ::std::option::Option<::pilota::FastStr>,
-
-            pub test_byte: ::std::option::Option<i8>,
-        }
-        impl ::pilota::thrift::Message for C {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.off.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                if let Some(value) = self.test_byte.as_ref() {
-                    __protocol.write_i8_field(2, *value)?;
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut off = Some(::pilota::FastStr::from_static_str("off"));
-                let mut test_byte = Some(0i8);
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                off = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
-                                test_byte = Some(__protocol.read_i8()?);
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `C` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self { off, test_byte };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut off = Some(::pilota::FastStr::from_static_str("off"));
-                    let mut test_byte = Some(0i8);
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    off = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
-                                {
-                                    test_byte = Some(__protocol.read_i8().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `C` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self { off, test_byte };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
-                    + self
-                        .off
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self
-                        .test_byte
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i8_field_len(Some(2), *value))
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        pub const A_S: &'static str = "string";
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct B(i32);
-
-        impl B {
-            pub const READ: Self = Self(1);
-            pub const WRITE: Self = Self(2);
-
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(1) => ::std::string::String::from("READ"),
-                    Self(2) => ::std::string::String::from("WRITE"),
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
-
-        impl ::std::convert::From<i32> for B {
-            fn from(value: i32) -> Self {
-                Self(value)
-            }
-        }
-
-        impl ::std::convert::From<B> for i32 {
-            fn from(value: B) -> i32 {
-                value.0
-            }
-        }
-
-        impl ::pilota::thrift::Message for B {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(self.inner())?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let value = __protocol.read_i32()?;
-                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                    |err| {
-                        ::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for B, value: {}", value),
-                        )
-                    },
-                )?)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let value = __protocol.read_i32().await?;
-                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                        |err| {
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for B, value: {}", value),
-                            )
-                        },
-                    )?)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(self.inner())
-            }
-        }
         impl Default for A {
             fn default() -> Self {
                 A {
@@ -848,6 +587,267 @@ pub mod multi {
                     + __protocol.struct_end_len()
             }
         }
+        impl Default for C {
+            fn default() -> Self {
+                C {
+                    off: Some(::pilota::FastStr::from_static_str("off")),
+                    test_byte: Some(0i8),
+                }
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
+        pub struct C {
+            pub off: ::std::option::Option<::pilota::FastStr>,
+
+            pub test_byte: ::std::option::Option<i8>,
+        }
+        impl ::pilota::thrift::Message for C {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.off.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
+                if let Some(value) = self.test_byte.as_ref() {
+                    __protocol.write_i8_field(2, *value)?;
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+
+                let mut off = Some(::pilota::FastStr::from_static_str("off"));
+                let mut test_byte = Some(0i8);
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                off = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::I8 => {
+                                test_byte = Some(__protocol.read_i8()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `C` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let data = Self { off, test_byte };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut off = Some(::pilota::FastStr::from_static_str("off"));
+                    let mut test_byte = Some(0i8);
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    off = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type == ::pilota::thrift::TType::I8 =>
+                                {
+                                    test_byte = Some(__protocol.read_i8().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `C` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { off, test_byte };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+                    + self
+                        .off
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + self
+                        .test_byte
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i8_field_len(Some(2), *value))
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct B(i32);
+
+        impl B {
+            pub const READ: Self = Self(1);
+            pub const WRITE: Self = Self(2);
+
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(1) => ::std::string::String::from("READ"),
+                    Self(2) => ::std::string::String::from("WRITE"),
+                    Self(val) => val.to_string(),
+                }
+            }
+        }
+
+        impl ::std::convert::From<i32> for B {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
+
+        impl ::std::convert::From<B> for i32 {
+            fn from(value: B) -> i32 {
+                value.0
+            }
+        }
+
+        impl ::pilota::thrift::Message for B {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i32(self.inner())?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let value = __protocol.read_i32()?;
+                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                    |err| {
+                        ::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            format!("invalid enum value for B, value: {}", value),
+                        )
+                    },
+                )?)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let value = __protocol.read_i32().await?;
+                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                        |err| {
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                format!("invalid enum value for B, value: {}", value),
+                            )
+                        },
+                    )?)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.i32_len(self.inner())
+            }
+        }
+        pub const A_S: &'static str = "string";
     }
 
     pub mod multi {
@@ -1182,30 +1182,27 @@ pub mod multi {
     }
 
     pub mod recursive_type {
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct C {
-            pub c: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct A {
+            pub a: ::std::option::Option<::std::boxed::Box<A>>,
+
+            pub a_b: ::std::option::Option<::std::boxed::Box<B>>,
         }
-        impl ::pilota::thrift::Message for C {
+        impl ::pilota::thrift::Message for A {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.c.as_ref() {
-                    __protocol.write_set_field(
-                        1,
-                        ::pilota::thrift::TType::Binary,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
+                if let Some(value) = self.a.as_ref() {
+                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                }
+                if let Some(value) = self.a_b.as_ref() {
+                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1218,7 +1215,8 @@ pub mod multi {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut c = None;
+                let mut a = None;
+                let mut a_b = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1234,17 +1232,19 @@ pub mod multi {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                c = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_faststr()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                a = Some(::std::boxed::Box::new(
+                                    ::pilota::thrift::Message::decode(__protocol)?,
+                                ));
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                a_b = Some(::std::boxed::Box::new(
+                                    ::pilota::thrift::Message::decode(__protocol)?,
+                                ));
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1258,7 +1258,7 @@ pub mod multi {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `C` field(#{}) failed, caused by: ",
+                            "decode struct `A` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1266,7 +1266,7 @@ pub mod multi {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { c };
+                let data = Self { a, a_b };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1281,7 +1281,8 @@ pub mod multi {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut c = None;
+                    let mut a = None;
+                    let mut a_b = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1296,18 +1297,22 @@ pub mod multi {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    c = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_faststr().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
+                                    a = Some(::std::boxed::Box::new(
+                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?,
+                                    ));
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    a_b = Some(::std::boxed::Box::new(
+                                        <B as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?,
+                                    ));
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1322,7 +1327,7 @@ pub mod multi {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `C` field(#{}) failed, caused by: ",
+                                "decode struct `A` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -1330,7 +1335,7 @@ pub mod multi {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { c };
+                    let data = Self { a, a_b };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1338,41 +1343,36 @@ pub mod multi {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
-                    + self.c.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(1),
-                            ::pilota::thrift::TType::Binary,
-                            value,
-                            |__protocol, el| __protocol.faststr_len(el),
-                        )
-                    })
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
+                    + self
+                        .a
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                    + self
+                        .a_b
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct A {
-            pub a: ::std::option::Option<::std::boxed::Box<A>>,
-
-            pub a_b: ::std::option::Option<::std::boxed::Box<B>>,
+        pub struct B {
+            pub b_a: ::std::option::Option<::std::boxed::Box<A>>,
         }
-        impl ::pilota::thrift::Message for A {
+        impl ::pilota::thrift::Message for B {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.a.as_ref() {
+                if let Some(value) = self.b_a.as_ref() {
                     __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
                 }
-                if let Some(value) = self.a_b.as_ref() {
-                    __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1384,8 +1384,7 @@ pub mod multi {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut a = None;
-                let mut a_b = None;
+                let mut b_a = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1404,14 +1403,7 @@ pub mod multi {
                             Some(1)
                                 if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                a = Some(::std::boxed::Box::new(
-                                    ::pilota::thrift::Message::decode(__protocol)?,
-                                ));
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                a_b = Some(::std::boxed::Box::new(
+                                b_a = Some(::std::boxed::Box::new(
                                     ::pilota::thrift::Message::decode(__protocol)?,
                                 ));
                             }
@@ -1427,7 +1419,7 @@ pub mod multi {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `A` field(#{}) failed, caused by: ",
+                            "decode struct `B` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1435,7 +1427,7 @@ pub mod multi {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { a, a_b };
+                let data = Self { b_a };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1450,8 +1442,7 @@ pub mod multi {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut a = None;
-                    let mut a_b = None;
+                    let mut b_a = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1469,20 +1460,11 @@ pub mod multi {
                                     if field_ident.field_type
                                         == ::pilota::thrift::TType::Struct =>
                                 {
-                                    a = Some(::std::boxed::Box::new(
+                                    b_a = Some(::std::boxed::Box::new(
                                         <A as ::pilota::thrift::Message>::decode_async(__protocol)
                                             .await?,
                                     ));
                                 }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    a_b = Some(::std::boxed::Box::new(
-                                        <B as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?,
-                                    ));
-                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -1496,7 +1478,7 @@ pub mod multi {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `A` field(#{}) failed, caused by: ",
+                                "decode struct `B` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -1504,7 +1486,7 @@ pub mod multi {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { a, a_b };
+                    let data = Self { b_a };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1512,35 +1494,39 @@ pub mod multi {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
                     + self
-                        .a
+                        .b_a
                         .as_ref()
                         .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
-                    + self
-                        .a_b
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(2), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct B {
-            pub b_a: ::std::option::Option<::std::boxed::Box<A>>,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct C {
+            pub c: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
         }
-        impl ::pilota::thrift::Message for B {
+        impl ::pilota::thrift::Message for C {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.b_a.as_ref() {
-                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                if let Some(value) = self.c.as_ref() {
+                    __protocol.write_set_field(
+                        1,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1553,7 +1539,7 @@ pub mod multi {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut b_a = None;
+                let mut c = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1569,12 +1555,17 @@ pub mod multi {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b_a = Some(::std::boxed::Box::new(
-                                    ::pilota::thrift::Message::decode(__protocol)?,
-                                ));
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                c = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_faststr()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1588,7 +1579,7 @@ pub mod multi {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `B` field(#{}) failed, caused by: ",
+                            "decode struct `C` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1596,7 +1587,7 @@ pub mod multi {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { b_a };
+                let data = Self { c };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1611,7 +1602,7 @@ pub mod multi {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut b_a = None;
+                    let mut c = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1626,13 +1617,18 @@ pub mod multi {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
                                 {
-                                    b_a = Some(::std::boxed::Box::new(
-                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?,
-                                    ));
+                                    c = Some({
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_faststr().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1647,7 +1643,7 @@ pub mod multi {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `B` field(#{}) failed, caused by: ",
+                                "decode struct `C` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -1655,7 +1651,7 @@ pub mod multi {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { b_a };
+                    let data = Self { c };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1663,11 +1659,15 @@ pub mod multi {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
-                    + self
-                        .b_a
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+                    + self.c.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(1),
+                            ::pilota::thrift::TType::Binary,
+                            value,
+                            |__protocol, el| __protocol.faststr_len(el),
+                        )
+                    })
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
diff --git a/pilota-build/test_data/thrift/normal.rs b/pilota-build/test_data/thrift/normal.rs
index 7cd96839..d0cc6ffc 100644
--- a/pilota-build/test_data/thrift/normal.rs
+++ b/pilota-build/test_data/thrift/normal.rs
@@ -141,10 +141,9 @@ pub mod normal {
                     + __protocol.struct_end_len()
             }
         }
-        pub trait Test {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestTest123ArgsSend {}
-        impl ::pilota::thrift::Message for TestTest123ArgsSend {
+        pub struct TestTest123ArgsRecv {}
+        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -152,7 +151,7 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -194,7 +193,7 @@ pub mod normal {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -241,7 +240,7 @@ pub mod normal {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -256,62 +255,38 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct ObjReq {
-            pub msg: Message,
-
-            pub msg_map: ::pilota::AHashMap<Message, SubMessage>,
-
-            pub sub_msgs: ::std::vec::Vec<SubMessage>,
-
-            pub msg_set: ::std::option::Option<::pilota::AHashSet<Message>>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct Message {
+            pub uid: ::std::option::Option<[u8; 16]>,
 
-            pub flag_msg: ::pilota::FastStr,
+            pub value: ::std::option::Option<::pilota::FastStr>,
 
-            pub mock_cost: ::std::option::Option<::pilota::FastStr>,
+            pub sub_messages: ::std::option::Option<::std::vec::Vec<SubMessage>>,
         }
-        impl ::pilota::thrift::Message for ObjReq {
+        impl ::pilota::thrift::Message for Message {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ObjReq" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Message" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.msg, ::pilota::thrift::TType::Struct)?;
-                __protocol.write_map_field(
-                    2,
-                    ::pilota::thrift::TType::Struct,
-                    ::pilota::thrift::TType::Struct,
-                    &&self.msg_map,
-                    |__protocol, key| {
-                        __protocol.write_struct(key)?;
-                        ::std::result::Result::Ok(())
-                    },
-                    |__protocol, val| {
-                        __protocol.write_struct(val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                __protocol.write_list_field(
-                    3,
-                    ::pilota::thrift::TType::Struct,
-                    &&self.sub_msgs,
-                    |__protocol, val| {
-                        __protocol.write_struct(val)?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                if let Some(value) = self.msg_set.as_ref() {
-                    __protocol.write_set_field(
-                        4,
+                if let Some(value) = self.uid.as_ref() {
+                    __protocol.write_uuid_field(1, *value)?;
+                }
+                if let Some(value) = self.value.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
+                }
+                if let Some(value) = self.sub_messages.as_ref() {
+                    __protocol.write_list_field(
+                        3,
                         ::pilota::thrift::TType::Struct,
                         &value,
                         |__protocol, val| {
@@ -320,10 +295,6 @@ pub mod normal {
                         },
                     )?;
                 }
-                __protocol.write_faststr_field(5, (&self.flag_msg).clone())?;
-                if let Some(value) = self.mock_cost.as_ref() {
-                    __protocol.write_faststr_field(6, (value).clone())?;
-                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -335,12 +306,9 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut msg = None;
-                let mut msg_map = None;
-                let mut sub_msgs = None;
-                let mut msg_set = None;
-                let mut flag_msg = None;
-                let mut mock_cost = None;
+                let mut uid = None;
+                let mut value = None;
+                let mut sub_messages = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -356,27 +324,16 @@ pub mod normal {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                msg = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
+                                uid = Some(__protocol.read_uuid()?);
                             }
-                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map => {
-                                msg_map = Some({
-                                    let map_ident = __protocol.read_map_begin()?;
-                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                                    for _ in 0..map_ident.size {
-                                        val.insert(
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                            ::pilota::thrift::Message::decode(__protocol)?,
-                                        );
-                                    }
-                                    __protocol.read_map_end()?;
-                                    val
-                                });
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                value = Some(__protocol.read_faststr()?);
                             }
                             Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                sub_msgs = Some(unsafe {
+                                sub_messages = Some(unsafe {
                                     let list_ident = __protocol.read_list_begin()?;
                                     let mut val: Vec<SubMessage> =
                                         Vec::with_capacity(list_ident.size);
@@ -390,28 +347,6 @@ pub mod normal {
                                     val
                                 });
                             }
-                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                msg_set = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(::pilota::thrift::Message::decode(__protocol)?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
-                            }
-                            Some(5)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                flag_msg = Some(__protocol.read_faststr()?);
-                            }
-                            Some(6)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                mock_cost = Some(__protocol.read_faststr()?);
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -424,7 +359,7 @@ pub mod normal {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `ObjReq` field(#{}) failed, caused by: ",
+                            "decode struct `Message` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -432,38 +367,10 @@ pub mod normal {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(msg) = msg else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field msg is required".to_string(),
-                    ));
-                };
-                let Some(msg_map) = msg_map else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field msg_map is required".to_string(),
-                    ));
-                };
-                let Some(sub_msgs) = sub_msgs else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field sub_msgs is required".to_string(),
-                    ));
-                };
-                let Some(flag_msg) = flag_msg else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field flag_msg is required".to_string(),
-                    ));
-                };
-
                 let data = Self {
-                    msg,
-                    msg_map,
-                    sub_msgs,
-                    msg_set,
-                    flag_msg,
-                    mock_cost,
+                    uid,
+                    value,
+                    sub_messages,
                 };
                 ::std::result::Result::Ok(data)
             }
@@ -479,12 +386,9 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut msg = None;
-                    let mut msg_map = None;
-                    let mut sub_msgs = None;
-                    let mut msg_set = None;
-                    let mut flag_msg = None;
-                    let mut mock_cost = None;
+                    let mut uid = None;
+                    let mut value = None;
+                    let mut sub_messages = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -502,22 +406,14 @@ pub mod normal {
                 }
                 __pilota_decoding_field_id = field_ident.id;
                 match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    msg = Some(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid  => {
+                    uid = Some(__protocol.read_uuid().await?);
 
-                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map  => {
-                    msg_map = Some({
-                        let map_ident = __protocol.read_map_begin().await?;
-                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
-                        for _ in 0..map_ident.size {
-                            val.insert(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?, <SubMessage as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                        }
-                        __protocol.read_map_end().await?;
-                        val
-                    });
+                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
+                    value = Some(__protocol.read_faststr().await?);
 
                 },Some(3) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    sub_msgs = Some({
+                    sub_messages = Some({
                             let list_ident = __protocol.read_list_begin().await?;
                             let mut val = Vec::with_capacity(list_ident.size);
                             for _ in 0..list_ident.size {
@@ -527,21 +423,6 @@ pub mod normal {
                             val
                         });
 
-                },Some(4) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
-                    msg_set = Some({let list_ident = __protocol.read_set_begin().await?;
-                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
-                    for _ in 0..list_ident.size {
-                        val.insert(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                    };
-                    __protocol.read_set_end().await?;
-                    val});
-
-                },Some(5) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
-                    flag_msg = Some(__protocol.read_faststr().await?);
-
-                },Some(6) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
-                    mock_cost = Some(__protocol.read_faststr().await?);
-
                 },
                     _ => {
                         __protocol.skip(field_ident.field_type).await?;
@@ -556,52 +437,16 @@ pub mod normal {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 }.await {
                 if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `ObjReq` field(#{}) failed, caused by: ", field_id));
+                    err.prepend_msg(&format!("decode struct `Message` field(#{}) failed, caused by: ", field_id));
                 }
                 return ::std::result::Result::Err(err);
             };
                     __protocol.read_struct_end().await?;
 
-                    let Some(msg) = msg else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field msg is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(msg_map) = msg_map else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field msg_map is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(sub_msgs) = sub_msgs else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field sub_msgs is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(flag_msg) = flag_msg else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field flag_msg is required".to_string(),
-                            ),
-                        );
-                    };
-
                     let data = Self {
-                        msg,
-                        msg_map,
-                        sub_msgs,
-                        msg_set,
-                        flag_msg,
-                        mock_cost,
+                        uid,
+                        value,
+                        sub_messages,
                     };
                     ::std::result::Result::Ok(data)
                 })
@@ -610,39 +455,131 @@ pub mod normal {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ObjReq" })
-                    + __protocol.struct_field_len(Some(1), &self.msg)
-                    + __protocol.map_field_len(
-                        Some(2),
-                        ::pilota::thrift::TType::Struct,
-                        ::pilota::thrift::TType::Struct,
-                        &self.msg_map,
-                        |__protocol, key| __protocol.struct_len(key),
-                        |__protocol, val| __protocol.struct_len(val),
-                    )
-                    + __protocol.list_field_len(
-                        Some(3),
-                        ::pilota::thrift::TType::Struct,
-                        &self.sub_msgs,
-                        |__protocol, el| __protocol.struct_len(el),
-                    )
-                    + self.msg_set.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(4),
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Message" })
+                    + self
+                        .uid
+                        .as_ref()
+                        .map_or(0, |value| __protocol.uuid_field_len(Some(1), *value))
+                    + self
+                        .value
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                    + self.sub_messages.as_ref().map_or(0, |value| {
+                        __protocol.list_field_len(
+                            Some(3),
                             ::pilota::thrift::TType::Struct,
                             value,
                             |__protocol, el| __protocol.struct_len(el),
                         )
                     })
-                    + __protocol.faststr_field_len(Some(5), &self.flag_msg)
-                    + self
-                        .mock_cost
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(6), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+        pub trait Test {}
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestTest123ResultRecv {
+            #[derivative(Default)]
+            Ok(()),
+        }
+
+        impl ::pilota::thrift::Message for TestTest123ResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ResultRecv",
+                })?;
+                match self {
+                    TestTest123ResultRecv::Ok(ref value) => {}
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ResultRecv",
+                }) + match self {
+                    TestTest123ResultRecv::Ok(ref value) => 0,
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
         pub struct B {
             pub a: ::std::option::Option<A>,
@@ -943,21 +880,34 @@ pub mod normal {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestTest123ArgsRecv {}
-        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestTestExceptionResultRecv {
+            #[derivative(Default)]
+            Ok(ObjReq),
+
+            StException(StException),
+        }
+
+        impl ::pilota::thrift::Message for TestTestExceptionResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultRecv",
+                })?;
+                match self {
+                    TestTestExceptionResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestTestExceptionResultRecv::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -968,43 +918,60 @@ pub mod normal {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
                         }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultRecv::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self {};
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1018,118 +985,7 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self {};
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
-                }) + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestTest123ResultSend {
-            #[derivative(Default)]
-            Ok(()),
-        }
-
-        impl ::pilota::thrift::Message for TestTest123ResultSend {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultSend",
-                })?;
-                match self {
-                    TestTest123ResultSend::Ok(ref value) => {}
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
                     loop {
                         let field_ident = __protocol.read_field_begin().await?;
@@ -1138,6 +994,39 @@ pub mod normal {
                         } else {
                         }
                         match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionResultRecv::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -1148,7 +1037,10 @@ pub mod normal {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
                     }
                 })
             }
@@ -1157,31 +1049,80 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultSend",
+                    name: "TestTestExceptionResultRecv",
                 }) + match self {
-                    TestTest123ResultSend::Ok(ref value) => 0,
+                    TestTestExceptionResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                    TestTestExceptionResultRecv::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct StException {
-            pub message: ::std::option::Option<::pilota::FastStr>,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct ObjReq {
+            pub msg: Message,
+
+            pub msg_map: ::pilota::AHashMap<Message, SubMessage>,
+
+            pub sub_msgs: ::std::vec::Vec<SubMessage>,
+
+            pub msg_set: ::std::option::Option<::pilota::AHashSet<Message>>,
+
+            pub flag_msg: ::pilota::FastStr,
+
+            pub mock_cost: ::std::option::Option<::pilota::FastStr>,
         }
-        impl ::pilota::thrift::Message for StException {
+        impl ::pilota::thrift::Message for ObjReq {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "STException",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ObjReq" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.message.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
+                __protocol.write_struct_field(1, &self.msg, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_map_field(
+                    2,
+                    ::pilota::thrift::TType::Struct,
+                    ::pilota::thrift::TType::Struct,
+                    &&self.msg_map,
+                    |__protocol, key| {
+                        __protocol.write_struct(key)?;
+                        ::std::result::Result::Ok(())
+                    },
+                    |__protocol, val| {
+                        __protocol.write_struct(val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                __protocol.write_list_field(
+                    3,
+                    ::pilota::thrift::TType::Struct,
+                    &&self.sub_msgs,
+                    |__protocol, val| {
+                        __protocol.write_struct(val)?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                if let Some(value) = self.msg_set.as_ref() {
+                    __protocol.write_set_field(
+                        4,
+                        ::pilota::thrift::TType::Struct,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_struct(val)?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
+                }
+                __protocol.write_faststr_field(5, (&self.flag_msg).clone())?;
+                if let Some(value) = self.mock_cost.as_ref() {
+                    __protocol.write_faststr_field(6, (value).clone())?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1194,7 +1135,12 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut message = None;
+                let mut msg = None;
+                let mut msg_map = None;
+                let mut sub_msgs = None;
+                let mut msg_set = None;
+                let mut flag_msg = None;
+                let mut mock_cost = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1211,32 +1157,115 @@ pub mod normal {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                message = Some(__protocol.read_faststr()?);
+                                msg = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                            Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map => {
+                                msg_map = Some({
+                                    let map_ident = __protocol.read_map_begin()?;
+                                    let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                                    for _ in 0..map_ident.size {
+                                        val.insert(
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                            ::pilota::thrift::Message::decode(__protocol)?,
+                                        );
+                                    }
+                                    __protocol.read_map_end()?;
+                                    val
+                                });
                             }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `STException` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self { message };
-                ::std::result::Result::Ok(data)
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                sub_msgs = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<SubMessage> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr()
+                                            .offset(i as isize)
+                                            .write(::pilota::thrift::Message::decode(__protocol)?);
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            Some(4) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                msg_set = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(::pilota::thrift::Message::decode(__protocol)?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
+                            }
+                            Some(5)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                flag_msg = Some(__protocol.read_faststr()?);
+                            }
+                            Some(6)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                mock_cost = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `ObjReq` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(msg) = msg else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field msg is required".to_string(),
+                    ));
+                };
+                let Some(msg_map) = msg_map else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field msg_map is required".to_string(),
+                    ));
+                };
+                let Some(sub_msgs) = sub_msgs else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field sub_msgs is required".to_string(),
+                    ));
+                };
+                let Some(flag_msg) = flag_msg else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field flag_msg is required".to_string(),
+                    ));
+                };
+
+                let data = Self {
+                    msg,
+                    msg_map,
+                    sub_msgs,
+                    msg_set,
+                    flag_msg,
+                    mock_cost,
+                };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1250,82 +1279,509 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut message = None;
+                    let mut msg = None;
+                    let mut msg_map = None;
+                    let mut sub_msgs = None;
+                    let mut msg_set = None;
+                    let mut flag_msg = None;
+                    let mut mock_cost = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    message = Some(__protocol.read_faststr().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                    loop {
 
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `STException` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
+
+                    break;
+                } else {
+
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    msg = Some(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Map  => {
+                    msg_map = Some({
+                        let map_ident = __protocol.read_map_begin().await?;
+                        let mut val = ::pilota::AHashMap::with_capacity(map_ident.size);
+                        for _ in 0..map_ident.size {
+                            val.insert(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?, <SubMessage as ::pilota::thrift::Message>::decode_async(__protocol).await?);
                         }
-                        return ::std::result::Result::Err(err);
+                        __protocol.read_map_end().await?;
+                        val
+                    });
+
+                },Some(3) if field_ident.field_type == ::pilota::thrift::TType::List  => {
+                    sub_msgs = Some({
+                            let list_ident = __protocol.read_list_begin().await?;
+                            let mut val = Vec::with_capacity(list_ident.size);
+                            for _ in 0..list_ident.size {
+                                val.push(<SubMessage as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+                            };
+                            __protocol.read_list_end().await?;
+                            val
+                        });
+
+                },Some(4) if field_ident.field_type == ::pilota::thrift::TType::Set  => {
+                    msg_set = Some({let list_ident = __protocol.read_set_begin().await?;
+                    let mut val = ::pilota::AHashSet::with_capacity(list_ident.size);
+                    for _ in 0..list_ident.size {
+                        val.insert(<Message as ::pilota::thrift::Message>::decode_async(__protocol).await?);
                     };
+                    __protocol.read_set_end().await?;
+                    val});
+
+                },Some(5) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
+                    flag_msg = Some(__protocol.read_faststr().await?);
+
+                },Some(6) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
+                    mock_cost = Some(__protocol.read_faststr().await?);
+
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
+
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `ObjReq` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { message };
+                    let Some(msg) = msg else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field msg is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(msg_map) = msg_map else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field msg_map is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(sub_msgs) = sub_msgs else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field sub_msgs is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(flag_msg) = flag_msg else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field flag_msg is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self {
+                        msg,
+                        msg_map,
+                        sub_msgs,
+                        msg_set,
+                        flag_msg,
+                        mock_cost,
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
 
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ObjReq" })
+                    + __protocol.struct_field_len(Some(1), &self.msg)
+                    + __protocol.map_field_len(
+                        Some(2),
+                        ::pilota::thrift::TType::Struct,
+                        ::pilota::thrift::TType::Struct,
+                        &self.msg_map,
+                        |__protocol, key| __protocol.struct_len(key),
+                        |__protocol, val| __protocol.struct_len(val),
+                    )
+                    + __protocol.list_field_len(
+                        Some(3),
+                        ::pilota::thrift::TType::Struct,
+                        &self.sub_msgs,
+                        |__protocol, el| __protocol.struct_len(el),
+                    )
+                    + self.msg_set.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(4),
+                            ::pilota::thrift::TType::Struct,
+                            value,
+                            |__protocol, el| __protocol.struct_len(el),
+                        )
+                    })
+                    + __protocol.faststr_field_len(Some(5), &self.flag_msg)
+                    + self
+                        .mock_cost
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(6), value))
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestTestExceptionResultSend {
+            #[derivative(Default)]
+            Ok(ObjReq),
+
+            StException(StException),
+        }
+
+        impl ::pilota::thrift::Message for TestTestExceptionResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultSend",
+                })?;
+                match self {
+                    TestTestExceptionResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestTestExceptionResultSend::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultSend::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestTestExceptionResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionResultSend::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultSend",
+                }) + match self {
+                    TestTestExceptionResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                    TestTestExceptionResultSend::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestTestExceptionException {
+            #[derivative(Default)]
+            StException(StException),
+        }
+
+        impl ::pilota::thrift::Message for TestTestExceptionException {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionException",
+                })?;
+                match self {
+                    TestTestExceptionException::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionException::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionException::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "STException",
-                }) + self
-                    .message
-                    .as_ref()
-                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + __protocol.field_stop_len()
+                    name: "TestTestExceptionException",
+                }) + match self {
+                    TestTestExceptionException::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct SubMessage {
-            pub value: ::std::option::Option<::pilota::FastStr>,
-        }
-        impl ::pilota::thrift::Message for SubMessage {
+        pub struct TestTest123ArgsSend {}
+        impl ::pilota::thrift::Message for TestTest123ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "SubMessage" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ArgsSend",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.value.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
-                }
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1337,8 +1793,6 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut value = None;
-
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
@@ -1353,11 +1807,6 @@ pub mod normal {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                value = Some(__protocol.read_faststr()?);
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -1370,7 +1819,7 @@ pub mod normal {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `SubMessage` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1378,7 +1827,7 @@ pub mod normal {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { value };
+                let data = Self {};
                 ::std::result::Result::Ok(data)
             }
 
@@ -1393,8 +1842,6 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut value = None;
-
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
@@ -1407,12 +1854,6 @@ pub mod normal {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    value = Some(__protocol.read_faststr().await?);
-                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -1425,16 +1866,13 @@ pub mod normal {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `SubMessage` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { value };
+                    let data = Self {};
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1442,33 +1880,29 @@ pub mod normal {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SubMessage" })
-                    + self
-                        .value
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ArgsSend",
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct TestTestExceptionArgsRecv {
-            pub req: ObjReq,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct SubMessage {
+            pub value: ::std::option::Option<::pilota::FastStr>,
         }
-        impl ::pilota::thrift::Message for TestTestExceptionArgsRecv {
+        impl ::pilota::thrift::Message for SubMessage {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsRecv",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "SubMessage" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                if let Some(value) = self.value.as_ref() {
+                    __protocol.write_faststr_field(2, (value).clone())?;
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1480,7 +1914,7 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut req = None;
+                let mut value = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -1496,10 +1930,10 @@ pub mod normal {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                value = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -1512,174 +1946,17 @@ pub mod normal {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `SubMessage` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(req) = req else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
-                    ));
-                };
-
-                let data = Self { req };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut req = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    req = Some(
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(req) = req else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { req };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsRecv",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestTestExceptionException {
-            #[derivative(Default)]
-            StException(StException),
-        }
-
-        impl ::pilota::thrift::Message for TestTestExceptionException {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionException",
-                })?;
-                match self {
-                    TestTestExceptionException::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionException::StException(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                let data = Self { value };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1693,91 +1970,82 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut value = None;
 
-                                    ret =
-                                        Some(TestTestExceptionException::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    value = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `SubMessage` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self { value };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionException",
-                }) + match self {
-                    TestTestExceptionException::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SubMessage" })
+                    + self
+                        .value
+                        .as_ref()
+                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestTestExceptionResultSend {
-            #[derivative(Default)]
-            Ok(ObjReq),
-
-            StException(StException),
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct TestTestExceptionArgsRecv {
+            pub req: ObjReq,
         }
-
-        impl ::pilota::thrift::Message for TestTestExceptionResultSend {
+        impl ::pilota::thrift::Message for TestTestExceptionArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultSend",
-                })?;
-                match self {
-                    TestTestExceptionResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestTestExceptionResultSend::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1788,60 +2056,54 @@ pub mod normal {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut req = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultSend::StException(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(req) = req else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field req is required".to_string(),
+                    ));
+                };
+
+                let data = Self { req };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1855,63 +2117,60 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut req = None;
 
-                                    ret = Some(TestTestExceptionResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret =
-                                        Some(TestTestExceptionResultSend::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    req = Some(
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -1919,45 +2178,30 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultSend",
-                }) + match self {
-                    TestTestExceptionResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    TestTestExceptionResultSend::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "TestTestExceptionArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestTestExceptionResultRecv {
-            #[derivative(Default)]
-            Ok(ObjReq),
-
-            StException(StException),
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct StException {
+            pub message: ::std::option::Option<::pilota::FastStr>,
         }
-
-        impl ::pilota::thrift::Message for TestTestExceptionResultRecv {
+        impl ::pilota::thrift::Message for StException {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultRecv",
-                })?;
-                match self {
-                    TestTestExceptionResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestTestExceptionResultRecv::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "STException",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.message.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1969,60 +2213,50 @@ pub mod normal {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut message = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultRecv::StException(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                message = Some(__protocol.read_faststr()?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `STException` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self { message };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -2036,63 +2270,49 @@ pub mod normal {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut message = None;
 
-                                    ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret =
-                                        Some(TestTestExceptionResultRecv::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    message = Some(__protocol.read_faststr().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `STException` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self { message };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -2100,27 +2320,24 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultRecv",
-                }) + match self {
-                    TestTestExceptionResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    TestTestExceptionResultRecv::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "STException",
+                }) + self
+                    .message
+                    .as_ref()
+                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestTest123ResultRecv {
+        pub enum TestTest123ResultSend {
             #[derivative(Default)]
             Ok(()),
         }
 
-        impl ::pilota::thrift::Message for TestTest123ResultRecv {
+        impl ::pilota::thrift::Message for TestTest123ResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -2128,10 +2345,10 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultRecv",
+                    name: "TestTest123ResultSend",
                 })?;
                 match self {
-                    TestTest123ResultRecv::Ok(ref value) => {}
+                    TestTest123ResultSend::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2164,7 +2381,7 @@ pub mod normal {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
+                    ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
                 }
             }
 
@@ -2198,7 +2415,7 @@ pub mod normal {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
+                        ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
                     }
                 })
             }
@@ -2207,229 +2424,12 @@ pub mod normal {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultRecv",
+                    name: "TestTest123ResultSend",
                 }) + match self {
-                    TestTest123ResultRecv::Ok(ref value) => 0,
+                    TestTest123ResultSend::Ok(ref value) => 0,
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Message {
-            pub uid: ::std::option::Option<[u8; 16]>,
-
-            pub value: ::std::option::Option<::pilota::FastStr>,
-
-            pub sub_messages: ::std::option::Option<::std::vec::Vec<SubMessage>>,
-        }
-        impl ::pilota::thrift::Message for Message {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Message" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.uid.as_ref() {
-                    __protocol.write_uuid_field(1, *value)?;
-                }
-                if let Some(value) = self.value.as_ref() {
-                    __protocol.write_faststr_field(2, (value).clone())?;
-                }
-                if let Some(value) = self.sub_messages.as_ref() {
-                    __protocol.write_list_field(
-                        3,
-                        ::pilota::thrift::TType::Struct,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_struct(val)?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut uid = None;
-                let mut value = None;
-                let mut sub_messages = None;
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid => {
-                                uid = Some(__protocol.read_uuid()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                value = Some(__protocol.read_faststr()?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                sub_messages = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<SubMessage> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr()
-                                            .offset(i as isize)
-                                            .write(::pilota::thrift::Message::decode(__protocol)?);
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Message` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self {
-                    uid,
-                    value,
-                    sub_messages,
-                };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut uid = None;
-                    let mut value = None;
-                    let mut sub_messages = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                    loop {
-
-
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
-
-                    break;
-                } else {
-
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Uuid  => {
-                    uid = Some(__protocol.read_uuid().await?);
-
-                },Some(2) if field_ident.field_type == ::pilota::thrift::TType::Binary  => {
-                    value = Some(__protocol.read_faststr().await?);
-
-                },Some(3) if field_ident.field_type == ::pilota::thrift::TType::List  => {
-                    sub_messages = Some({
-                            let list_ident = __protocol.read_list_begin().await?;
-                            let mut val = Vec::with_capacity(list_ident.size);
-                            for _ in 0..list_ident.size {
-                                val.push(<SubMessage as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-                            };
-                            __protocol.read_list_end().await?;
-                            val
-                        });
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
-
-
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `Message` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self {
-                        uid,
-                        value,
-                        sub_messages,
-                    };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Message" })
-                    + self
-                        .uid
-                        .as_ref()
-                        .map_or(0, |value| __protocol.uuid_field_len(Some(1), *value))
-                    + self
-                        .value
-                        .as_ref()
-                        .map_or(0, |value| __protocol.faststr_field_len(Some(2), value))
-                    + self.sub_messages.as_ref().map_or(0, |value| {
-                        __protocol.list_field_len(
-                            Some(3),
-                            ::pilota::thrift::TType::Struct,
-                            value,
-                            |__protocol, el| __protocol.struct_len(el),
-                        )
-                    })
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
     }
 }
diff --git a/pilota-build/test_data/thrift/pilota_name.rs b/pilota-build/test_data/thrift/pilota_name.rs
index 0edbf449..b0668a17 100644
--- a/pilota-build/test_data/thrift/pilota_name.rs
+++ b/pilota-build/test_data/thrift/pilota_name.rs
@@ -312,29 +312,47 @@ pub mod pilota_name {
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultSend {
-            #[derivative(Default)]
-            Ok(Test1),
+        #[derive(Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct Index(i32);
+
+        impl Index {
+            pub const AA: Self = Self(0);
+            pub const B: Self = Self(1);
+
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(0) => ::std::string::String::from("AA"),
+                    Self(1) => ::std::string::String::from("B"),
+                    Self(val) => val.to_string(),
+                }
+            }
         }
 
-        impl ::pilota::thrift::Message for TestServiceTestResultSend {
+        impl ::std::convert::From<i32> for Index {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
+
+        impl ::std::convert::From<Index> for i32 {
+            fn from(value: Index) -> i32 {
+                value.0
+            }
+        }
+
+        impl ::pilota::thrift::Message for Index {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
-                })?;
-                match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
+                __protocol.write_i32(self.inner())?;
                 ::std::result::Result::Ok(())
             }
 
@@ -343,46 +361,15 @@ pub mod pilota_name {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                let value = __protocol.read_i32()?;
+                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                    |err| {
+                        ::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            format!("invalid enum value for Index, value: {}", value),
+                        )
+                    },
+                )?)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -396,80 +383,41 @@ pub mod pilota_name {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <Test1 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+                    let value = __protocol.read_i32().await?;
+                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                        |err| {
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                format!("invalid enum value for Index, value: {}", value),
+                            )
+                        },
+                    )?)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
-                }) + match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
+                __protocol.i32_len(self.inner())
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct Test1 {
-            pub id: ::pilota::FastStr,
-
-            pub hello: ::pilota::FastStr,
+        pub struct TestServiceTestArgsSend {
+            pub req: Test2,
         }
-        impl ::pilota::thrift::Message for Test1 {
+        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Test" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestArgsSend",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.id).clone())?;
-                __protocol.write_faststr_field(2, (&self.hello).clone())?;
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -481,8 +429,7 @@ pub mod pilota_name {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut id = None;
-                let mut hello = None;
+                let mut req = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -499,14 +446,9 @@ pub mod pilota_name {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                id = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                hello = Some(__protocol.read_faststr()?);
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -519,29 +461,20 @@ pub mod pilota_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `Test` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(id) = id else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field id is required".to_string(),
-                    ));
-                };
-                let Some(hello) = hello else {
+                let Some(req) = req else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field hello is required".to_string(),
+                        "field req is required".to_string(),
                     ));
                 };
 
-                let data = Self { id, hello };
+                let data = Self { req };
                 ::std::result::Result::Ok(data)
             }
 
@@ -556,8 +489,7 @@ pub mod pilota_name {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut id = None;
-                    let mut hello = None;
+                    let mut req = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -573,86 +505,217 @@ pub mod pilota_name {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    id = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    hello = Some(__protocol.read_faststr().await?);
+                                    req = Some(
+                                        <Test2 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestServiceTestResultRecv {
+            #[derivative(Default)]
+            Ok(Test1),
+        }
+
+        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestResultRecv",
+                })?;
+                match self {
+                    TestServiceTestResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <Test1 as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Test` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(id) = id else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field id is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(hello) = hello else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field hello is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { id, hello };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Test" })
-                    + __protocol.faststr_field_len(Some(1), &self.id)
-                    + __protocol.faststr_field_len(Some(2), &self.hello)
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestResultRecv",
+                }) + match self {
+                    TestServiceTestResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestServiceTestArgsSend {
-            pub req: Test2,
+        pub struct Test1 {
+            pub id: ::pilota::FastStr,
+
+            pub hello: ::pilota::FastStr,
         }
-        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
+        impl ::pilota::thrift::Message for Test1 {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Test" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_faststr_field(1, (&self.id).clone())?;
+                __protocol.write_faststr_field(2, (&self.hello).clone())?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -664,7 +727,8 @@ pub mod pilota_name {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut req = None;
+                let mut id = None;
+                let mut hello = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -681,9 +745,14 @@ pub mod pilota_name {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                id = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                hello = Some(__protocol.read_faststr()?);
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -696,20 +765,29 @@ pub mod pilota_name {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `Test` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(req) = req else {
+                let Some(id) = id else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
+                        "field id is required".to_string(),
+                    ));
+                };
+                let Some(hello) = hello else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field hello is required".to_string(),
                     ));
                 };
 
-                let data = Self { req };
+                let data = Self { id, hello };
                 ::std::result::Result::Ok(data)
             }
 
@@ -724,7 +802,8 @@ pub mod pilota_name {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut req = None;
+                    let mut id = None;
+                    let mut hello = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -740,14 +819,15 @@ pub mod pilota_name {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                        == ::pilota::thrift::TType::Binary =>
                                 {
-                                    req = Some(
-                                        <Test2 as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
+                                    id = Some(__protocol.read_faststr().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    hello = Some(__protocol.read_faststr().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -761,22 +841,33 @@ pub mod pilota_name {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `Test` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(req) = req else {
+                    let Some(id) = id else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
+                                "field id is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(hello) = hello else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field hello is required".to_string(),
                             ),
                         );
                     };
 
-                    let data = Self { req };
+                    let data = Self { id, hello };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -784,9 +875,9 @@ pub mod pilota_name {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Test" })
+                    + __protocol.faststr_field_len(Some(1), &self.id)
+                    + __protocol.faststr_field_len(Some(2), &self.hello)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -796,12 +887,12 @@ pub mod pilota_name {
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultRecv {
+        pub enum TestServiceTestResultSend {
             #[derivative(Default)]
             Ok(Test1),
         }
 
-        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
+        impl ::pilota::thrift::Message for TestServiceTestResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -809,10 +900,10 @@ pub mod pilota_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
+                    name: "TestServiceTestResultSend",
                 })?;
                 match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
+                    TestServiceTestResultSend::Ok(ref value) => {
                         __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
@@ -841,7 +932,7 @@ pub mod pilota_name {
                             if ret.is_none() {
                                 let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
+                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -896,7 +987,7 @@ pub mod pilota_name {
                                         )
                                         .await?;
 
-                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
+                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -926,105 +1017,14 @@ pub mod pilota_name {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
+                    name: "TestServiceTestResultSend",
                 }) + match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
+                    TestServiceTestResultSend::Ok(ref value) => {
                         __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct Index(i32);
-
-        impl Index {
-            pub const AA: Self = Self(0);
-            pub const B: Self = Self(1);
-
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(0) => ::std::string::String::from("AA"),
-                    Self(1) => ::std::string::String::from("B"),
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
-
-        impl ::std::convert::From<i32> for Index {
-            fn from(value: i32) -> Self {
-                Self(value)
-            }
-        }
-
-        impl ::std::convert::From<Index> for i32 {
-            fn from(value: Index) -> i32 {
-                value.0
-            }
-        }
-
-        impl ::pilota::thrift::Message for Index {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(self.inner())?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let value = __protocol.read_i32()?;
-                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                    |err| {
-                        ::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for Index, value: {}", value),
-                        )
-                    },
-                )?)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let value = __protocol.read_i32().await?;
-                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                        |err| {
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for Index, value: {}", value),
-                            )
-                        },
-                    )?)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(self.inner())
-            }
-        }
     }
 }
diff --git a/pilota-build/test_data/thrift/recursive_type.rs b/pilota-build/test_data/thrift/recursive_type.rs
index 4ce40b2a..55f0f000 100644
--- a/pilota-build/test_data/thrift/recursive_type.rs
+++ b/pilota-build/test_data/thrift/recursive_type.rs
@@ -176,30 +176,22 @@ pub mod recursive_type {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct C {
-            pub c: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
+        pub struct B {
+            pub b_a: ::std::option::Option<::std::boxed::Box<A>>,
         }
-        impl ::pilota::thrift::Message for C {
+        impl ::pilota::thrift::Message for B {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.c.as_ref() {
-                    __protocol.write_set_field(
-                        1,
-                        ::pilota::thrift::TType::Binary,
-                        &value,
-                        |__protocol, val| {
-                            __protocol.write_faststr((val).clone())?;
-                            ::std::result::Result::Ok(())
-                        },
-                    )?;
+                if let Some(value) = self.b_a.as_ref() {
+                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -212,7 +204,7 @@ pub mod recursive_type {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut c = None;
+                let mut b_a = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -228,17 +220,12 @@ pub mod recursive_type {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
-                                c = Some({
-                                    let list_ident = __protocol.read_set_begin()?;
-                                    let mut val =
-                                        ::pilota::AHashSet::with_capacity(list_ident.size);
-                                    for _ in 0..list_ident.size {
-                                        val.insert(__protocol.read_faststr()?);
-                                    }
-                                    __protocol.read_set_end()?;
-                                    val
-                                });
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                b_a = Some(::std::boxed::Box::new(
+                                    ::pilota::thrift::Message::decode(__protocol)?,
+                                ));
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -252,7 +239,7 @@ pub mod recursive_type {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `C` field(#{}) failed, caused by: ",
+                            "decode struct `B` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -260,7 +247,7 @@ pub mod recursive_type {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { c };
+                let data = Self { b_a };
                 ::std::result::Result::Ok(data)
             }
 
@@ -275,7 +262,7 @@ pub mod recursive_type {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut c = None;
+                    let mut b_a = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -290,18 +277,13 @@ pub mod recursive_type {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    c = Some({
-                                        let list_ident = __protocol.read_set_begin().await?;
-                                        let mut val =
-                                            ::pilota::AHashSet::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.insert(__protocol.read_faststr().await?);
-                                        }
-                                        __protocol.read_set_end().await?;
-                                        val
-                                    });
+                                    b_a = Some(::std::boxed::Box::new(
+                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?,
+                                    ));
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -316,7 +298,7 @@ pub mod recursive_type {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `C` field(#{}) failed, caused by: ",
+                                "decode struct `B` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -324,7 +306,7 @@ pub mod recursive_type {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { c };
+                    let data = Self { b_a };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -332,35 +314,39 @@ pub mod recursive_type {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
-                    + self.c.as_ref().map_or(0, |value| {
-                        __protocol.set_field_len(
-                            Some(1),
-                            ::pilota::thrift::TType::Binary,
-                            value,
-                            |__protocol, el| __protocol.faststr_len(el),
-                        )
-                    })
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
+                    + self
+                        .b_a
+                        .as_ref()
+                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct B {
-            pub b_a: ::std::option::Option<::std::boxed::Box<A>>,
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct C {
+            pub c: ::std::option::Option<::pilota::AHashSet<::pilota::FastStr>>,
         }
-        impl ::pilota::thrift::Message for B {
+        impl ::pilota::thrift::Message for C {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.b_a.as_ref() {
-                    __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                if let Some(value) = self.c.as_ref() {
+                    __protocol.write_set_field(
+                        1,
+                        ::pilota::thrift::TType::Binary,
+                        &value,
+                        |__protocol, val| {
+                            __protocol.write_faststr((val).clone())?;
+                            ::std::result::Result::Ok(())
+                        },
+                    )?;
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -373,7 +359,7 @@ pub mod recursive_type {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut b_a = None;
+                let mut c = None;
 
                 let mut __pilota_decoding_field_id = None;
 
@@ -389,12 +375,17 @@ pub mod recursive_type {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                b_a = Some(::std::boxed::Box::new(
-                                    ::pilota::thrift::Message::decode(__protocol)?,
-                                ));
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::Set => {
+                                c = Some({
+                                    let list_ident = __protocol.read_set_begin()?;
+                                    let mut val =
+                                        ::pilota::AHashSet::with_capacity(list_ident.size);
+                                    for _ in 0..list_ident.size {
+                                        val.insert(__protocol.read_faststr()?);
+                                    }
+                                    __protocol.read_set_end()?;
+                                    val
+                                });
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -408,7 +399,7 @@ pub mod recursive_type {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `B` field(#{}) failed, caused by: ",
+                            "decode struct `C` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -416,7 +407,7 @@ pub mod recursive_type {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { b_a };
+                let data = Self { c };
                 ::std::result::Result::Ok(data)
             }
 
@@ -431,7 +422,7 @@ pub mod recursive_type {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut b_a = None;
+                    let mut c = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -446,13 +437,18 @@ pub mod recursive_type {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::Set =>
                                 {
-                                    b_a = Some(::std::boxed::Box::new(
-                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?,
-                                    ));
+                                    c = Some({
+                                        let list_ident = __protocol.read_set_begin().await?;
+                                        let mut val =
+                                            ::pilota::AHashSet::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.insert(__protocol.read_faststr().await?);
+                                        }
+                                        __protocol.read_set_end().await?;
+                                        val
+                                    });
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -467,7 +463,7 @@ pub mod recursive_type {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `B` field(#{}) failed, caused by: ",
+                                "decode struct `C` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -475,7 +471,7 @@ pub mod recursive_type {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self { b_a };
+                    let data = Self { c };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -483,11 +479,15 @@ pub mod recursive_type {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
-                    + self
-                        .b_a
-                        .as_ref()
-                        .map_or(0, |value| __protocol.struct_field_len(Some(1), value))
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+                    + self.c.as_ref().map_or(0, |value| {
+                        __protocol.set_field_len(
+                            Some(1),
+                            ::pilota::thrift::TType::Binary,
+                            value,
+                            |__protocol, el| __protocol.faststr_len(el),
+                        )
+                    })
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
diff --git a/pilota-build/test_data/thrift/union.rs b/pilota-build/test_data/thrift/union.rs
index de977e60..e90138f8 100644
--- a/pilota-build/test_data/thrift/union.rs
+++ b/pilota-build/test_data/thrift/union.rs
@@ -169,108 +169,6 @@ pub mod union {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
-        pub enum Empty {}
-
-        impl ::pilota::thrift::Message for Empty {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol
-                    .write_struct_begin(&::pilota::thrift::TStructIdentifier { name: "Empty" })?;
-                match self {
-                    _ => {}
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Empty" })
-                    + match self {
-                        _ => 0,
-                    }
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
         pub struct A {
             pub u: ::std::option::Option<Union>,
@@ -418,5 +316,107 @@ pub mod union {
                     + __protocol.struct_end_len()
             }
         }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, Clone, PartialEq)]
+        pub enum Empty {}
+
+        impl ::pilota::thrift::Message for Empty {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol
+                    .write_struct_begin(&::pilota::thrift::TStructIdentifier { name: "Empty" })?;
+                match self {
+                    _ => {}
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Empty" })
+                    + match self {
+                        _ => 0,
+                    }
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
     }
 }
diff --git a/pilota-build/test_data/thrift/void.rs b/pilota-build/test_data/thrift/void.rs
index 9d8e1479..2631fe4e 100644
--- a/pilota-build/test_data/thrift/void.rs
+++ b/pilota-build/test_data/thrift/void.rs
@@ -104,9 +104,10 @@ pub mod void {
                     + __protocol.struct_end_len()
             }
         }
+        pub trait Test {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestTest123ArgsSend {}
-        impl ::pilota::thrift::Message for TestTest123ArgsSend {
+        pub struct TestTest123ArgsRecv {}
+        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -114,7 +115,7 @@ pub mod void {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -156,7 +157,7 @@ pub mod void {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -203,7 +204,7 @@ pub mod void {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -218,14 +219,14 @@ pub mod void {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, Default, Clone, PartialEq)]
-        pub struct TestTest123ArgsRecv {}
-        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
+        pub struct TestTest123ArgsSend {}
+        impl ::pilota::thrift::Message for TestTest123ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -233,7 +234,7 @@ pub mod void {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
+                    name: "TestTest123ArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -275,7 +276,7 @@ pub mod void {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -322,7 +323,7 @@ pub mod void {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -337,7 +338,7 @@ pub mod void {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
+                    name: "TestTest123ArgsSend",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -444,6 +445,5 @@ pub mod void {
                     + __protocol.struct_end_len()
             }
         }
-        pub trait Test {}
     }
 }
diff --git a/pilota-build/test_data/thrift/wrapper_arc.rs b/pilota-build/test_data/thrift/wrapper_arc.rs
index 52ddefb0..cb5c3adc 100644
--- a/pilota-build/test_data/thrift/wrapper_arc.rs
+++ b/pilota-build/test_data/thrift/wrapper_arc.rs
@@ -121,30 +121,23 @@ pub mod wrapper_arc {
                     + __protocol.struct_end_len()
             }
         }
-        pub trait TestService {}
-        #[derive(Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultRecv {
-            #[derivative(Default)]
-            Ok(Test),
+        #[derive(Debug, Default, Clone, PartialEq)]
+        pub struct TestServiceTestArgsRecv {
+            pub req: Test,
         }
-
-        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
+        impl ::pilota::thrift::Message for TestServiceTestArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
-                })?;
-                match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestArgsRecv",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -155,46 +148,54 @@ pub mod wrapper_arc {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut req = None;
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
                         }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(req) = req else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field req is required".to_string(),
+                    ));
+                };
+
+                let data = Self { req };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -208,46 +209,60 @@ pub mod wrapper_arc {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
+                    let mut req = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
                     __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    req = Some(
                                         <Test as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
-                                        .await?;
-
-                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -255,20 +270,17 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultRecv",
-                }) + match self {
-                    TestServiceTestResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                } + __protocol.field_stop_len()
+                    name: "TestServiceTestArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
         #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct TestServiceTestArgsRecv {
-            pub req: Test,
+        pub struct TestServiceTestArgsSend {
+            pub req: ::std::sync::Arc<Test>,
         }
-        impl ::pilota::thrift::Message for TestServiceTestArgsRecv {
+        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -276,7 +288,7 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsRecv",
+                    name: "TestServiceTestArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -311,7 +323,9 @@ pub mod wrapper_arc {
                             Some(1)
                                 if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                req = Some(::std::sync::Arc::new(
+                                    ::pilota::thrift::Message::decode(__protocol)?,
+                                ));
                             }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
@@ -324,7 +338,7 @@ pub mod wrapper_arc {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
@@ -370,12 +384,12 @@ pub mod wrapper_arc {
                                     if field_ident.field_type
                                         == ::pilota::thrift::TType::Struct =>
                                 {
-                                    req = Some(
+                                    req = Some(::std::sync::Arc::new(
                                         <Test as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
                                         .await?,
-                                    );
+                                    ));
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -389,7 +403,7 @@ pub mod wrapper_arc {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -413,7 +427,7 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsRecv",
+                    name: "TestServiceTestArgsSend",
                 }) + __protocol.struct_field_len(Some(1), &self.req)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
@@ -422,12 +436,12 @@ pub mod wrapper_arc {
         #[derive(Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(Clone, PartialEq)]
-        pub enum TestServiceTestResultSend {
+        pub enum TestServiceTestResultRecv {
             #[derivative(Default)]
-            Ok(::std::sync::Arc<Test>),
+            Ok(Test),
         }
 
-        impl ::pilota::thrift::Message for TestServiceTestResultSend {
+        impl ::pilota::thrift::Message for TestServiceTestResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -435,10 +449,10 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
+                    name: "TestServiceTestResultRecv",
                 })?;
                 match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
+                    TestServiceTestResultRecv::Ok(ref value) => {
                         __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
                     }
                 }
@@ -465,11 +479,9 @@ pub mod wrapper_arc {
                     match field_ident.id {
                         Some(0) => {
                             if ret.is_none() {
-                                let field_ident = ::std::sync::Arc::new(
-                                    ::pilota::thrift::Message::decode(__protocol)?,
-                                );
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
                                 __protocol.struct_len(&field_ident);
-                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                ret = Some(TestServiceTestResultRecv::Ok(field_ident));
                             } else {
                                 return ::std::result::Result::Err(
                                     ::pilota::thrift::new_protocol_exception(
@@ -518,14 +530,13 @@ pub mod wrapper_arc {
                         match field_ident.id {
                             Some(0) => {
                                 if ret.is_none() {
-                                    let field_ident = ::std::sync::Arc::new(
+                                    let field_ident =
                                         <Test as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
-                                        .await?,
-                                    );
+                                        .await?;
 
-                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                    ret = Some(TestServiceTestResultRecv::Ok(field_ident));
                                 } else {
                                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                                             ::pilota::thrift::ProtocolExceptionKind::InvalidData,
@@ -555,9 +566,9 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestResultSend",
+                    name: "TestServiceTestResultRecv",
                 }) + match self {
-                    TestServiceTestResultSend::Ok(ref value) => {
+                    TestServiceTestResultRecv::Ok(ref value) => {
                         __protocol.struct_field_len(Some(0), value)
                     }
                 } + __protocol.field_stop_len()
@@ -910,23 +921,30 @@ pub mod wrapper_arc {
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(Debug, Default, Clone, PartialEq)]
-        pub struct TestServiceTestArgsSend {
-            pub req: ::std::sync::Arc<Test>,
+        pub trait TestService {}
+        #[derive(Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(Clone, PartialEq)]
+        pub enum TestServiceTestResultSend {
+            #[derivative(Default)]
+            Ok(::std::sync::Arc<Test>),
         }
-        impl ::pilota::thrift::Message for TestServiceTestArgsSend {
+
+        impl ::pilota::thrift::Message for TestServiceTestResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestServiceTestResultSend",
+                })?;
+                match self {
+                    TestServiceTestResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -937,56 +955,48 @@ pub mod wrapper_arc {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut req = None;
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                req = Some(::std::sync::Arc::new(
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::std::sync::Arc::new(
                                     ::pilota::thrift::Message::decode(__protocol)?,
-                                ));
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                );
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let Some(req) = req else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
-                    ));
-                };
-
-                let data = Self { req };
-                ::std::result::Result::Ok(data)
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1000,60 +1010,47 @@ pub mod wrapper_arc {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut req = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    req = Some(::std::sync::Arc::new(
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident = ::std::sync::Arc::new(
                                         <Test as ::pilota::thrift::Message>::decode_async(
                                             __protocol,
                                         )
                                         .await?,
-                                    ));
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                                    );
+
+                                    ret = Some(TestServiceTestResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestServiceTestArgsSend` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let Some(req) = req else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { req };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
@@ -1061,9 +1058,12 @@ pub mod wrapper_arc {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestServiceTestArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
+                    name: "TestServiceTestResultSend",
+                }) + match self {
+                    TestServiceTestResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
diff --git a/pilota-build/test_data/unknown_fields.rs b/pilota-build/test_data/unknown_fields.rs
index a76d67d3..67181a1d 100644
--- a/pilota-build/test_data/unknown_fields.rs
+++ b/pilota-build/test_data/unknown_fields.rs
@@ -2,172 +2,6 @@ pub mod unknown_fields {
     #![allow(warnings, clippy::all)]
 
     pub mod must_gen_items {
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct A {
-            pub a: ::std::option::Option<i32>,
-            pub _unknown_fields: ::pilota::LinkedBytes,
-        }
-        impl ::pilota::thrift::Message for A {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.a.as_ref() {
-                    __protocol.write_i32_field(1, *value)?;
-                }
-                for bytes in self._unknown_fields.list.iter() {
-                    __protocol.write_bytes_without_len(bytes.clone());
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut a = None;
-                let mut _unknown_fields = ::pilota::LinkedBytes::new();
-
-                let mut __pilota_decoding_field_id = None;
-
-                __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let mut __pilota_offset = 0;
-                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __pilota_offset += __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __pilota_offset +=
-                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
-                                a = Some(__protocol.read_i32()?);
-                            }
-                            _ => {
-                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                                _unknown_fields.push_back(
-                                    __protocol
-                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
-                                );
-                            }
-                        }
-
-                        __protocol.read_field_end()?;
-                        __pilota_offset += __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `A` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
-
-                let data = Self { a, _unknown_fields };
-                ::std::result::Result::Ok(data)
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut a = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
-                                {
-                                    a = Some(__protocol.read_i32().await?);
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `A` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let data = Self {
-                        a,
-                        _unknown_fields: ::pilota::LinkedBytes::new(),
-                    };
-                    ::std::result::Result::Ok(data)
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
-                    + self
-                        .a
-                        .as_ref()
-                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
-                    + self._unknown_fields.size()
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
         #[derive(
             PartialOrd,
             Hash,
@@ -340,9 +174,6 @@ pub mod unknown_fields {
                     + __protocol.struct_end_len()
             }
         }
-    }
-
-    pub mod unknown_fields {
         #[derive(
             PartialOrd,
             Hash,
@@ -356,9 +187,7 @@ pub mod unknown_fields {
             PartialEq,
         )]
         pub struct A {
-            pub bytes: ::pilota::Bytes,
-
-            pub vec: ::std::vec::Vec<u8>,
+            pub a: ::std::option::Option<i32>,
             pub _unknown_fields: ::pilota::LinkedBytes,
         }
         impl ::pilota::thrift::Message for A {
@@ -371,8 +200,9 @@ pub mod unknown_fields {
                 let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_bytes_field(1, (&self.bytes).clone())?;
-                __protocol.write_bytes_vec_field(2, &self.vec)?;
+                if let Some(value) = self.a.as_ref() {
+                    __protocol.write_i32_field(1, *value)?;
+                }
                 for bytes in self._unknown_fields.list.iter() {
                     __protocol.write_bytes_without_len(bytes.clone());
                 }
@@ -387,8 +217,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut bytes = None;
-                let mut vec = None;
+                let mut a = None;
                 let mut _unknown_fields = ::pilota::LinkedBytes::new();
 
                 let mut __pilota_decoding_field_id = None;
@@ -408,15 +237,8 @@ pub mod unknown_fields {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                bytes = Some(__protocol.read_bytes()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                vec = Some(__protocol.read_bytes_vec()?);
+                            Some(1) if field_ident.field_type == ::pilota::thrift::TType::I32 => {
+                                a = Some(__protocol.read_i32()?);
                             }
                             _ => {
                                 __pilota_offset += __protocol.skip(field_ident.field_type)?;
@@ -442,24 +264,7 @@ pub mod unknown_fields {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(bytes) = bytes else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field bytes is required".to_string(),
-                    ));
-                };
-                let Some(vec) = vec else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field vec is required".to_string(),
-                    ));
-                };
-
-                let data = Self {
-                    bytes,
-                    vec,
-                    _unknown_fields,
-                };
+                let data = Self { a, _unknown_fields };
                 ::std::result::Result::Ok(data)
             }
 
@@ -474,8 +279,7 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut bytes = None;
-                    let mut vec = None;
+                    let mut a = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -490,16 +294,9 @@ pub mod unknown_fields {
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
                                 Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    bytes = Some(__protocol.read_bytes().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                    if field_ident.field_type == ::pilota::thrift::TType::I32 =>
                                 {
-                                    vec = Some(__protocol.read_bytes_vec().await?);
+                                    a = Some(__protocol.read_i32().await?);
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -522,26 +319,8 @@ pub mod unknown_fields {
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(bytes) = bytes else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field bytes is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(vec) = vec else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field vec is required".to_string(),
-                            ),
-                        );
-                    };
-
                     let data = Self {
-                        bytes,
-                        vec,
+                        a,
                         _unknown_fields: ::pilota::LinkedBytes::new(),
                     };
                     ::std::result::Result::Ok(data)
@@ -552,13 +331,18 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
-                    + __protocol.bytes_field_len(Some(1), &self.bytes)
-                    + __protocol.bytes_vec_field_len(Some(2), &self.vec)
+                    + self
+                        .a
+                        .as_ref()
+                        .map_or(0, |value| __protocol.i32_field_len(Some(1), *value))
                     + self._unknown_fields.size()
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
+    }
+
+    pub mod unknown_fields {
         #[derive(
             PartialOrd,
             Hash,
@@ -742,8 +526,188 @@ pub mod unknown_fields {
                     + __protocol.struct_end_len()
             }
         }
-        pub trait Test {}
-        #[derive(
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
+        pub enum TestTestExceptionResultRecv {
+            #[derivative(Default)]
+            Ok(ObjReq),
+
+            StException(StException),
+        }
+
+        impl ::pilota::thrift::Message for TestTestExceptionResultRecv {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultRecv",
+                })?;
+                match self {
+                    TestTestExceptionResultRecv::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestTestExceptionResultRecv::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultRecv::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionResultRecv::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultRecv",
+                }) + match self {
+                    TestTestExceptionResultRecv::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                    TestTestExceptionResultRecv::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(
             PartialOrd,
             Hash,
             Eq,
@@ -755,20 +719,22 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct TestTest123ArgsSend {}
-        impl ::pilota::thrift::Message for TestTest123ArgsSend {
+        pub struct ObjReq {
+            pub _unknown_fields: ::pilota::LinkedBytes,
+        }
+        impl ::pilota::thrift::Message for ObjReq {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ObjReq" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-
+                for bytes in self._unknown_fields.list.iter() {
+                    __protocol.write_bytes_without_len(bytes.clone());
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -780,33 +746,49 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
+                let mut __pilota_fields_num = 0;
+                let mut _unknown_fields = ::pilota::LinkedBytes::new();
+
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
                 if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
+                        if __pilota_fields_num == 0 {
+                            let __pilota_remaining = __protocol.buf().remaining();
+                            _unknown_fields
+                                .push_back(__protocol.get_bytes(None, __pilota_remaining - 2)?);
+                            break;
+                        }
+                        let mut __pilota_offset = 0;
+                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
                         let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
+                            __pilota_offset += __protocol.field_stop_len();
                             break;
                         } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                            __pilota_offset +=
+                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                                _unknown_fields.push_back(
+                                    __protocol
+                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
+                                );
                             }
                         }
 
                         __protocol.read_field_end()?;
-                        __protocol.field_end_len();
+                        __pilota_offset += __protocol.field_end_len();
                     }
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
+                            "decode struct `ObjReq` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -814,7 +796,7 @@ pub mod unknown_fields {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {};
+                let data = Self { _unknown_fields };
                 ::std::result::Result::Ok(data)
             }
 
@@ -853,13 +835,18 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!(
+                                "decode struct `ObjReq` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {};
+                    let data = Self {
+                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -867,61 +854,220 @@ pub mod unknown_fields {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
-                }) + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ObjReq" })
+                    + self._unknown_fields.size()
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        pub const TEST_LIST: [&'static str; 2] = ["hello", "world"];
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct B {
-            pub faststr: ::pilota::FastStr,
-
-            pub string: ::std::string::String,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
+        pub enum TestTestExceptionResultSend {
+            #[derivative(Default)]
+            Ok(ObjReq),
 
-            pub list: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>,
+            StException(StException),
+        }
+
+        impl ::pilota::thrift::Message for TestTestExceptionResultSend {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultSend",
+                })?;
+                match self {
+                    TestTestExceptionResultSend::Ok(ref value) => {
+                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestTestExceptionResultSend::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                }
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let mut ret = None;
+                __protocol.read_struct_begin()?;
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(0) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultSend::Ok(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionResultSend::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(0) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret = Some(TestTestExceptionResultSend::Ok(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionResultSend::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
+                        }
+                    }
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionResultSend",
+                }) + match self {
+                    TestTestExceptionResultSend::Ok(ref value) => {
+                        __protocol.struct_field_len(Some(0), value)
+                    }
+                    TestTestExceptionResultSend::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct C {
+            pub a: super::must_gen_items::A,
             pub _unknown_fields: ::pilota::LinkedBytes,
         }
-        impl ::pilota::thrift::Message for B {
+        impl ::pilota::thrift::Message for C {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_faststr_field(1, (&self.faststr).clone())?;
-                __protocol.write_string_field(2, &self.string)?;
-                __protocol.write_list_field(
-                    3,
-                    ::pilota::thrift::TType::List,
-                    &&self.list,
-                    |__protocol, val| {
-                        __protocol.write_list(
-                            ::pilota::thrift::TType::Binary,
-                            &val,
-                            |__protocol, val| {
-                                __protocol.write_faststr((val).clone())?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
+                __protocol.write_struct_field(1, &self.a, ::pilota::thrift::TType::Struct)?;
                 for bytes in self._unknown_fields.list.iter() {
                     __protocol.write_bytes_without_len(bytes.clone());
                 }
@@ -936,9 +1082,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut faststr = None;
-                let mut string = None;
-                let mut list = None;
+                let mut a = None;
                 let mut _unknown_fields = ::pilota::LinkedBytes::new();
 
                 let mut __pilota_decoding_field_id = None;
@@ -959,39 +1103,9 @@ pub mod unknown_fields {
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
-                            {
-                                faststr = Some(__protocol.read_faststr()?);
-                            }
-                            Some(2)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                string = Some(__protocol.read_string()?);
-                            }
-                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
-                                list = Some(unsafe {
-                                    let list_ident = __protocol.read_list_begin()?;
-                                    let mut val: Vec<::std::vec::Vec<::pilota::FastStr>> =
-                                        Vec::with_capacity(list_ident.size);
-                                    for i in 0..list_ident.size {
-                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
-                                            let list_ident = __protocol.read_list_begin()?;
-                                            let mut val: Vec<::pilota::FastStr> =
-                                                Vec::with_capacity(list_ident.size);
-                                            for i in 0..list_ident.size {
-                                                val.as_mut_ptr()
-                                                    .offset(i as isize)
-                                                    .write(__protocol.read_faststr()?);
-                                            }
-                                            val.set_len(list_ident.size);
-                                            __protocol.read_list_end()?;
-                                            val
-                                        });
-                                    }
-                                    val.set_len(list_ident.size);
-                                    __protocol.read_list_end()?;
-                                    val
-                                });
+                                a = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
                                 __pilota_offset += __protocol.skip(field_ident.field_type)?;
@@ -1009,7 +1123,7 @@ pub mod unknown_fields {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `B` field(#{}) failed, caused by: ",
+                            "decode struct `C` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1017,31 +1131,14 @@ pub mod unknown_fields {
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(faststr) = faststr else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field faststr is required".to_string(),
-                    ));
-                };
-                let Some(string) = string else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field string is required".to_string(),
-                    ));
-                };
-                let Some(list) = list else {
+                let Some(a) = a else {
                     return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field list is required".to_string(),
+                        "field a is required".to_string(),
                     ));
                 };
 
-                let data = Self {
-                    faststr,
-                    string,
-                    list,
-                    _unknown_fields,
-                };
+                let data = Self { a, _unknown_fields };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1056,106 +1153,58 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut faststr = None;
-                    let mut string = None;
-                    let mut list = None;
+                    let mut a = None;
 
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
                     if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    faststr = Some(__protocol.read_faststr().await?);
-                                }
-                                Some(2)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
-                                {
-                                    string = Some(__protocol.read_string().await?);
-                                }
-                                Some(3)
-                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
-                                {
-                                    list = Some({
-                                        let list_ident = __protocol.read_list_begin().await?;
-                                        let mut val = Vec::with_capacity(list_ident.size);
-                                        for _ in 0..list_ident.size {
-                                            val.push({
-                                                let list_ident =
-                                                    __protocol.read_list_begin().await?;
-                                                let mut val = Vec::with_capacity(list_ident.size);
-                                                for _ in 0..list_ident.size {
-                                                    val.push(__protocol.read_faststr().await?);
-                                                }
-                                                __protocol.read_list_end().await?;
-                                                val
-                                            });
-                                        }
-                                        __protocol.read_list_end().await?;
-                                        val
-                                    });
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
+                    loop {
 
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `B` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+
+                let field_ident = __protocol.read_field_begin().await?;
+                if field_ident.field_type == ::pilota::thrift::TType::Stop {
+
+                    break;
+                } else {
+
+                }
+                __pilota_decoding_field_id = field_ident.id;
+                match field_ident.id {
+                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
+                    a = Some(<super::must_gen_items::A as ::pilota::thrift::Message>::decode_async(__protocol).await?);
+
+                },
+                    _ => {
+                        __protocol.skip(field_ident.field_type).await?;
+
+                    },
+                }
+
+                __protocol.read_field_end().await?;
+
+
+            };
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                }.await {
+                if let Some(field_id) = __pilota_decoding_field_id {
+                    err.prepend_msg(&format!("decode struct `C` field(#{}) failed, caused by: ", field_id));
+                }
+                return ::std::result::Result::Err(err);
+            };
                     __protocol.read_struct_end().await?;
 
-                    let Some(faststr) = faststr else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field faststr is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(string) = string else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field string is required".to_string(),
-                            ),
-                        );
-                    };
-                    let Some(list) = list else {
+                    let Some(a) = a else {
                         return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field list is required".to_string(),
+                                "field a is required".to_string(),
                             ),
                         );
                     };
 
                     let data = Self {
-                        faststr,
-                        string,
-                        list,
+                        a,
                         _unknown_fields: ::pilota::LinkedBytes::new(),
                     };
                     ::std::result::Result::Ok(data)
@@ -1165,53 +1214,35 @@ pub mod unknown_fields {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
-                    + __protocol.faststr_field_len(Some(1), &self.faststr)
-                    + __protocol.string_field_len(Some(2), &&self.string)
-                    + __protocol.list_field_len(
-                        Some(3),
-                        ::pilota::thrift::TType::List,
-                        &self.list,
-                        |__protocol, el| {
-                            __protocol.list_len(
-                                ::pilota::thrift::TType::Binary,
-                                el,
-                                |__protocol, el| __protocol.faststr_len(el),
-                            )
-                        },
-                    )
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
+                    + __protocol.struct_field_len(Some(1), &self.a)
                     + self._unknown_fields.size()
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct SubMessage {
-            pub _unknown_fields: ::pilota::LinkedBytes,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
+        pub enum TestTestExceptionException {
+            #[derivative(Default)]
+            StException(StException),
         }
-        impl ::pilota::thrift::Message for SubMessage {
+
+        impl ::pilota::thrift::Message for TestTestExceptionException {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "SubMessage" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                for bytes in self._unknown_fields.list.iter() {
-                    __protocol.write_bytes_without_len(bytes.clone());
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionException",
+                })?;
+                match self {
+                    TestTestExceptionException::StException(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1223,52 +1254,46 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut _unknown_fields = ::pilota::LinkedBytes::new();
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let mut __pilota_offset = 0;
-                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __pilota_offset += __protocol.field_stop_len();
-                            break;
-                        } else {
-                            __pilota_offset +=
-                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                        }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            _ => {
-                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                                _unknown_fields.push_back(
-                                    __protocol
-                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __protocol.struct_len(&field_ident);
+                                ret = Some(TestTestExceptionException::StException(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
                                 );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __pilota_offset += __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `SubMessage` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self { _unknown_fields };
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1282,53 +1307,60 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <StException as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?;
+
+                                    ret =
+                                        Some(TestTestExceptionException::StException(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
-
-                            __protocol.read_field_end().await?;
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `SubMessage` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self {
-                        _unknown_fields: ::pilota::LinkedBytes::new(),
-                    };
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SubMessage" })
-                    + self._unknown_fields.size()
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionException",
+                }) + match self {
+                    TestTestExceptionException::StException(ref value) => {
+                        __protocol.struct_field_len(Some(1), value)
+                    }
+                } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
@@ -1344,11 +1376,10 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct StException {
-            pub message: ::std::option::Option<::pilota::FastStr>,
-            pub _unknown_fields: ::pilota::LinkedBytes,
+        pub struct TestTestExceptionArgsRecv {
+            pub req: ObjReq,
         }
-        impl ::pilota::thrift::Message for StException {
+        impl ::pilota::thrift::Message for TestTestExceptionArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -1356,16 +1387,11 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "STException",
+                    name: "TestTestExceptionArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                if let Some(value) = self.message.as_ref() {
-                    __protocol.write_faststr_field(1, (value).clone())?;
-                }
-                for bytes in self._unknown_fields.list.iter() {
-                    __protocol.write_bytes_without_len(bytes.clone());
-                }
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1377,59 +1403,52 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut message = None;
-                let mut _unknown_fields = ::pilota::LinkedBytes::new();
+                let mut req = None;
 
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
                 if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
-                        let mut __pilota_offset = 0;
-                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
                         let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __pilota_offset += __protocol.field_stop_len();
+                            __protocol.field_stop_len();
                             break;
                         } else {
-                            __pilota_offset +=
-                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
                             {
-                                message = Some(__protocol.read_faststr()?);
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
                             }
                             _ => {
-                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                                _unknown_fields.push_back(
-                                    __protocol
-                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
-                                );
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
 
                         __protocol.read_field_end()?;
-                        __pilota_offset += __protocol.field_end_len();
+                        __protocol.field_end_len();
                     }
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `STException` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self {
-                    message,
-                    _unknown_fields,
+                let Some(req) = req else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field req is required".to_string(),
+                    ));
                 };
+
+                let data = Self { req };
                 ::std::result::Result::Ok(data)
             }
 
@@ -1444,7 +1463,7 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut message = None;
+                    let mut req = None;
 
                     let mut __pilota_decoding_field_id = None;
 
@@ -1460,9 +1479,14 @@ pub mod unknown_fields {
                             match field_ident.id {
                                 Some(1)
                                     if field_ident.field_type
-                                        == ::pilota::thrift::TType::Binary =>
+                                        == ::pilota::thrift::TType::Struct =>
                                 {
-                                    message = Some(__protocol.read_faststr().await?);
+                                    req = Some(
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
                                 }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
@@ -1476,19 +1500,22 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `STException` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        message,
-                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field req is required".to_string(),
+                            ),
+                        );
                     };
+
+                    let data = Self { req };
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1497,42 +1524,53 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "STException",
-                }) + self
-                    .message
-                    .as_ref()
-                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
-                    + self._unknown_fields.size()
+                    name: "TestTestExceptionArgsRecv",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct TestTest123ArgsRecv {}
-        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
+        ::pilota::lazy_static::lazy_static! {
+            pub static ref TEST_MAP_LIST: ::pilota::AHashMap<i32, ::std::vec::Vec<&'static str>> = {
+            let mut map = ::pilota::AHashMap::with_capacity(1);
+            map.insert(1i32, ::std::vec!["hello"]);
+            map
+        };
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
+        pub enum TestUnion {
+            #[derivative(Default)]
+            A(A),
+
+            B(B),
+            _UnknownFields(::pilota::LinkedBytes),
+        }
+
+        impl ::pilota::thrift::Message for TestUnion {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
-                };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestUnion",
+                })?;
+                match self {
+                    TestUnion::A(ref value) => {
+                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestUnion::B(ref value) => {
+                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
+                    }
+                    TestUnion::_UnknownFields(ref value) => {
+                        for bytes in value.list.iter() {
+                            __protocol.write_bytes_without_len(bytes.clone());
+                        }
+                    }
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1543,43 +1581,80 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
-                    loop {
-                        let field_ident = __protocol.read_field_begin()?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
-                            break;
-                        } else {
+                loop {
+                    let mut __pilota_offset = 0;
+                    let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __pilota_offset += __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __pilota_offset +=
                             __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        Some(1) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __pilota_offset += __protocol.struct_len(&field_ident);
+                                ret = Some(TestUnion::A(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
                         }
-                        __pilota_decoding_field_id = field_ident.id;
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                        Some(2) => {
+                            if ret.is_none() {
+                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
+                                __pilota_offset += __protocol.struct_len(&field_ident);
+                                ret = Some(TestUnion::B(field_ident));
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
+                            }
+                        }
+                        _ => {
+                            __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                            if ret.is_none() {
+                                unsafe {
+                                    let mut __pilota_linked_bytes = ::pilota::LinkedBytes::new();
+                                    __pilota_linked_bytes.push_back(
+                                        __protocol
+                                            .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
+                                    );
+                                    ret = Some(TestUnion::_UnknownFields(__pilota_linked_bytes));
+                                }
+                            } else {
+                                return ::std::result::Result::Err(
+                                    ::pilota::thrift::new_protocol_exception(
+                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                        "received multiple fields for union from remote Message",
+                                    ),
+                                );
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
                     }
-                    return ::std::result::Result::Err(err);
-                };
+                }
+                __protocol.read_field_end()?;
                 __protocol.read_struct_end()?;
-
-                let data = Self {};
-                ::std::result::Result::Ok(data)
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "received empty union from remote Message",
+                    ))
+                }
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1593,86 +1668,95 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut __pilota_decoding_field_id = None;
-
+                    let mut ret = None;
                     __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
+                    loop {
+                        let field_ident = __protocol.read_field_begin().await?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            break;
+                        } else {
+                        }
+                        match field_ident.id {
+                            Some(1) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?;
+
+                                    ret = Some(TestUnion::A(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
                                 }
                             }
+                            Some(2) => {
+                                if ret.is_none() {
+                                    let field_ident =
+                                        <B as ::pilota::thrift::Message>::decode_async(__protocol)
+                                            .await?;
 
-                            __protocol.read_field_end().await?;
+                                    ret = Some(TestUnion::B(field_ident));
+                                } else {
+                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                            "received multiple fields for union from remote Message"
+                                        ));
+                                }
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type).await?;
+                            }
                         }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
+                    __protocol.read_field_end().await?;
                     __protocol.read_struct_end().await?;
-
-                    let data = Self {};
-                    ::std::result::Result::Ok(data)
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            "received empty union from remote Message",
+                        ))
+                    }
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
-                }) + __protocol.field_stop_len()
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "TestUnion" })
+                    + match self {
+                        TestUnion::A(ref value) => __protocol.struct_field_len(Some(1), value),
+                        TestUnion::B(ref value) => __protocol.struct_field_len(Some(2), value),
+                        TestUnion::_UnknownFields(ref value) => value.size(),
+                    }
+                    + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        ::pilota::lazy_static::lazy_static! {
-            pub static ref TEST_MAP_LIST: ::pilota::AHashMap<i32, ::std::vec::Vec<&'static str>> = {
-            let mut map = ::pilota::AHashMap::with_capacity(1);
-            map.insert(1i32, ::std::vec!["hello"]);
-            map
-        };
-        }
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct C {
-            pub a: super::must_gen_items::A,
-            pub _unknown_fields: ::pilota::LinkedBytes,
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
+        pub enum TestTest123ResultSend {
+            #[derivative(Default)]
+            Ok(()),
         }
-        impl ::pilota::thrift::Message for C {
+
+        impl ::pilota::thrift::Message for TestTest123ResultSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "C" };
-
-                __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.a, ::pilota::thrift::TType::Struct)?;
-                for bytes in self._unknown_fields.list.iter() {
-                    __protocol.write_bytes_without_len(bytes.clone());
+                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ResultSend",
+                })?;
+                match self {
+                    TestTest123ResultSend::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -1684,65 +1768,158 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-
-                let mut a = None;
-                let mut _unknown_fields = ::pilota::LinkedBytes::new();
-
-                let mut __pilota_decoding_field_id = None;
-
+                let mut ret = None;
                 __protocol.read_struct_begin()?;
-                if let ::std::result::Result::Err(mut err) = (|| {
+                loop {
+                    let field_ident = __protocol.read_field_begin()?;
+                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                        __protocol.field_stop_len();
+                        break;
+                    } else {
+                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                    }
+                    match field_ident.id {
+                        _ => {
+                            __protocol.skip(field_ident.field_type)?;
+                        }
+                    }
+                }
+                __protocol.read_field_end()?;
+                __protocol.read_struct_end()?;
+                if let Some(ret) = ret {
+                    ::std::result::Result::Ok(ret)
+                } else {
+                    ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
+                }
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut ret = None;
+                    __protocol.read_struct_begin().await?;
                     loop {
-                        let mut __pilota_offset = 0;
-                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
-                        let field_ident = __protocol.read_field_begin()?;
+                        let field_ident = __protocol.read_field_begin().await?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __pilota_offset += __protocol.field_stop_len();
                             break;
                         } else {
-                            __pilota_offset +=
-                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                a = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
                             _ => {
-                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                                _unknown_fields.push_back(
-                                    __protocol
-                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
-                                );
+                                __protocol.skip(field_ident.field_type).await?;
                             }
                         }
-
-                        __protocol.read_field_end()?;
-                        __pilota_offset += __protocol.field_end_len();
                     }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!(
-                            "decode struct `C` field(#{}) failed, caused by: ",
-                            field_id
-                        ));
+                    __protocol.read_field_end().await?;
+                    __protocol.read_struct_end().await?;
+                    if let Some(ret) = ret {
+                        ::std::result::Result::Ok(ret)
+                    } else {
+                        ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
                     }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
+                })
+            }
 
-                let Some(a) = a else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field a is required".to_string(),
-                    ));
-                };
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ResultSend",
+                }) + match self {
+                    TestTest123ResultSend::Ok(ref value) => 0,
+                } + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct Td(pub ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>);
 
-                let data = Self { a, _unknown_fields };
-                ::std::result::Result::Ok(data)
+        impl ::std::ops::Deref for Td {
+            type Target = ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>;
+
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
+
+        impl From<::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>> for Td {
+            fn from(v: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>) -> Self {
+                Self(v)
+            }
+        }
+
+        impl ::pilota::thrift::Message for Td {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_list(
+                    ::pilota::thrift::TType::List,
+                    &(&**self),
+                    |__protocol, val| {
+                        __protocol.write_list(
+                            ::pilota::thrift::TType::Binary,
+                            &val,
+                            |__protocol, val| {
+                                __protocol.write_faststr((val).clone())?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                ::std::result::Result::Ok(())
+            }
+
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                ::std::result::Result::Ok(Td(unsafe {
+                    let list_ident = __protocol.read_list_begin()?;
+                    let mut val: Vec<::std::vec::Vec<::pilota::FastStr>> =
+                        Vec::with_capacity(list_ident.size);
+                    for i in 0..list_ident.size {
+                        val.as_mut_ptr().offset(i as isize).write(unsafe {
+                            let list_ident = __protocol.read_list_begin()?;
+                            let mut val: Vec<::pilota::FastStr> =
+                                Vec::with_capacity(list_ident.size);
+                            for i in 0..list_ident.size {
+                                val.as_mut_ptr()
+                                    .offset(i as isize)
+                                    .write(__protocol.read_faststr()?);
+                            }
+                            val.set_len(list_ident.size);
+                            __protocol.read_list_end()?;
+                            val
+                        });
+                    }
+                    val.set_len(list_ident.size);
+                    __protocol.read_list_end()?;
+                    val
+                }))
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -1756,72 +1933,34 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut a = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                    loop {
-
-
-                let field_ident = __protocol.read_field_begin().await?;
-                if field_ident.field_type == ::pilota::thrift::TType::Stop {
-
-                    break;
-                } else {
-
-                }
-                __pilota_decoding_field_id = field_ident.id;
-                match field_ident.id {
-                    Some(1) if field_ident.field_type == ::pilota::thrift::TType::Struct  => {
-                    a = Some(<super::must_gen_items::A as ::pilota::thrift::Message>::decode_async(__protocol).await?);
-
-                },
-                    _ => {
-                        __protocol.skip(field_ident.field_type).await?;
-
-                    },
-                }
-
-                __protocol.read_field_end().await?;
-
-
-            };
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                }.await {
-                if let Some(field_id) = __pilota_decoding_field_id {
-                    err.prepend_msg(&format!("decode struct `C` field(#{}) failed, caused by: ", field_id));
-                }
-                return ::std::result::Result::Err(err);
-            };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(a) = a else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field a is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self {
-                        a,
-                        _unknown_fields: ::pilota::LinkedBytes::new(),
-                    };
-                    ::std::result::Result::Ok(data)
+                    ::std::result::Result::Ok(Td({
+                        let list_ident = __protocol.read_list_begin().await?;
+                        let mut val = Vec::with_capacity(list_ident.size);
+                        for _ in 0..list_ident.size {
+                            val.push({
+                                let list_ident = __protocol.read_list_begin().await?;
+                                let mut val = Vec::with_capacity(list_ident.size);
+                                for _ in 0..list_ident.size {
+                                    val.push(__protocol.read_faststr().await?);
+                                }
+                                __protocol.read_list_end().await?;
+                                val
+                            });
+                        }
+                        __protocol.read_list_end().await?;
+                        val
+                    }))
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "C" })
-                    + __protocol.struct_field_len(Some(1), &self.a)
-                    + self._unknown_fields.size()
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
+                __protocol.list_len(::pilota::thrift::TType::List, &**self, |__protocol, el| {
+                    __protocol.list_len(::pilota::thrift::TType::Binary, el, |__protocol, el| {
+                        __protocol.faststr_len(el)
+                    })
+                })
             }
         }
         #[derive(
@@ -1836,22 +1975,20 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct Message {
-            pub _unknown_fields: ::pilota::LinkedBytes,
-        }
-        impl ::pilota::thrift::Message for Message {
+        pub struct TestTest123ArgsRecv {}
+        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Message" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ArgsRecv",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                for bytes in self._unknown_fields.list.iter() {
-                    __protocol.write_bytes_without_len(bytes.clone());
-                }
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -1863,42 +2000,33 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut _unknown_fields = ::pilota::LinkedBytes::new();
-
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
                 if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
-                        let mut __pilota_offset = 0;
-                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
                         let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __pilota_offset += __protocol.field_stop_len();
+                            __protocol.field_stop_len();
                             break;
                         } else {
-                            __pilota_offset +=
-                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             _ => {
-                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                                _unknown_fields.push_back(
-                                    __protocol
-                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
-                                );
+                                __protocol.skip(field_ident.field_type)?;
                             }
                         }
 
                         __protocol.read_field_end()?;
-                        __pilota_offset += __protocol.field_end_len();
+                        __protocol.field_end_len();
                     }
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `Message` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -1906,7 +2034,7 @@ pub mod unknown_fields {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { _unknown_fields };
+                let data = Self {};
                 ::std::result::Result::Ok(data)
             }
 
@@ -1945,18 +2073,13 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!(
-                                "decode struct `Message` field(#{}) failed, caused by: ",
-                                field_id
-                            ));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let data = Self {
-                        _unknown_fields: ::pilota::LinkedBytes::new(),
-                    };
+                    let data = Self {};
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -1964,46 +2087,39 @@ pub mod unknown_fields {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Message" })
-                    + self._unknown_fields.size()
-                    + __protocol.field_stop_len()
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTest123ArgsRecv",
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestUnion {
-            #[derivative(Default)]
-            A(A),
-
-            B(B),
-            _UnknownFields(::pilota::LinkedBytes),
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct Message {
+            pub _unknown_fields: ::pilota::LinkedBytes,
         }
-
-        impl ::pilota::thrift::Message for TestUnion {
+        impl ::pilota::thrift::Message for Message {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestUnion",
-                })?;
-                match self {
-                    TestUnion::A(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestUnion::B(ref value) => {
-                        __protocol.write_struct_field(2, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestUnion::_UnknownFields(ref value) => {
-                        for bytes in value.list.iter() {
-                            __protocol.write_bytes_without_len(bytes.clone());
-                        }
-                    }
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "Message" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                for bytes in self._unknown_fields.list.iter() {
+                    __protocol.write_bytes_without_len(bytes.clone());
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2015,80 +2131,52 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut _unknown_fields = ::pilota::LinkedBytes::new();
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let mut __pilota_offset = 0;
-                    let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __pilota_offset += __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __pilota_offset +=
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __pilota_offset += __protocol.struct_len(&field_ident);
-                                ret = Some(TestUnion::A(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(2) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __pilota_offset += __protocol.struct_len(&field_ident);
-                                ret = Some(TestUnion::B(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let mut __pilota_offset = 0;
+                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __pilota_offset += __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __pilota_offset +=
+                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
-                        _ => {
-                            __pilota_offset += __protocol.skip(field_ident.field_type)?;
-                            if ret.is_none() {
-                                unsafe {
-                                    let mut __pilota_linked_bytes = ::pilota::LinkedBytes::new();
-                                    __pilota_linked_bytes.push_back(
-                                        __protocol
-                                            .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
-                                    );
-                                    ret = Some(TestUnion::_UnknownFields(__pilota_linked_bytes));
-                                }
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            _ => {
+                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                                _unknown_fields.push_back(
+                                    __protocol
+                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
                                 );
                             }
                         }
+
+                        __protocol.read_field_end()?;
+                        __pilota_offset += __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `Message` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+
+                let data = Self { _unknown_fields };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -2102,58 +2190,43 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <A as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?;
+                    let mut __pilota_decoding_field_id = None;
 
-                                    ret = Some(TestUnion::A(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
                             }
-                            Some(2) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <B as ::pilota::thrift::Message>::decode_async(__protocol)
-                                            .await?;
-
-                                    ret = Some(TestUnion::B(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                    __protocol.read_field_end().await?;
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `Message` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
+
+                    let data = Self {
+                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
@@ -2161,38 +2234,62 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol
-                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "TestUnion" })
-                    + match self {
-                        TestUnion::A(ref value) => __protocol.struct_field_len(Some(1), value),
-                        TestUnion::B(ref value) => __protocol.struct_field_len(Some(2), value),
-                        TestUnion::_UnknownFields(ref value) => value.size(),
-                    }
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "Message" })
+                    + self._unknown_fields.size()
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestTestExceptionException {
-            #[derivative(Default)]
-            StException(StException),
-        }
-
-        impl ::pilota::thrift::Message for TestTestExceptionException {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionException",
-                })?;
-                match self {
-                    TestTestExceptionException::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct B {
+            pub faststr: ::pilota::FastStr,
+
+            pub string: ::std::string::String,
+
+            pub list: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>,
+            pub _unknown_fields: ::pilota::LinkedBytes,
+        }
+        impl ::pilota::thrift::Message for B {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "B" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_faststr_field(1, (&self.faststr).clone())?;
+                __protocol.write_string_field(2, &self.string)?;
+                __protocol.write_list_field(
+                    3,
+                    ::pilota::thrift::TType::List,
+                    &&self.list,
+                    |__protocol, val| {
+                        __protocol.write_list(
+                            ::pilota::thrift::TType::Binary,
+                            &val,
+                            |__protocol, val| {
+                                __protocol.write_faststr((val).clone())?;
+                                ::std::result::Result::Ok(())
+                            },
+                        )?;
+                        ::std::result::Result::Ok(())
+                    },
+                )?;
+                for bytes in self._unknown_fields.list.iter() {
+                    __protocol.write_bytes_without_len(bytes.clone());
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -2204,46 +2301,114 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
+
+                let mut faststr = None;
+                let mut string = None;
+                let mut list = None;
+                let mut _unknown_fields = ::pilota::LinkedBytes::new();
+
+                let mut __pilota_decoding_field_id = None;
+
                 __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionException::StException(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let mut __pilota_offset = 0;
+                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __pilota_offset += __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __pilota_offset +=
+                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                faststr = Some(__protocol.read_faststr()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                string = Some(__protocol.read_string()?);
+                            }
+                            Some(3) if field_ident.field_type == ::pilota::thrift::TType::List => {
+                                list = Some(unsafe {
+                                    let list_ident = __protocol.read_list_begin()?;
+                                    let mut val: Vec<::std::vec::Vec<::pilota::FastStr>> =
+                                        Vec::with_capacity(list_ident.size);
+                                    for i in 0..list_ident.size {
+                                        val.as_mut_ptr().offset(i as isize).write(unsafe {
+                                            let list_ident = __protocol.read_list_begin()?;
+                                            let mut val: Vec<::pilota::FastStr> =
+                                                Vec::with_capacity(list_ident.size);
+                                            for i in 0..list_ident.size {
+                                                val.as_mut_ptr()
+                                                    .offset(i as isize)
+                                                    .write(__protocol.read_faststr()?);
+                                            }
+                                            val.set_len(list_ident.size);
+                                            __protocol.read_list_end()?;
+                                            val
+                                        });
+                                    }
+                                    val.set_len(list_ident.size);
+                                    __protocol.read_list_end()?;
+                                    val
+                                });
+                            }
+                            _ => {
+                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                                _unknown_fields.push_back(
+                                    __protocol
+                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
                                 );
                             }
                         }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
+
+                        __protocol.read_field_end()?;
+                        __pilota_offset += __protocol.field_end_len();
                     }
-                }
-                __protocol.read_field_end()?;
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `B` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
                 __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+
+                let Some(faststr) = faststr else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
                         ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
+                        "field faststr is required".to_string(),
+                    ));
+                };
+                let Some(string) = string else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field string is required".to_string(),
+                    ));
+                };
+                let Some(list) = list else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field list is required".to_string(),
+                    ));
+                };
+
+                let data = Self {
+                    faststr,
+                    string,
+                    list,
+                    _unknown_fields,
+                };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -2257,391 +2422,165 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret =
-                                        Some(TestTestExceptionException::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
+                    let mut faststr = None;
+                    let mut string = None;
+                    let mut list = None;
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionException",
-                }) + match self {
-                    TestTestExceptionException::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestTestExceptionResultRecv {
-            #[derivative(Default)]
-            Ok(ObjReq),
+                    let mut __pilota_decoding_field_id = None;
 
-            StException(StException),
-        }
-
-        impl ::pilota::thrift::Message for TestTestExceptionResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultRecv",
-                })?;
-                match self {
-                    TestTestExceptionResultRecv::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestTestExceptionResultRecv::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
-
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultRecv::StException(field_ident));
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
                             } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
                             }
-                        }
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(TestTestExceptionResultRecv::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    faststr = Some(__protocol.read_faststr().await?);
                                 }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret =
-                                        Some(TestTestExceptionResultRecv::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    string = Some(__protocol.read_string().await?);
+                                }
+                                Some(3)
+                                    if field_ident.field_type == ::pilota::thrift::TType::List =>
+                                {
+                                    list = Some({
+                                        let list_ident = __protocol.read_list_begin().await?;
+                                        let mut val = Vec::with_capacity(list_ident.size);
+                                        for _ in 0..list_ident.size {
+                                            val.push({
+                                                let list_ident =
+                                                    __protocol.read_list_begin().await?;
+                                                let mut val = Vec::with_capacity(list_ident.size);
+                                                for _ in 0..list_ident.size {
+                                                    val.push(__protocol.read_faststr().await?);
+                                                }
+                                                __protocol.read_list_end().await?;
+                                                val
+                                            });
+                                        }
+                                        __protocol.read_list_end().await?;
+                                        val
+                                    });
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
                             }
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
-                        }
-                    }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
-                    }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultRecv",
-                }) + match self {
-                    TestTestExceptionResultRecv::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    TestTestExceptionResultRecv::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestTest123ResultRecv {
-            #[derivative(Default)]
-            Ok(()),
-        }
-
-        impl ::pilota::thrift::Message for TestTest123ResultRecv {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultRecv",
-                })?;
-                match self {
-                    TestTest123ResultRecv::Ok(ref value) => {}
-                }
-                __protocol.write_field_stop()?;
-                __protocol.write_struct_end()?;
-                ::std::result::Result::Ok(())
-            }
 
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
+                            __protocol.read_field_end().await?;
                         }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                     }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
-                }
-            }
-
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
-                    loop {
-                        let field_ident = __protocol.read_field_begin().await?;
-                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            break;
-                        } else {
-                        }
-                        match field_ident.id {
-                            _ => {
-                                __protocol.skip(field_ident.field_type).await?;
-                            }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `B` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
-                    }
-                    __protocol.read_field_end().await?;
+                        return ::std::result::Result::Err(err);
+                    };
                     __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
-                    }
-                })
-            }
 
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultRecv",
-                }) + match self {
-                    TestTest123ResultRecv::Ok(ref value) => 0,
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize)]
-        #[serde(transparent)]
-        #[derive(Clone, PartialEq, Copy)]
-        #[repr(transparent)]
-        pub struct Index(i32);
-
-        impl Index {
-            pub const A: Self = Self(0);
-            pub const B: Self = Self(1);
-
-            pub fn inner(&self) -> i32 {
-                self.0
-            }
-
-            pub fn to_string(&self) -> ::std::string::String {
-                match self {
-                    Self(0) => ::std::string::String::from("A"),
-                    Self(1) => ::std::string::String::from("B"),
-                    Self(val) => val.to_string(),
-                }
-            }
-        }
+                    let Some(faststr) = faststr else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field faststr is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(string) = string else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field string is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(list) = list else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field list is required".to_string(),
+                            ),
+                        );
+                    };
 
-        impl ::std::convert::From<i32> for Index {
-            fn from(value: i32) -> Self {
-                Self(value)
+                    let data = Self {
+                        faststr,
+                        string,
+                        list,
+                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    };
+                    ::std::result::Result::Ok(data)
+                })
             }
-        }
 
-        impl ::std::convert::From<Index> for i32 {
-            fn from(value: Index) -> i32 {
-                value.0
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "B" })
+                    + __protocol.faststr_field_len(Some(1), &self.faststr)
+                    + __protocol.string_field_len(Some(2), &&self.string)
+                    + __protocol.list_field_len(
+                        Some(3),
+                        ::pilota::thrift::TType::List,
+                        &self.list,
+                        |__protocol, el| {
+                            __protocol.list_len(
+                                ::pilota::thrift::TType::Binary,
+                                el,
+                                |__protocol, el| __protocol.faststr_len(el),
+                            )
+                        },
+                    )
+                    + self._unknown_fields.size()
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
             }
         }
-
-        impl ::pilota::thrift::Message for Index {
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct TestTestExceptionArgsSend {
+            pub req: ObjReq,
+        }
+        impl ::pilota::thrift::Message for TestTestExceptionArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_i32(self.inner())?;
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionArgsSend",
+                };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_field_stop()?;
+                __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
             }
 
@@ -2650,15 +2589,54 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let value = __protocol.read_i32()?;
-                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                    |err| {
-                        ::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            format!("invalid enum value for Index, value: {}", value),
-                        )
-                    },
-                )?)
+
+                let mut req = None;
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
+                    loop {
+                        let field_ident = __protocol.read_field_begin()?;
+                        if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __protocol.field_stop_len();
+                            break;
+                        } else {
+                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                        }
+                        __pilota_decoding_field_id = field_ident.id;
+                        match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                            {
+                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                            }
+                            _ => {
+                                __protocol.skip(field_ident.field_type)?;
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(req) = req else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field req is required".to_string(),
+                    ));
+                };
+
+                let data = Self { req };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -2672,24 +2650,74 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let value = __protocol.read_i32().await?;
-                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
-                        |err| {
+                    let mut req = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Struct =>
+                                {
+                                    req = Some(
+                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
+                                            __protocol,
+                                        )
+                                        .await?,
+                                    );
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
+                            }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(req) = req else {
+                        return ::std::result::Result::Err(
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                format!("invalid enum value for Index, value: {}", value),
-                            )
-                        },
-                    )?)
+                                "field req is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self { req };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.i32_len(self.inner())
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "TestTestExceptionArgsSend",
+                }) + __protocol.struct_field_len(Some(1), &self.req)
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
             }
         }
+        pub const TEST_LIST: [&'static str; 2] = ["hello", "world"];
         #[derive(
             PartialOrd,
             Hash,
@@ -2702,19 +2730,25 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct ObjReq {
+        pub struct StException {
+            pub message: ::std::option::Option<::pilota::FastStr>,
             pub _unknown_fields: ::pilota::LinkedBytes,
         }
-        impl ::pilota::thrift::Message for ObjReq {
+        impl ::pilota::thrift::Message for StException {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "ObjReq" };
+                let struct_ident = ::pilota::thrift::TStructIdentifier {
+                    name: "STException",
+                };
 
                 __protocol.write_struct_begin(&struct_ident)?;
+                if let Some(value) = self.message.as_ref() {
+                    __protocol.write_faststr_field(1, (value).clone())?;
+                }
                 for bytes in self._unknown_fields.list.iter() {
                     __protocol.write_bytes_without_len(bytes.clone());
                 }
@@ -2729,7 +2763,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut __pilota_fields_num = 0;
+                let mut message = None;
                 let mut _unknown_fields = ::pilota::LinkedBytes::new();
 
                 let mut __pilota_decoding_field_id = None;
@@ -2737,12 +2771,6 @@ pub mod unknown_fields {
                 __protocol.read_struct_begin()?;
                 if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
-                        if __pilota_fields_num == 0 {
-                            let __pilota_remaining = __protocol.buf().remaining();
-                            _unknown_fields
-                                .push_back(__protocol.get_bytes(None, __pilota_remaining - 2)?);
-                            break;
-                        }
                         let mut __pilota_offset = 0;
                         let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
                         let field_ident = __protocol.read_field_begin()?;
@@ -2755,6 +2783,11 @@ pub mod unknown_fields {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
+                            Some(1)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                message = Some(__protocol.read_faststr()?);
+                            }
                             _ => {
                                 __pilota_offset += __protocol.skip(field_ident.field_type)?;
                                 _unknown_fields.push_back(
@@ -2771,7 +2804,7 @@ pub mod unknown_fields {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `ObjReq` field(#{}) failed, caused by: ",
+                            "decode struct `STException` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -2779,7 +2812,10 @@ pub mod unknown_fields {
                 };
                 __protocol.read_struct_end()?;
 
-                let data = Self { _unknown_fields };
+                let data = Self {
+                    message,
+                    _unknown_fields,
+                };
                 ::std::result::Result::Ok(data)
             }
 
@@ -2794,6 +2830,8 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
+                    let mut message = None;
+
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
@@ -2806,6 +2844,12 @@ pub mod unknown_fields {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    message = Some(__protocol.read_faststr().await?);
+                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -2819,7 +2863,7 @@ pub mod unknown_fields {
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
                             err.prepend_msg(&format!(
-                                "decode struct `ObjReq` field(#{}) failed, caused by: ",
+                                "decode struct `STException` field(#{}) failed, caused by: ",
                                 field_id
                             ));
                         }
@@ -2828,6 +2872,7 @@ pub mod unknown_fields {
                     __protocol.read_struct_end().await?;
 
                     let data = Self {
+                        message,
                         _unknown_fields: ::pilota::LinkedBytes::new(),
                     };
                     ::std::result::Result::Ok(data)
@@ -2837,7 +2882,12 @@ pub mod unknown_fields {
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "ObjReq" })
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
+                    name: "STException",
+                }) + self
+                    .message
+                    .as_ref()
+                    .map_or(0, |value| __protocol.faststr_field_len(Some(1), value))
                     + self._unknown_fields.size()
                     + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
@@ -2855,10 +2905,8 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct TestTestExceptionArgsSend {
-            pub req: ObjReq,
-        }
-        impl ::pilota::thrift::Message for TestTestExceptionArgsSend {
+        pub struct TestTest123ArgsSend {}
+        impl ::pilota::thrift::Message for TestTest123ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -2866,11 +2914,11 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsSend",
+                    name: "TestTest123ArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -2882,8 +2930,6 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut req = None;
-
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
@@ -2898,11 +2944,6 @@ pub mod unknown_fields {
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
-                            Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
-                            {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type)?;
                             }
@@ -2914,20 +2955,16 @@ pub mod unknown_fields {
                     ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                        err.prepend_msg(&format!(
+                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
                     return ::std::result::Result::Err(err);
                 };
                 __protocol.read_struct_end()?;
 
-                let Some(req) = req else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
-                    ));
-                };
-
-                let data = Self { req };
+                let data = Self {};
                 ::std::result::Result::Ok(data)
             }
 
@@ -2942,8 +2979,6 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut req = None;
-
                     let mut __pilota_decoding_field_id = None;
 
                     __protocol.read_struct_begin().await?;
@@ -2956,17 +2991,6 @@ pub mod unknown_fields {
                             }
                             __pilota_decoding_field_id = field_ident.id;
                             match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    req = Some(
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
                                 _ => {
                                     __protocol.skip(field_ident.field_type).await?;
                                 }
@@ -2979,22 +3003,13 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
                     __protocol.read_struct_end().await?;
 
-                    let Some(req) = req else {
-                        return ::std::result::Result::Err(
-                            ::pilota::thrift::new_protocol_exception(
-                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { req };
+                    let data = Self {};
                     ::std::result::Result::Ok(data)
                 })
             }
@@ -3003,32 +3018,38 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsSend",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
+                    name: "TestTest123ArgsSend",
+                }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
-        #[derivative(Default)]
-        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestTest123ResultSend {
-            #[derivative(Default)]
-            Ok(()),
+        #[derive(
+            PartialOrd,
+            Hash,
+            Eq,
+            Ord,
+            Debug,
+            Default,
+            ::pilota::serde::Serialize,
+            ::pilota::serde::Deserialize,
+            Clone,
+            PartialEq,
+        )]
+        pub struct SubMessage {
+            pub _unknown_fields: ::pilota::LinkedBytes,
         }
-
-        impl ::pilota::thrift::Message for TestTest123ResultSend {
+        impl ::pilota::thrift::Message for SubMessage {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultSend",
-                })?;
-                match self {
-                    TestTest123ResultSend::Ok(ref value) => {}
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "SubMessage" };
+
+                __protocol.write_struct_begin(&struct_ident)?;
+                for bytes in self._unknown_fields.list.iter() {
+                    __protocol.write_bytes_without_len(bytes.clone());
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -3040,158 +3061,52 @@ pub mod unknown_fields {
             ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                let mut ret = None;
-                __protocol.read_struct_begin()?;
-                loop {
-                    let field_ident = __protocol.read_field_begin()?;
-                    if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                        __protocol.field_stop_len();
-                        break;
-                    } else {
-                        __protocol.field_begin_len(field_ident.field_type, field_ident.id);
-                    }
-                    match field_ident.id {
-                        _ => {
-                            __protocol.skip(field_ident.field_type)?;
-                        }
-                    }
-                }
-                __protocol.read_field_end()?;
-                __protocol.read_struct_end()?;
-                if let Some(ret) = ret {
-                    ::std::result::Result::Ok(ret)
-                } else {
-                    ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
-                }
-            }
 
-            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
-                __protocol: &'a mut T,
-            ) -> ::std::pin::Pin<
-                ::std::boxed::Box<
-                    dyn ::std::future::Future<
-                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
-                        > + Send
-                        + 'a,
-                >,
-            > {
-                ::std::boxed::Box::pin(async move {
-                    let mut ret = None;
-                    __protocol.read_struct_begin().await?;
+                let mut _unknown_fields = ::pilota::LinkedBytes::new();
+
+                let mut __pilota_decoding_field_id = None;
+
+                __protocol.read_struct_begin()?;
+                if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
-                        let field_ident = __protocol.read_field_begin().await?;
+                        let mut __pilota_offset = 0;
+                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
+                        let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                            __pilota_offset += __protocol.field_stop_len();
                             break;
                         } else {
+                            __pilota_offset +=
+                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
+                        __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             _ => {
-                                __protocol.skip(field_ident.field_type).await?;
+                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                                _unknown_fields.push_back(
+                                    __protocol
+                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
+                                );
                             }
                         }
+
+                        __protocol.read_field_end()?;
+                        __pilota_offset += __protocol.field_end_len();
                     }
-                    __protocol.read_field_end().await?;
-                    __protocol.read_struct_end().await?;
-                    if let Some(ret) = ret {
-                        ::std::result::Result::Ok(ret)
-                    } else {
-                        ::std::result::Result::Ok(TestTest123ResultSend::Ok(()))
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `SubMessage` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
                     }
-                })
-            }
-
-            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ResultSend",
-                }) + match self {
-                    TestTest123ResultSend::Ok(ref value) => 0,
-                } + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
-            }
-        }
-        #[derive(
-            PartialOrd,
-            Hash,
-            Eq,
-            Ord,
-            Debug,
-            Default,
-            ::pilota::serde::Serialize,
-            ::pilota::serde::Deserialize,
-            Clone,
-            PartialEq,
-        )]
-        pub struct Td(pub ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>);
-
-        impl ::std::ops::Deref for Td {
-            type Target = ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-
-        impl From<::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>> for Td {
-            fn from(v: ::std::vec::Vec<::std::vec::Vec<::pilota::FastStr>>) -> Self {
-                Self(v)
-            }
-        }
-
-        impl ::pilota::thrift::Message for Td {
-            fn encode<T: ::pilota::thrift::TOutputProtocol>(
-                &self,
-                __protocol: &mut T,
-            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::thrift::TOutputProtocolExt;
-                __protocol.write_list(
-                    ::pilota::thrift::TType::List,
-                    &(&**self),
-                    |__protocol, val| {
-                        __protocol.write_list(
-                            ::pilota::thrift::TType::Binary,
-                            &val,
-                            |__protocol, val| {
-                                __protocol.write_faststr((val).clone())?;
-                                ::std::result::Result::Ok(())
-                            },
-                        )?;
-                        ::std::result::Result::Ok(())
-                    },
-                )?;
-                ::std::result::Result::Ok(())
-            }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
 
-            fn decode<T: ::pilota::thrift::TInputProtocol>(
-                __protocol: &mut T,
-            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
-                #[allow(unused_imports)]
-                use ::pilota::{thrift::TLengthProtocolExt, Buf};
-                ::std::result::Result::Ok(Td(unsafe {
-                    let list_ident = __protocol.read_list_begin()?;
-                    let mut val: Vec<::std::vec::Vec<::pilota::FastStr>> =
-                        Vec::with_capacity(list_ident.size);
-                    for i in 0..list_ident.size {
-                        val.as_mut_ptr().offset(i as isize).write(unsafe {
-                            let list_ident = __protocol.read_list_begin()?;
-                            let mut val: Vec<::pilota::FastStr> =
-                                Vec::with_capacity(list_ident.size);
-                            for i in 0..list_ident.size {
-                                val.as_mut_ptr()
-                                    .offset(i as isize)
-                                    .write(__protocol.read_faststr()?);
-                            }
-                            val.set_len(list_ident.size);
-                            __protocol.read_list_end()?;
-                            val
-                        });
-                    }
-                    val.set_len(list_ident.size);
-                    __protocol.read_list_end()?;
-                    val
-                }))
+                let data = Self { _unknown_fields };
+                ::std::result::Result::Ok(data)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -3205,34 +3120,54 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    ::std::result::Result::Ok(Td({
-                        let list_ident = __protocol.read_list_begin().await?;
-                        let mut val = Vec::with_capacity(list_ident.size);
-                        for _ in 0..list_ident.size {
-                            val.push({
-                                let list_ident = __protocol.read_list_begin().await?;
-                                let mut val = Vec::with_capacity(list_ident.size);
-                                for _ in 0..list_ident.size {
-                                    val.push(__protocol.read_faststr().await?);
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
                                 }
-                                __protocol.read_list_end().await?;
-                                val
-                            });
+                            }
+
+                            __protocol.read_field_end().await?;
                         }
-                        __protocol.read_list_end().await?;
-                        val
-                    }))
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `SubMessage` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
+                        }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let data = Self {
+                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    };
+                    ::std::result::Result::Ok(data)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.list_len(::pilota::thrift::TType::List, &**self, |__protocol, el| {
-                    __protocol.list_len(::pilota::thrift::TType::Binary, el, |__protocol, el| {
-                        __protocol.faststr_len(el)
-                    })
-                })
+                __protocol
+                    .struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "SubMessage" })
+                    + self._unknown_fields.size()
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
             }
         }
         #[derive(
@@ -3247,22 +3182,27 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct TestTestExceptionArgsRecv {
-            pub req: ObjReq,
+        pub struct A {
+            pub bytes: ::pilota::Bytes,
+
+            pub vec: ::std::vec::Vec<u8>,
+            pub _unknown_fields: ::pilota::LinkedBytes,
         }
-        impl ::pilota::thrift::Message for TestTestExceptionArgsRecv {
+        impl ::pilota::thrift::Message for A {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
             ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
-                let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsRecv",
-                };
+                let struct_ident = ::pilota::thrift::TStructIdentifier { name: "A" };
 
                 __protocol.write_struct_begin(&struct_ident)?;
-                __protocol.write_struct_field(1, &self.req, ::pilota::thrift::TType::Struct)?;
+                __protocol.write_bytes_field(1, (&self.bytes).clone())?;
+                __protocol.write_bytes_vec_field(2, &self.vec)?;
+                for bytes in self._unknown_fields.list.iter() {
+                    __protocol.write_bytes_without_len(bytes.clone());
+                }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
                 ::std::result::Result::Ok(())
@@ -3274,53 +3214,240 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::{thrift::TLengthProtocolExt, Buf};
 
-                let mut req = None;
+                let mut bytes = None;
+                let mut vec = None;
+                let mut _unknown_fields = ::pilota::LinkedBytes::new();
 
                 let mut __pilota_decoding_field_id = None;
 
                 __protocol.read_struct_begin()?;
                 if let ::std::result::Result::Err(mut err) = (|| {
                     loop {
+                        let mut __pilota_offset = 0;
+                        let __pilota_begin_ptr = __protocol.buf().chunk().as_ptr();
                         let field_ident = __protocol.read_field_begin()?;
                         if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                            __protocol.field_stop_len();
+                            __pilota_offset += __protocol.field_stop_len();
                             break;
                         } else {
-                            __protocol.field_begin_len(field_ident.field_type, field_ident.id);
+                            __pilota_offset +=
+                                __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                         }
                         __pilota_decoding_field_id = field_ident.id;
                         match field_ident.id {
                             Some(1)
-                                if field_ident.field_type == ::pilota::thrift::TType::Struct =>
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
                             {
-                                req = Some(::pilota::thrift::Message::decode(__protocol)?);
+                                bytes = Some(__protocol.read_bytes()?);
+                            }
+                            Some(2)
+                                if field_ident.field_type == ::pilota::thrift::TType::Binary =>
+                            {
+                                vec = Some(__protocol.read_bytes_vec()?);
                             }
                             _ => {
-                                __protocol.skip(field_ident.field_type)?;
+                                __pilota_offset += __protocol.skip(field_ident.field_type)?;
+                                _unknown_fields.push_back(
+                                    __protocol
+                                        .get_bytes(Some(__pilota_begin_ptr), __pilota_offset)?,
+                                );
+                            }
+                        }
+
+                        __protocol.read_field_end()?;
+                        __pilota_offset += __protocol.field_end_len();
+                    }
+                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                })() {
+                    if let Some(field_id) = __pilota_decoding_field_id {
+                        err.prepend_msg(&format!(
+                            "decode struct `A` field(#{}) failed, caused by: ",
+                            field_id
+                        ));
+                    }
+                    return ::std::result::Result::Err(err);
+                };
+                __protocol.read_struct_end()?;
+
+                let Some(bytes) = bytes else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field bytes is required".to_string(),
+                    ));
+                };
+                let Some(vec) = vec else {
+                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
+                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                        "field vec is required".to_string(),
+                    ));
+                };
+
+                let data = Self {
+                    bytes,
+                    vec,
+                    _unknown_fields,
+                };
+                ::std::result::Result::Ok(data)
+            }
+
+            fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
+                __protocol: &'a mut T,
+            ) -> ::std::pin::Pin<
+                ::std::boxed::Box<
+                    dyn ::std::future::Future<
+                            Output = ::std::result::Result<Self, ::pilota::thrift::ThriftException>,
+                        > + Send
+                        + 'a,
+                >,
+            > {
+                ::std::boxed::Box::pin(async move {
+                    let mut bytes = None;
+                    let mut vec = None;
+
+                    let mut __pilota_decoding_field_id = None;
+
+                    __protocol.read_struct_begin().await?;
+                    if let ::std::result::Result::Err(mut err) = async {
+                        loop {
+                            let field_ident = __protocol.read_field_begin().await?;
+                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
+                                break;
+                            } else {
+                            }
+                            __pilota_decoding_field_id = field_ident.id;
+                            match field_ident.id {
+                                Some(1)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    bytes = Some(__protocol.read_bytes().await?);
+                                }
+                                Some(2)
+                                    if field_ident.field_type
+                                        == ::pilota::thrift::TType::Binary =>
+                                {
+                                    vec = Some(__protocol.read_bytes_vec().await?);
+                                }
+                                _ => {
+                                    __protocol.skip(field_ident.field_type).await?;
+                                }
                             }
+
+                            __protocol.read_field_end().await?;
+                        }
+                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
+                    }
+                    .await
+                    {
+                        if let Some(field_id) = __pilota_decoding_field_id {
+                            err.prepend_msg(&format!(
+                                "decode struct `A` field(#{}) failed, caused by: ",
+                                field_id
+                            ));
                         }
+                        return ::std::result::Result::Err(err);
+                    };
+                    __protocol.read_struct_end().await?;
+
+                    let Some(bytes) = bytes else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field bytes is required".to_string(),
+                            ),
+                        );
+                    };
+                    let Some(vec) = vec else {
+                        return ::std::result::Result::Err(
+                            ::pilota::thrift::new_protocol_exception(
+                                ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                                "field vec is required".to_string(),
+                            ),
+                        );
+                    };
+
+                    let data = Self {
+                        bytes,
+                        vec,
+                        _unknown_fields: ::pilota::LinkedBytes::new(),
+                    };
+                    ::std::result::Result::Ok(data)
+                })
+            }
+
+            fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TLengthProtocolExt;
+                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier { name: "A" })
+                    + __protocol.bytes_field_len(Some(1), &self.bytes)
+                    + __protocol.bytes_vec_field_len(Some(2), &self.vec)
+                    + self._unknown_fields.size()
+                    + __protocol.field_stop_len()
+                    + __protocol.struct_end_len()
+            }
+        }
+        #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
+        #[derivative(Default)]
+        #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize)]
+        #[serde(transparent)]
+        #[derive(Clone, PartialEq, Copy)]
+        #[repr(transparent)]
+        pub struct Index(i32);
+
+        impl Index {
+            pub const A: Self = Self(0);
+            pub const B: Self = Self(1);
+
+            pub fn inner(&self) -> i32 {
+                self.0
+            }
+
+            pub fn to_string(&self) -> ::std::string::String {
+                match self {
+                    Self(0) => ::std::string::String::from("A"),
+                    Self(1) => ::std::string::String::from("B"),
+                    Self(val) => val.to_string(),
+                }
+            }
+        }
+
+        impl ::std::convert::From<i32> for Index {
+            fn from(value: i32) -> Self {
+                Self(value)
+            }
+        }
 
-                        __protocol.read_field_end()?;
-                        __protocol.field_end_len();
-                    }
-                    ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                })() {
-                    if let Some(field_id) = __pilota_decoding_field_id {
-                        err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
-                    }
-                    return ::std::result::Result::Err(err);
-                };
-                __protocol.read_struct_end()?;
+        impl ::std::convert::From<Index> for i32 {
+            fn from(value: Index) -> i32 {
+                value.0
+            }
+        }
 
-                let Some(req) = req else {
-                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "field req is required".to_string(),
-                    ));
-                };
+        impl ::pilota::thrift::Message for Index {
+            fn encode<T: ::pilota::thrift::TOutputProtocol>(
+                &self,
+                __protocol: &mut T,
+            ) -> ::std::result::Result<(), ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::thrift::TOutputProtocolExt;
+                __protocol.write_i32(self.inner())?;
+                ::std::result::Result::Ok(())
+            }
 
-                let data = Self { req };
-                ::std::result::Result::Ok(data)
+            fn decode<T: ::pilota::thrift::TInputProtocol>(
+                __protocol: &mut T,
+            ) -> ::std::result::Result<Self, ::pilota::thrift::ThriftException> {
+                #[allow(unused_imports)]
+                use ::pilota::{thrift::TLengthProtocolExt, Buf};
+                let value = __protocol.read_i32()?;
+                ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                    |err| {
+                        ::pilota::thrift::new_protocol_exception(
+                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
+                            format!("invalid enum value for Index, value: {}", value),
+                        )
+                    },
+                )?)
             }
 
             fn decode_async<'a, T: ::pilota::thrift::TAsyncInputProtocol>(
@@ -3334,84 +3461,42 @@ pub mod unknown_fields {
                 >,
             > {
                 ::std::boxed::Box::pin(async move {
-                    let mut req = None;
-
-                    let mut __pilota_decoding_field_id = None;
-
-                    __protocol.read_struct_begin().await?;
-                    if let ::std::result::Result::Err(mut err) = async {
-                        loop {
-                            let field_ident = __protocol.read_field_begin().await?;
-                            if field_ident.field_type == ::pilota::thrift::TType::Stop {
-                                break;
-                            } else {
-                            }
-                            __pilota_decoding_field_id = field_ident.id;
-                            match field_ident.id {
-                                Some(1)
-                                    if field_ident.field_type
-                                        == ::pilota::thrift::TType::Struct =>
-                                {
-                                    req = Some(
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?,
-                                    );
-                                }
-                                _ => {
-                                    __protocol.skip(field_ident.field_type).await?;
-                                }
-                            }
-
-                            __protocol.read_field_end().await?;
-                        }
-                        ::std::result::Result::Ok::<_, ::pilota::thrift::ThriftException>(())
-                    }
-                    .await
-                    {
-                        if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTestExceptionArgsRecv` field(#{}) failed, caused by: ", field_id));
-                        }
-                        return ::std::result::Result::Err(err);
-                    };
-                    __protocol.read_struct_end().await?;
-
-                    let Some(req) = req else {
-                        return ::std::result::Result::Err(
+                    let value = __protocol.read_i32().await?;
+                    ::std::result::Result::Ok(::std::convert::TryFrom::try_from(value).map_err(
+                        |err| {
                             ::pilota::thrift::new_protocol_exception(
                                 ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                "field req is required".to_string(),
-                            ),
-                        );
-                    };
-
-                    let data = Self { req };
-                    ::std::result::Result::Ok(data)
+                                format!("invalid enum value for Index, value: {}", value),
+                            )
+                        },
+                    )?)
                 })
             }
 
             fn size<T: ::pilota::thrift::TLengthProtocol>(&self, __protocol: &mut T) -> usize {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
-                __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionArgsRecv",
-                }) + __protocol.struct_field_len(Some(1), &self.req)
-                    + __protocol.field_stop_len()
-                    + __protocol.struct_end_len()
+                __protocol.i32_len(self.inner())
             }
         }
+        ::pilota::lazy_static::lazy_static! {
+            pub static ref TEST_MAP: ::pilota::AHashMap<Index, &'static str> = {
+            let mut map = ::pilota::AHashMap::with_capacity(2);
+            map.insert(Index::A, "hello");map.insert(Index::B, "world");
+            map
+        };
+        }
+
+        pub trait Test {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
-        pub enum TestTestExceptionResultSend {
+        pub enum TestTest123ResultRecv {
             #[derivative(Default)]
-            Ok(ObjReq),
-
-            StException(StException),
+            Ok(()),
         }
 
-        impl ::pilota::thrift::Message for TestTestExceptionResultSend {
+        impl ::pilota::thrift::Message for TestTest123ResultRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -3419,15 +3504,10 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 __protocol.write_struct_begin(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultSend",
+                    name: "TestTest123ResultRecv",
                 })?;
                 match self {
-                    TestTestExceptionResultSend::Ok(ref value) => {
-                        __protocol.write_struct_field(0, value, ::pilota::thrift::TType::Struct)?;
-                    }
-                    TestTestExceptionResultSend::StException(ref value) => {
-                        __protocol.write_struct_field(1, value, ::pilota::thrift::TType::Struct)?;
-                    }
+                    TestTest123ResultRecv::Ok(ref value) => {}
                 }
                 __protocol.write_field_stop()?;
                 __protocol.write_struct_end()?;
@@ -3450,34 +3530,6 @@ pub mod unknown_fields {
                         __protocol.field_begin_len(field_ident.field_type, field_ident.id);
                     }
                     match field_ident.id {
-                        Some(0) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultSend::Ok(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
-                        Some(1) => {
-                            if ret.is_none() {
-                                let field_ident = ::pilota::thrift::Message::decode(__protocol)?;
-                                __protocol.struct_len(&field_ident);
-                                ret = Some(TestTestExceptionResultSend::StException(field_ident));
-                            } else {
-                                return ::std::result::Result::Err(
-                                    ::pilota::thrift::new_protocol_exception(
-                                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                        "received multiple fields for union from remote Message",
-                                    ),
-                                );
-                            }
-                        }
                         _ => {
                             __protocol.skip(field_ident.field_type)?;
                         }
@@ -3488,10 +3540,7 @@ pub mod unknown_fields {
                 if let Some(ret) = ret {
                     ::std::result::Result::Ok(ret)
                 } else {
-                    ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                        ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                        "received empty union from remote Message",
-                    ))
+                    ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
                 }
             }
 
@@ -3515,39 +3564,6 @@ pub mod unknown_fields {
                         } else {
                         }
                         match field_ident.id {
-                            Some(0) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <ObjReq as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret = Some(TestTestExceptionResultSend::Ok(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
-                            Some(1) => {
-                                if ret.is_none() {
-                                    let field_ident =
-                                        <StException as ::pilota::thrift::Message>::decode_async(
-                                            __protocol,
-                                        )
-                                        .await?;
-
-                                    ret =
-                                        Some(TestTestExceptionResultSend::StException(field_ident));
-                                } else {
-                                    return ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                                            "received multiple fields for union from remote Message"
-                                        ));
-                                }
-                            }
                             _ => {
                                 __protocol.skip(field_ident.field_type).await?;
                             }
@@ -3558,10 +3574,7 @@ pub mod unknown_fields {
                     if let Some(ret) = ret {
                         ::std::result::Result::Ok(ret)
                     } else {
-                        ::std::result::Result::Err(::pilota::thrift::new_protocol_exception(
-                            ::pilota::thrift::ProtocolExceptionKind::InvalidData,
-                            "received empty union from remote Message",
-                        ))
+                        ::std::result::Result::Ok(TestTest123ResultRecv::Ok(()))
                     }
                 })
             }
@@ -3570,30 +3583,16 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTestExceptionResultSend",
+                    name: "TestTest123ResultRecv",
                 }) + match self {
-                    TestTestExceptionResultSend::Ok(ref value) => {
-                        __protocol.struct_field_len(Some(0), value)
-                    }
-                    TestTestExceptionResultSend::StException(ref value) => {
-                        __protocol.struct_field_len(Some(1), value)
-                    }
+                    TestTest123ResultRecv::Ok(ref value) => 0,
                 } + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
         }
-        ::pilota::lazy_static::lazy_static! {
-            pub static ref TEST_MAP: ::pilota::AHashMap<Index, &'static str> = {
-            let mut map = ::pilota::AHashMap::with_capacity(2);
-            map.insert(Index::A, "hello");map.insert(Index::B, "world");
-            map
-        };
-        }
     }
 
     pub mod void {
-
-        pub trait Test {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
@@ -3696,6 +3695,7 @@ pub mod unknown_fields {
                     + __protocol.struct_end_len()
             }
         }
+        pub trait Test {}
         #[derive(PartialOrd, Hash, Eq, Ord, Debug, ::pilota::derivative::Derivative)]
         #[derivative(Default)]
         #[derive(::pilota::serde::Serialize, ::pilota::serde::Deserialize, Clone, PartialEq)]
@@ -3810,8 +3810,8 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct TestTest123ArgsSend {}
-        impl ::pilota::thrift::Message for TestTest123ArgsSend {
+        pub struct TestTest123ArgsRecv {}
+        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -3819,7 +3819,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -3861,7 +3861,7 @@ pub mod unknown_fields {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -3908,7 +3908,7 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -3923,7 +3923,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsSend",
+                    name: "TestTest123ArgsRecv",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }
@@ -3940,8 +3940,8 @@ pub mod unknown_fields {
             Clone,
             PartialEq,
         )]
-        pub struct TestTest123ArgsRecv {}
-        impl ::pilota::thrift::Message for TestTest123ArgsRecv {
+        pub struct TestTest123ArgsSend {}
+        impl ::pilota::thrift::Message for TestTest123ArgsSend {
             fn encode<T: ::pilota::thrift::TOutputProtocol>(
                 &self,
                 __protocol: &mut T,
@@ -3949,7 +3949,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TOutputProtocolExt;
                 let struct_ident = ::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
+                    name: "TestTest123ArgsSend",
                 };
 
                 __protocol.write_struct_begin(&struct_ident)?;
@@ -3991,7 +3991,7 @@ pub mod unknown_fields {
                 })() {
                     if let Some(field_id) = __pilota_decoding_field_id {
                         err.prepend_msg(&format!(
-                            "decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ",
+                            "decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ",
                             field_id
                         ));
                     }
@@ -4038,7 +4038,7 @@ pub mod unknown_fields {
                     .await
                     {
                         if let Some(field_id) = __pilota_decoding_field_id {
-                            err.prepend_msg(&format!("decode struct `TestTest123ArgsRecv` field(#{}) failed, caused by: ", field_id));
+                            err.prepend_msg(&format!("decode struct `TestTest123ArgsSend` field(#{}) failed, caused by: ", field_id));
                         }
                         return ::std::result::Result::Err(err);
                     };
@@ -4053,7 +4053,7 @@ pub mod unknown_fields {
                 #[allow(unused_imports)]
                 use ::pilota::thrift::TLengthProtocolExt;
                 __protocol.struct_begin_len(&::pilota::thrift::TStructIdentifier {
-                    name: "TestTest123ArgsRecv",
+                    name: "TestTest123ArgsSend",
                 }) + __protocol.field_stop_len()
                     + __protocol.struct_end_len()
             }