diff --git a/packet-service/src/packets/cli_accept_req.rs b/packet-service/src/packets/cli_accept_req.rs
new file mode 100644
index 0000000..9258146
--- /dev/null
+++ b/packet-service/src/packets/cli_accept_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAcceptReq {}
+
+impl PacketPayload for CliAcceptReq {}
+
+impl Encode for CliAcceptReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAcceptReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_alive.rs b/packet-service/src/packets/cli_alive.rs
new file mode 100644
index 0000000..ebeaecb
--- /dev/null
+++ b/packet-service/src/packets/cli_alive.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlive {}
+
+impl PacketPayload for CliAlive {}
+
+impl Encode for CliAlive {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlive {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_allied_chat.rs b/packet-service/src/packets/cli_allied_chat.rs
new file mode 100644
index 0000000..3872e4c
--- /dev/null
+++ b/packet-service/src/packets/cli_allied_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlliedChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliAlliedChat {}
+
+impl Encode for CliAlliedChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlliedChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_allied_shout_chat.rs b/packet-service/src/packets/cli_allied_shout_chat.rs
new file mode 100644
index 0000000..bcb9890
--- /dev/null
+++ b/packet-service/src/packets/cli_allied_shout_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAlliedShoutChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliAlliedShoutChat {}
+
+impl Encode for CliAlliedShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAlliedShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_appraisal_req.rs b/packet-service/src/packets/cli_appraisal_req.rs
new file mode 100644
index 0000000..9ab73df
--- /dev/null
+++ b/packet-service/src/packets/cli_appraisal_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAppraisalReq {
+    pub(crate) index: u16,
+}
+
+impl PacketPayload for CliAppraisalReq {}
+
+impl Encode for CliAppraisalReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAppraisalReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        Ok(Self { index })
+    }
+}
diff --git a/packet-service/src/packets/cli_attack.rs b/packet-service/src/packets/cli_attack.rs
new file mode 100644
index 0000000..604e430
--- /dev/null
+++ b/packet-service/src/packets/cli_attack.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliAttack {
+    pub(crate) target_id: u16,
+}
+
+impl PacketPayload for CliAttack {}
+
+impl Encode for CliAttack {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliAttack {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        Ok(Self { target_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_bank_list_req.rs b/packet-service/src/packets/cli_bank_list_req.rs
new file mode 100644
index 0000000..d847eb5
--- /dev/null
+++ b/packet-service/src/packets/cli_bank_list_req.rs
@@ -0,0 +1,61 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankListRequest {
+    Open = 0,
+    ChangePassword = 17,
+}
+
+impl Encode for BankListRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankListRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankListRequest::Open),
+            17 => Ok(BankListRequest::ChangePassword),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankListRequest: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankListReq {
+    pub(crate) request: BankListRequest,
+    pub(crate) password: NullTerminatedString,
+}
+
+impl PacketPayload for CliBankListReq {}
+
+impl Encode for CliBankListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.request.encode(encoder)?;
+        self.password.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let request = BankListRequest::decode(decoder)?;
+        let password = NullTerminatedString::decode(decoder)?;
+        Ok(Self { request, password })
+    }
+}
diff --git a/packet-service/src/packets/cli_bank_move_item.rs b/packet-service/src/packets/cli_bank_move_item.rs
new file mode 100644
index 0000000..24fad81
--- /dev/null
+++ b/packet-service/src/packets/cli_bank_move_item.rs
@@ -0,0 +1,164 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankMoveMode {
+    InventoryToBank = 0,
+    BankToInventory = 1,
+}
+
+impl Encode for BankMoveMode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankMoveMode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankMoveMode::InventoryToBank),
+            1 => Ok(BankMoveMode::BankToInventory),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankMoveMode: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankMoveItem {
+    pub(crate) mode: BankMoveMode,
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+    pub(crate) use_special_tab: u8,
+}
+
+impl PacketPayload for CliBankMoveItem {}
+
+impl Encode for CliBankMoveItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.mode.encode(encoder)?;
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.use_special_tab.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankMoveItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mode = BankMoveMode::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let use_special_tab = u8::decode(decoder)?;
+        Ok(Self {
+            mode,
+            index,
+            item,
+            use_special_tab,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_bank_move_money.rs b/packet-service/src/packets/cli_bank_move_money.rs
new file mode 100644
index 0000000..464dcbf
--- /dev/null
+++ b/packet-service/src/packets/cli_bank_move_money.rs
@@ -0,0 +1,61 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankMoveMode {
+    InventoryToBank = 16,
+    BankToInventory = 17,
+}
+
+impl Encode for BankMoveMode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankMoveMode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            16 => Ok(BankMoveMode::InventoryToBank),
+            17 => Ok(BankMoveMode::BankToInventory),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankMoveMode: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliBankMoveMoney {
+    pub(crate) mode: BankMoveMode,
+    pub(crate) amount: i64,
+}
+
+impl PacketPayload for CliBankMoveMoney {}
+
+impl Encode for CliBankMoveMoney {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.mode.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliBankMoveMoney {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mode = BankMoveMode::decode(decoder)?;
+        let amount = i64::decode(decoder)?;
+        Ok(Self { mode, amount })
+    }
+}
diff --git a/packet-service/src/packets/cli_change_char_req.rs b/packet-service/src/packets/cli_change_char_req.rs
new file mode 100644
index 0000000..a48f1f0
--- /dev/null
+++ b/packet-service/src/packets/cli_change_char_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChangeCharReq {}
+
+impl PacketPayload for CliChangeCharReq {}
+
+impl Encode for CliChangeCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChangeCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_change_map_req.rs b/packet-service/src/packets/cli_change_map_req.rs
new file mode 100644
index 0000000..28bfb26
--- /dev/null
+++ b/packet-service/src/packets/cli_change_map_req.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChangeMapReq {
+    pub(crate) weight_rate: u8,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliChangeMapReq {}
+
+impl Encode for CliChangeMapReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.weight_rate.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChangeMapReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let weight_rate = u8::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { weight_rate, z })
+    }
+}
diff --git a/packet-service/src/packets/cli_channel_list_req.rs b/packet-service/src/packets/cli_channel_list_req.rs
new file mode 100644
index 0000000..0dd11af
--- /dev/null
+++ b/packet-service/src/packets/cli_channel_list_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChannelListReq {
+    pub(crate) server_id: u32,
+}
+
+impl PacketPayload for CliChannelListReq {}
+
+impl Encode for CliChannelListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.server_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChannelListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let server_id = u32::decode(decoder)?;
+        Ok(Self { server_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_char_list_req.rs b/packet-service/src/packets/cli_char_list_req.rs
new file mode 100644
index 0000000..25a4f65
--- /dev/null
+++ b/packet-service/src/packets/cli_char_list_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCharListReq {}
+
+impl PacketPayload for CliCharListReq {}
+
+impl Encode for CliCharListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCharListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_chatroom.rs b/packet-service/src/packets/cli_chatroom.rs
new file mode 100644
index 0000000..d46eb29
--- /dev/null
+++ b/packet-service/src/packets/cli_chatroom.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChatroom {}
+
+impl PacketPayload for CliChatroom {}
+
+impl Encode for CliChatroom {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChatroom {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_chatroom_message.rs b/packet-service/src/packets/cli_chatroom_message.rs
new file mode 100644
index 0000000..7dd0f28
--- /dev/null
+++ b/packet-service/src/packets/cli_chatroom_message.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliChatroomMessage {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliChatroomMessage {}
+
+impl Encode for CliChatroomMessage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliChatroomMessage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_clan_chat.rs b/packet-service/src/packets/cli_clan_chat.rs
new file mode 100644
index 0000000..e51e76d
--- /dev/null
+++ b/packet-service/src/packets/cli_clan_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliClanChat {}
+
+impl Encode for CliClanChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_clan_command.rs b/packet-service/src/packets/cli_clan_command.rs
new file mode 100644
index 0000000..f85e675
--- /dev/null
+++ b/packet-service/src/packets/cli_clan_command.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanCommand {}
+
+impl PacketPayload for CliClanCommand {}
+
+impl Encode for CliClanCommand {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanCommand {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_clan_icon_req.rs b/packet-service/src/packets/cli_clan_icon_req.rs
new file mode 100644
index 0000000..7f1aba6
--- /dev/null
+++ b/packet-service/src/packets/cli_clan_icon_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconReq {
+    pub(crate) id: u32,
+}
+
+impl PacketPayload for CliClanIconReq {}
+
+impl Encode for CliClanIconReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u32::decode(decoder)?;
+        Ok(Self { id })
+    }
+}
diff --git a/packet-service/src/packets/cli_clan_icon_set.rs b/packet-service/src/packets/cli_clan_icon_set.rs
new file mode 100644
index 0000000..ad450b4
--- /dev/null
+++ b/packet-service/src/packets/cli_clan_icon_set.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconSet {
+    pub(crate) crc: u16,
+    pub(crate) data: Vec<u8>,
+}
+
+impl PacketPayload for CliClanIconSet {}
+
+impl Encode for CliClanIconSet {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.crc.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconSet {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let crc = u16::decode(decoder)?;
+        let data = Vec::decode(decoder)?;
+        Ok(Self { crc, data })
+    }
+}
diff --git a/packet-service/src/packets/cli_clan_icon_timestamp.rs b/packet-service/src/packets/cli_clan_icon_timestamp.rs
new file mode 100644
index 0000000..41bd2d7
--- /dev/null
+++ b/packet-service/src/packets/cli_clan_icon_timestamp.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliClanIconTimestamp {}
+
+impl PacketPayload for CliClanIconTimestamp {}
+
+impl Encode for CliClanIconTimestamp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliClanIconTimestamp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_craft_enhance_req.rs b/packet-service/src/packets/cli_craft_enhance_req.rs
new file mode 100644
index 0000000..e96d478
--- /dev/null
+++ b/packet-service/src/packets/cli_craft_enhance_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCraftEnhanceReq {}
+
+impl PacketPayload for CliCraftEnhanceReq {}
+
+impl Encode for CliCraftEnhanceReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftEnhanceReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_craft_req.rs b/packet-service/src/packets/cli_craft_req.rs
new file mode 100644
index 0000000..122b607
--- /dev/null
+++ b/packet-service/src/packets/cli_craft_req.rs
@@ -0,0 +1,50 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCraftReq {
+    pub(crate) slot: u8,
+    pub(crate) type_: i8,
+    pub(crate) id: i8,
+    pub(crate) material_slots: [i16; 4],
+}
+
+impl PacketPayload for CliCraftReq {}
+
+impl Encode for CliCraftReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        for value in &self.material_slots {
+            value.encode(encoder)?;
+        }
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let type_ = i8::decode(decoder)?;
+        let id = i8::decode(decoder)?;
+        let mut material_slots = [0i16; 4];
+        for value in &mut material_slots {
+            *value = i16::decode(decoder)?;
+        }
+        Ok(Self {
+            slot,
+            type_,
+            id,
+            material_slots,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_craft_status.rs b/packet-service/src/packets/cli_craft_status.rs
new file mode 100644
index 0000000..69aa2aa
--- /dev/null
+++ b/packet-service/src/packets/cli_craft_status.rs
@@ -0,0 +1,72 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum CraftStatus {
+    CraftStart = 0,
+    CraftSuccess = 1,
+    CraftFail = 2,
+    UpgradeStart = 3,
+    UpgradeSuccess = 4,
+    UpgradeFail = 5,
+}
+
+impl Encode for CraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for CraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(CraftStatus::CraftStart),
+            1 => Ok(CraftStatus::CraftSuccess),
+            2 => Ok(CraftStatus::CraftFail),
+            3 => Ok(CraftStatus::UpgradeStart),
+            4 => Ok(CraftStatus::UpgradeSuccess),
+            5 => Ok(CraftStatus::UpgradeFail),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for CraftStatus: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliCraftStatus {
+    pub(crate) stats: CraftStatus,
+    pub(crate) type_: i8,
+    pub(crate) id: i16,
+}
+
+impl PacketPayload for CliCraftStatus {}
+
+impl Encode for CliCraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.stats.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let stats = CraftStatus::decode(decoder)?;
+        let type_ = i8::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        Ok(Self { stats, type_, id })
+    }
+}
diff --git a/packet-service/src/packets/cli_create_char_req.rs b/packet-service/src/packets/cli_create_char_req.rs
new file mode 100644
index 0000000..7aceed9
--- /dev/null
+++ b/packet-service/src/packets/cli_create_char_req.rs
@@ -0,0 +1,57 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliCreateCharReq {
+    pub(crate) race: u8,
+    pub(crate) stone: u8,
+    pub(crate) hair: u8,
+    pub(crate) face: u8,
+    pub(crate) weapon: u8,
+    pub(crate) zone: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliCreateCharReq {}
+
+impl Encode for CliCreateCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.race.encode(encoder)?;
+        self.stone.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.weapon.encode(encoder)?;
+        self.zone.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliCreateCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let race = u8::decode(decoder)?;
+        let stone = u8::decode(decoder)?;
+        let hair = u8::decode(decoder)?;
+        let face = u8::decode(decoder)?;
+        let weapon = u8::decode(decoder)?;
+        let zone = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            race,
+            stone,
+            hair,
+            face,
+            weapon,
+            zone,
+            name,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_damage.rs b/packet-service/src/packets/cli_damage.rs
new file mode 100644
index 0000000..bd80280
--- /dev/null
+++ b/packet-service/src/packets/cli_damage.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDamage {
+    pub(crate) target_id: u16,
+    pub(crate) random_id: u16,
+}
+
+impl PacketPayload for CliDamage {}
+
+impl Encode for CliDamage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        self.random_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDamage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        let random_id = u16::decode(decoder)?;
+        Ok(Self { target_id, random_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_delete_char_req.rs b/packet-service/src/packets/cli_delete_char_req.rs
new file mode 100644
index 0000000..a4daf3a
--- /dev/null
+++ b/packet-service/src/packets/cli_delete_char_req.rs
@@ -0,0 +1,41 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDeleteCharReq {
+    pub(crate) char_id: u8,
+    pub(crate) is_delete: u8,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliDeleteCharReq {}
+
+impl Encode for CliDeleteCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.is_delete.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDeleteCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u8::decode(decoder)?;
+        let is_delete = u8::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            is_delete,
+            name,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_drop_item.rs b/packet-service/src/packets/cli_drop_item.rs
new file mode 100644
index 0000000..799e4d9
--- /dev/null
+++ b/packet-service/src/packets/cli_drop_item.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliDropItem {
+    pub(crate) index: u8,
+    pub(crate) quantity: u32,
+}
+
+impl PacketPayload for CliDropItem {}
+
+impl Encode for CliDropItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.quantity.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliDropItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let quantity = u32::decode(decoder)?;
+        Ok(Self { index, quantity })
+    }
+}
diff --git a/packet-service/src/packets/cli_equip_item.rs b/packet-service/src/packets/cli_equip_item.rs
new file mode 100644
index 0000000..03a8640
--- /dev/null
+++ b/packet-service/src/packets/cli_equip_item.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliEquipItem {
+    pub(crate) slot_to: i16,
+    pub(crate) slot_from: i16,
+}
+
+impl PacketPayload for CliEquipItem {}
+
+impl Encode for CliEquipItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot_to.encode(encoder)?;
+        self.slot_from.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot_to = i16::decode(decoder)?;
+        let slot_from = i16::decode(decoder)?;
+        Ok(Self { slot_to, slot_from })
+    }
+}
diff --git a/packet-service/src/packets/cli_equip_item_ride.rs b/packet-service/src/packets/cli_equip_item_ride.rs
new file mode 100644
index 0000000..f85d7c5
--- /dev/null
+++ b/packet-service/src/packets/cli_equip_item_ride.rs
@@ -0,0 +1,67 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPositionRide {
+    Body = 0,
+    Engine = 1,
+    Leg = 2,
+    Ability = 3,
+    Arm = 4,
+}
+
+impl Encode for EquippedPositionRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPositionRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPositionRide::Body),
+            1 => Ok(EquippedPositionRide::Engine),
+            2 => Ok(EquippedPositionRide::Leg),
+            3 => Ok(EquippedPositionRide::Ability),
+            4 => Ok(EquippedPositionRide::Arm),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPositionRide: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliEquipItemRide {
+    pub(crate) slot: EquippedPositionRide,
+    pub(crate) index: u16,
+}
+
+impl PacketPayload for CliEquipItemRide {}
+
+impl Encode for CliEquipItemRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipItemRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = EquippedPositionRide::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        Ok(Self { slot, index })
+    }
+}
diff --git a/packet-service/src/packets/cli_equip_projectile.rs b/packet-service/src/packets/cli_equip_projectile.rs
new file mode 100644
index 0000000..30d7c37
--- /dev/null
+++ b/packet-service/src/packets/cli_equip_projectile.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct ProjectileTypeAndIndex {
+    pub(crate) type_: u8,
+    pub(crate) index: u16,
+}
+
+impl Encode for ProjectileTypeAndIndex {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ProjectileTypeAndIndex {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        Ok(Self { type_, index })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliEquipProjectile {
+    pub(crate) projectile: ProjectileTypeAndIndex,
+}
+
+impl PacketPayload for CliEquipProjectile {}
+
+impl Encode for CliEquipProjectile {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.projectile.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliEquipProjectile {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let projectile = ProjectileTypeAndIndex::decode(decoder)?;
+        Ok(Self { projectile })
+    }
+}
diff --git a/packet-service/src/packets/cli_hotbar_set_icon_req.rs b/packet-service/src/packets/cli_hotbar_set_icon_req.rs
new file mode 100644
index 0000000..6efadc3
--- /dev/null
+++ b/packet-service/src/packets/cli_hotbar_set_icon_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliHotbarSetIconReq {}
+
+impl PacketPayload for CliHotbarSetIconReq {}
+
+impl Encode for CliHotbarSetIconReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliHotbarSetIconReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_hp_req.rs b/packet-service/src/packets/cli_hp_req.rs
new file mode 100644
index 0000000..bd8e640
--- /dev/null
+++ b/packet-service/src/packets/cli_hp_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliHpReq {
+    pub(crate) target_id: u16,
+}
+
+impl PacketPayload for CliHpReq {}
+
+impl Encode for CliHpReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliHpReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        Ok(Self { target_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_join_server_req.rs b/packet-service/src/packets/cli_join_server_req.rs
new file mode 100644
index 0000000..ddd2729
--- /dev/null
+++ b/packet-service/src/packets/cli_join_server_req.rs
@@ -0,0 +1,68 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct Password {
+    pub(crate) password: String,
+}
+
+impl Encode for Password {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        let bytes = self.password.as_bytes();
+        let fixed_length = 64;
+        if bytes.len() > fixed_length {
+            return Err(bincode::error::EncodeError::OtherString(format!(
+                "password length exceeds fixed size: {} > {}",
+                bytes.len(),
+                fixed_length
+            )));
+        }
+        encoder.writer().write(bytes)?;
+        encoder.writer().write(&vec![0; fixed_length - bytes.len()])?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Password {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mut buffer = vec![0u8; 64];
+        decoder.reader().read(&mut buffer)?;
+        let password = String::from_utf8(buffer)
+            .map_err(|e| DecodeError::OtherString(format!("Invalid UTF-8: {}", e)))?
+            .trim_end_matches('\0')
+            .to_string();
+        Ok(Self { password })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliJoinServerReq {
+    pub(crate) session_id: u32,
+    pub(crate) password: Password,
+}
+
+impl PacketPayload for CliJoinServerReq {}
+
+impl Encode for CliJoinServerReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.session_id.encode(encoder)?;
+        self.password.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliJoinServerReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let session_id = u32::decode(decoder)?;
+        let password = Password::decode(decoder)?;
+        Ok(Self { session_id, password })
+    }
+}
diff --git a/packet-service/src/packets/cli_join_server_token_req.rs b/packet-service/src/packets/cli_join_server_token_req.rs
new file mode 100644
index 0000000..93bcdab
--- /dev/null
+++ b/packet-service/src/packets/cli_join_server_token_req.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliJoinServerTokenReq {
+    pub(crate) session_id: u32,
+    pub(crate) token: NullTerminatedString,
+}
+
+impl PacketPayload for CliJoinServerTokenReq {}
+
+impl Encode for CliJoinServerTokenReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.session_id.encode(encoder)?;
+        self.token.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliJoinServerTokenReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let session_id = u32::decode(decoder)?;
+        let token = NullTerminatedString::decode(decoder)?;
+        Ok(Self { session_id, token })
+    }
+}
diff --git a/packet-service/src/packets/cli_login_req.rs b/packet-service/src/packets/cli_login_req.rs
new file mode 100644
index 0000000..b0f943e
--- /dev/null
+++ b/packet-service/src/packets/cli_login_req.rs
@@ -0,0 +1,68 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct Password {
+    pub(crate) password: String,
+}
+
+impl Encode for Password {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        let bytes = self.password.as_bytes();
+        let fixed_length = 64;
+        if bytes.len() > fixed_length {
+            return Err(bincode::error::EncodeError::OtherString(format!(
+                "password length exceeds fixed size: {} > {}",
+                bytes.len(),
+                fixed_length
+            )));
+        }
+        encoder.writer().write(bytes)?;
+        encoder.writer().write(&vec![0; fixed_length - bytes.len()])?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Password {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mut buffer = vec![0u8; 64];
+        decoder.reader().read(&mut buffer)?;
+        let password = String::from_utf8(buffer)
+            .map_err(|e| DecodeError::OtherString(format!("Invalid UTF-8: {}", e)))?
+            .trim_end_matches('\0')
+            .to_string();
+        Ok(Self { password })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliLoginReq {
+    pub(crate) password: Password,
+    pub(crate) username: NullTerminatedString,
+}
+
+impl PacketPayload for CliLoginReq {}
+
+impl Encode for CliLoginReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.password.encode(encoder)?;
+        self.username.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLoginReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let password = Password::decode(decoder)?;
+        let username = NullTerminatedString::decode(decoder)?;
+        Ok(Self { password, username })
+    }
+}
diff --git a/packet-service/src/packets/cli_login_token_req.rs b/packet-service/src/packets/cli_login_token_req.rs
new file mode 100644
index 0000000..5a9a3bd
--- /dev/null
+++ b/packet-service/src/packets/cli_login_token_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliLoginTokenReq {
+    pub(crate) token: NullTerminatedString,
+}
+
+impl PacketPayload for CliLoginTokenReq {}
+
+impl Encode for CliLoginTokenReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.token.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLoginTokenReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let token = NullTerminatedString::decode(decoder)?;
+        Ok(Self { token })
+    }
+}
diff --git a/packet-service/src/packets/cli_logout_req.rs b/packet-service/src/packets/cli_logout_req.rs
new file mode 100644
index 0000000..522e7f8
--- /dev/null
+++ b/packet-service/src/packets/cli_logout_req.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliLogoutReq {}
+
+impl PacketPayload for CliLogoutReq {}
+
+impl Encode for CliLogoutReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliLogoutReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_memo.rs b/packet-service/src/packets/cli_memo.rs
new file mode 100644
index 0000000..42f31c5
--- /dev/null
+++ b/packet-service/src/packets/cli_memo.rs
@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MemoType {
+    RequestContent = 0,
+    Send = 1,
+    ReceivedCount = 2,
+}
+
+impl Encode for MemoType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MemoType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MemoType::RequestContent),
+            1 => Ok(MemoType::Send),
+            2 => Ok(MemoType::ReceivedCount),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MemoType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliMemo {
+    pub(crate) type_: MemoType,
+    pub(crate) target: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliMemo {}
+
+impl Encode for CliMemo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMemo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = MemoType::decode(decoder)?;
+        let target = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { type_, target, message })
+    }
+}
diff --git a/packet-service/src/packets/cli_messenger.rs b/packet-service/src/packets/cli_messenger.rs
new file mode 100644
index 0000000..bb4143a
--- /dev/null
+++ b/packet-service/src/packets/cli_messenger.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMessenger {}
+
+impl PacketPayload for CliMessenger {}
+
+impl Encode for CliMessenger {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMessenger {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_messenger_chat.rs b/packet-service/src/packets/cli_messenger_chat.rs
new file mode 100644
index 0000000..effc423
--- /dev/null
+++ b/packet-service/src/packets/cli_messenger_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMessengerChat {
+    pub(crate) tag: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliMessengerChat {}
+
+impl Encode for CliMessengerChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.tag.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMessengerChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let tag = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { tag, message })
+    }
+}
diff --git a/packet-service/src/packets/cli_mouse_cmd.rs b/packet-service/src/packets/cli_mouse_cmd.rs
new file mode 100644
index 0000000..31ee6ec
--- /dev/null
+++ b/packet-service/src/packets/cli_mouse_cmd.rs
@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliMouseCmd {
+    pub(crate) target_id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliMouseCmd {}
+
+impl Encode for CliMouseCmd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target_id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliMouseCmd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target_id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { target_id, x, y, z })
+    }
+}
diff --git a/packet-service/src/packets/cli_normal_chat.rs b/packet-service/src/packets/cli_normal_chat.rs
new file mode 100644
index 0000000..9c9492c
--- /dev/null
+++ b/packet-service/src/packets/cli_normal_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliNormalChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliNormalChat {}
+
+impl Encode for CliNormalChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliNormalChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_party_chat.rs b/packet-service/src/packets/cli_party_chat.rs
new file mode 100644
index 0000000..cd6a771
--- /dev/null
+++ b/packet-service/src/packets/cli_party_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliPartyChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliPartyChat {}
+
+impl Encode for CliPartyChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_party_reply.rs b/packet-service/src/packets/cli_party_reply.rs
new file mode 100644
index 0000000..9099b75
--- /dev/null
+++ b/packet-service/src/packets/cli_party_reply.rs
@@ -0,0 +1,85 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReplyType {
+    NotFound = 0,
+    Busy = 1,
+    AcceptCreate = 2,
+    AcceptJoin = 3,
+    RejectJoin = 4,
+    Destroy = 5,
+    Full = 6,
+    InvalidLevel = 7,
+    ChangeOwner = 8,
+    ChangeOwnerAndLeave = 9,
+    NoPremium = 10,
+    Bad = 128,
+    Leave = 129,
+    Rejoin = 130,
+}
+
+impl Encode for PartyReplyType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReplyType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReplyType::NotFound),
+            1 => Ok(PartyReplyType::Busy),
+            2 => Ok(PartyReplyType::AcceptCreate),
+            3 => Ok(PartyReplyType::AcceptJoin),
+            4 => Ok(PartyReplyType::RejectJoin),
+            5 => Ok(PartyReplyType::Destroy),
+            6 => Ok(PartyReplyType::Full),
+            7 => Ok(PartyReplyType::InvalidLevel),
+            8 => Ok(PartyReplyType::ChangeOwner),
+            9 => Ok(PartyReplyType::ChangeOwnerAndLeave),
+            10 => Ok(PartyReplyType::NoPremium),
+            128 => Ok(PartyReplyType::Bad),
+            129 => Ok(PartyReplyType::Leave),
+            130 => Ok(PartyReplyType::Rejoin),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReplyType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyReply {
+    pub(crate) type_: PartyReplyType,
+    pub(crate) target: u32,
+}
+
+impl PacketPayload for CliPartyReply {}
+
+impl Encode for CliPartyReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReplyType::decode(decoder)?;
+        let target = u32::decode(decoder)?;
+        Ok(Self { type_, target })
+    }
+}
diff --git a/packet-service/src/packets/cli_party_req.rs b/packet-service/src/packets/cli_party_req.rs
new file mode 100644
index 0000000..0a1e653
--- /dev/null
+++ b/packet-service/src/packets/cli_party_req.rs
@@ -0,0 +1,67 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReqType {
+    Create = 0,
+    Join = 1,
+    Leave = 2,
+    ChangeOwner = 3,
+    Ban = 129,
+}
+
+impl Encode for PartyReqType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReqType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReqType::Create),
+            1 => Ok(PartyReqType::Join),
+            2 => Ok(PartyReqType::Leave),
+            3 => Ok(PartyReqType::ChangeOwner),
+            129 => Ok(PartyReqType::Ban),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReqType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyReq {
+    pub(crate) type_: PartyReqType,
+    pub(crate) target: u16,
+}
+
+impl PacketPayload for CliPartyReq {}
+
+impl Encode for CliPartyReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReqType::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        Ok(Self { type_, target })
+    }
+}
diff --git a/packet-service/src/packets/cli_party_rule.rs b/packet-service/src/packets/cli_party_rule.rs
new file mode 100644
index 0000000..9299c0c
--- /dev/null
+++ b/packet-service/src/packets/cli_party_rule.rs
@@ -0,0 +1,58 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyRule {
+    ExpPerPlayer = 1,
+    ItemInOrder = 128,
+}
+
+impl Encode for PartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(PartyRule::ExpPerPlayer),
+            128 => Ok(PartyRule::ItemInOrder),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyRule: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliPartyRule {
+    pub(crate) rule: PartyRule,
+}
+
+impl PacketPayload for CliPartyRule {}
+
+impl Encode for CliPartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.rule.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let rule = PartyRule::decode(decoder)?;
+        Ok(Self { rule })
+    }
+}
diff --git a/packet-service/src/packets/cli_pickup_item_req.rs b/packet-service/src/packets/cli_pickup_item_req.rs
new file mode 100644
index 0000000..4894614
--- /dev/null
+++ b/packet-service/src/packets/cli_pickup_item_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliPickupItemReq {
+    pub(crate) item_id: u16,
+}
+
+impl PacketPayload for CliPickupItemReq {}
+
+impl Encode for CliPickupItemReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliPickupItemReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let item_id = u16::decode(decoder)?;
+        Ok(Self { item_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_quest_data_req.rs b/packet-service/src/packets/cli_quest_data_req.rs
new file mode 100644
index 0000000..9b78b0e
--- /dev/null
+++ b/packet-service/src/packets/cli_quest_data_req.rs
@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum QuestDataRequestType {
+    Add = 0,
+    Remove = 1,
+    Trigger = 2,
+}
+
+impl Encode for QuestDataRequestType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for QuestDataRequestType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(QuestDataRequestType::Add),
+            1 => Ok(QuestDataRequestType::Remove),
+            2 => Ok(QuestDataRequestType::Trigger),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for QuestDataRequestType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliQuestDataReq {
+    pub(crate) type_: QuestDataRequestType,
+    pub(crate) slot: u8,
+    pub(crate) id: i32,
+}
+
+impl PacketPayload for CliQuestDataReq {}
+
+impl Encode for CliQuestDataReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliQuestDataReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = QuestDataRequestType::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        let id = i32::decode(decoder)?;
+        Ok(Self { type_, slot, id })
+    }
+}
diff --git a/packet-service/src/packets/cli_repair_npc.rs b/packet-service/src/packets/cli_repair_npc.rs
new file mode 100644
index 0000000..3d99285
--- /dev/null
+++ b/packet-service/src/packets/cli_repair_npc.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliRepairNpc {
+    pub(crate) npc_id: u16,
+    pub(crate) target_index: u16,
+}
+
+impl PacketPayload for CliRepairNpc {}
+
+impl Encode for CliRepairNpc {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.npc_id.encode(encoder)?;
+        self.target_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRepairNpc {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let npc_id = u16::decode(decoder)?;
+        let target_index = u16::decode(decoder)?;
+        Ok(Self { npc_id, target_index })
+    }
+}
diff --git a/packet-service/src/packets/cli_repair_use_item.rs b/packet-service/src/packets/cli_repair_use_item.rs
new file mode 100644
index 0000000..523f637
--- /dev/null
+++ b/packet-service/src/packets/cli_repair_use_item.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliRepairUseItem {
+    pub(crate) index: u16,
+    pub(crate) target_index: u16,
+}
+
+impl PacketPayload for CliRepairUseItem {}
+
+impl Encode for CliRepairUseItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.target_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRepairUseItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let target_index = u16::decode(decoder)?;
+        Ok(Self { index, target_index })
+    }
+}
diff --git a/packet-service/src/packets/cli_revive_req.rs b/packet-service/src/packets/cli_revive_req.rs
new file mode 100644
index 0000000..9481a3f
--- /dev/null
+++ b/packet-service/src/packets/cli_revive_req.rs
@@ -0,0 +1,62 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ReviveRequest {
+    RevivePosition = 1,
+    SavePosition = 2,
+    StartPosition = 3,
+    CurrentPosition = 4,
+}
+
+impl Encode for ReviveRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ReviveRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(ReviveRequest::RevivePosition),
+            2 => Ok(ReviveRequest::SavePosition),
+            3 => Ok(ReviveRequest::StartPosition),
+            4 => Ok(ReviveRequest::CurrentPosition),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ReviveRequest: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliReviveReq {
+    pub(crate) revive_type: ReviveRequest,
+}
+
+impl PacketPayload for CliReviveReq {}
+
+impl Encode for CliReviveReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.revive_type.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliReviveReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let revive_type = ReviveRequest::decode(decoder)?;
+        Ok(Self { revive_type })
+    }
+}
diff --git a/packet-service/src/packets/cli_revive_set_pos.rs b/packet-service/src/packets/cli_revive_set_pos.rs
new file mode 100644
index 0000000..9c37df9
--- /dev/null
+++ b/packet-service/src/packets/cli_revive_set_pos.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliReviveSetPos {}
+
+impl PacketPayload for CliReviveSetPos {}
+
+impl Encode for CliReviveSetPos {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliReviveSetPos {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_ride_request.rs b/packet-service/src/packets/cli_ride_request.rs
new file mode 100644
index 0000000..a5e8eda
--- /dev/null
+++ b/packet-service/src/packets/cli_ride_request.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum RideAction {
+    Request = 0,
+    Accept = 1,
+    Refuse = 2,
+    OwnerNotFound = 3,
+    GuestNotFound = 4,
+}
+
+impl Encode for RideAction {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for RideAction {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(RideAction::Request),
+            1 => Ok(RideAction::Accept),
+            2 => Ok(RideAction::Refuse),
+            3 => Ok(RideAction::OwnerNotFound),
+            4 => Ok(RideAction::GuestNotFound),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for RideAction: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliRideRequest {
+    pub(crate) action: RideAction,
+    pub(crate) owner: u16,
+    pub(crate) guest: u32,
+}
+
+impl PacketPayload for CliRideRequest {}
+
+impl Encode for CliRideRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.action.encode(encoder)?;
+        self.owner.encode(encoder)?;
+        self.guest.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliRideRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let action = RideAction::decode(decoder)?;
+        let owner = u16::decode(decoder)?;
+        let guest = u32::decode(decoder)?;
+        Ok(Self { action, owner, guest })
+    }
+}
diff --git a/packet-service/src/packets/cli_screen_shot_time_req.rs b/packet-service/src/packets/cli_screen_shot_time_req.rs
new file mode 100644
index 0000000..d1eea7c
--- /dev/null
+++ b/packet-service/src/packets/cli_screen_shot_time_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliScreenShotTimeReq {
+    pub(crate) count: u16,
+}
+
+impl PacketPayload for CliScreenShotTimeReq {}
+
+impl Encode for CliScreenShotTimeReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliScreenShotTimeReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let count = u16::decode(decoder)?;
+        Ok(Self { count })
+    }
+}
diff --git a/packet-service/src/packets/cli_select_char_req.rs b/packet-service/src/packets/cli_select_char_req.rs
new file mode 100644
index 0000000..fd4d370
--- /dev/null
+++ b/packet-service/src/packets/cli_select_char_req.rs
@@ -0,0 +1,45 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSelectCharReq {
+    pub(crate) char_id: u8,
+    pub(crate) run_mode: u8,
+    pub(crate) ride_mode: u8,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for CliSelectCharReq {}
+
+impl Encode for CliSelectCharReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.run_mode.encode(encoder)?;
+        self.ride_mode.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSelectCharReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u8::decode(decoder)?;
+        let run_mode = u8::decode(decoder)?;
+        let ride_mode = u8::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            run_mode,
+            ride_mode,
+            name,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_set_animation.rs b/packet-service/src/packets/cli_set_animation.rs
new file mode 100644
index 0000000..537c426
--- /dev/null
+++ b/packet-service/src/packets/cli_set_animation.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetAnimation {
+    pub(crate) id: u16,
+    pub(crate) value: u16,
+}
+
+impl PacketPayload for CliSetAnimation {}
+
+impl Encode for CliSetAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let value = u16::decode(decoder)?;
+        Ok(Self { id, value })
+    }
+}
diff --git a/packet-service/src/packets/cli_set_position.rs b/packet-service/src/packets/cli_set_position.rs
new file mode 100644
index 0000000..2fa3986
--- /dev/null
+++ b/packet-service/src/packets/cli_set_position.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetPosition {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliSetPosition {}
+
+impl Encode for CliSetPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { x, y })
+    }
+}
diff --git a/packet-service/src/packets/cli_set_server_var_req.rs b/packet-service/src/packets/cli_set_server_var_req.rs
new file mode 100644
index 0000000..56acb6b
--- /dev/null
+++ b/packet-service/src/packets/cli_set_server_var_req.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetServerVarReq {
+    pub(crate) type_: u8,
+    pub(crate) value: u32,
+}
+
+impl PacketPayload for CliSetServerVarReq {}
+
+impl Encode for CliSetServerVarReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetServerVarReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let value = u32::decode(decoder)?;
+        Ok(Self { type_, value })
+    }
+}
diff --git a/packet-service/src/packets/cli_set_weight_req.rs b/packet-service/src/packets/cli_set_weight_req.rs
new file mode 100644
index 0000000..af7e17d
--- /dev/null
+++ b/packet-service/src/packets/cli_set_weight_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSetWeightReq {
+    pub(crate) weight: u8,
+}
+
+impl PacketPayload for CliSetWeightReq {}
+
+impl Encode for CliSetWeightReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.weight.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSetWeightReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let weight = u8::decode(decoder)?;
+        Ok(Self { weight })
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_buy_req.rs b/packet-service/src/packets/cli_shop_buy_req.rs
new file mode 100644
index 0000000..f8a92af
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_buy_req.rs
@@ -0,0 +1,151 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopBuyItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopBuyItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuyItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopBuyReq {
+    pub(crate) id: u16,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopBuyItem>,
+}
+
+impl PacketPayload for CliShopBuyReq {}
+
+impl Encode for CliShopBuyReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopBuyReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { id, count, items })
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_buysell_reply.rs b/packet-service/src/packets/cli_shop_buysell_reply.rs
new file mode 100644
index 0000000..429eac6
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_buysell_reply.rs
@@ -0,0 +1,196 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ShopBuySellResult {
+    Null = 0,
+    SoldOut = 1,
+    OverSold = 2,
+    BuyPartial = 3,
+    BuyAll = 4,
+    SellPartial = 5,
+    SellAll = 6,
+}
+
+impl Encode for ShopBuySellResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuySellResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(ShopBuySellResult::Null),
+            1 => Ok(ShopBuySellResult::SoldOut),
+            2 => Ok(ShopBuySellResult::OverSold),
+            3 => Ok(ShopBuySellResult::BuyPartial),
+            4 => Ok(ShopBuySellResult::BuyAll),
+            5 => Ok(ShopBuySellResult::SellPartial),
+            6 => Ok(ShopBuySellResult::SellAll),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ShopBuySellResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopBuySellItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopBuySellItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopBuySellItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopBuysellReply {
+    pub(crate) id: u16,
+    pub(crate) result: ShopBuySellResult,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopBuySellItem>,
+}
+
+impl PacketPayload for CliShopBuysellReply {}
+
+impl Encode for CliShopBuysellReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.result.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopBuysellReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let result = ShopBuySellResult::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self {
+            id,
+            result,
+            count,
+            items,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_close.rs b/packet-service/src/packets/cli_shop_close.rs
new file mode 100644
index 0000000..de52b9e
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_close.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShopClose {}
+
+impl PacketPayload for CliShopClose {}
+
+impl Encode for CliShopClose {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopClose {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_list_req.rs b/packet-service/src/packets/cli_shop_list_req.rs
new file mode 100644
index 0000000..9df229a
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_list_req.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShopListReq {
+    pub(crate) id: u16,
+}
+
+impl PacketPayload for CliShopListReq {}
+
+impl Encode for CliShopListReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopListReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        Ok(Self { id })
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_open.rs b/packet-service/src/packets/cli_shop_open.rs
new file mode 100644
index 0000000..a988219
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_open.rs
@@ -0,0 +1,158 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+    pub(crate) price: u32,
+}
+
+impl Encode for ShopItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.price.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let price = u32::decode(decoder)?;
+        Ok(Self { index, item, price })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopOpen {
+    pub(crate) sell_count: u8,
+    pub(crate) wishlist_count: u8,
+    pub(crate) items: Vec<ShopItem>,
+}
+
+impl PacketPayload for CliShopOpen {}
+
+impl Encode for CliShopOpen {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sell_count.encode(encoder)?;
+        self.wishlist_count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopOpen {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sell_count = u8::decode(decoder)?;
+        let wishlist_count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self {
+            sell_count,
+            wishlist_count,
+            items,
+        })
+    }
+}
diff --git a/packet-service/src/packets/cli_shop_sell_req.rs b/packet-service/src/packets/cli_shop_sell_req.rs
new file mode 100644
index 0000000..0c17a34
--- /dev/null
+++ b/packet-service/src/packets/cli_shop_sell_req.rs
@@ -0,0 +1,158 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopSellItem {
+    pub(crate) inventory_index: u8,
+    pub(crate) wishlist_index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for ShopSellItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory_index.encode(encoder)?;
+        self.wishlist_index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopSellItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory_index = u8::decode(decoder)?;
+        let wishlist_index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self {
+            inventory_index,
+            wishlist_index,
+            item,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliShopSellReq {
+    pub(crate) id: u16,
+    pub(crate) count: u8,
+    pub(crate) items: Vec<ShopSellItem>,
+}
+
+impl PacketPayload for CliShopSellReq {}
+
+impl Encode for CliShopSellReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShopSellReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { id, count, items })
+    }
+}
diff --git a/packet-service/src/packets/cli_shout_chat.rs b/packet-service/src/packets/cli_shout_chat.rs
new file mode 100644
index 0000000..0564d6e
--- /dev/null
+++ b/packet-service/src/packets/cli_shout_chat.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliShoutChat {
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliShoutChat {}
+
+impl Encode for CliShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message })
+    }
+}
diff --git a/packet-service/src/packets/cli_skill_cast_position.rs b/packet-service/src/packets/cli_skill_cast_position.rs
new file mode 100644
index 0000000..bf78d99
--- /dev/null
+++ b/packet-service/src/packets/cli_skill_cast_position.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastPosition {
+    pub(crate) slot: u8,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliSkillCastPosition {}
+
+impl Encode for CliSkillCastPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { slot, x, y })
+    }
+}
diff --git a/packet-service/src/packets/cli_skill_cast_self.rs b/packet-service/src/packets/cli_skill_cast_self.rs
new file mode 100644
index 0000000..8280d42
--- /dev/null
+++ b/packet-service/src/packets/cli_skill_cast_self.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastSelf {
+    pub(crate) slot: u8,
+}
+
+impl PacketPayload for CliSkillCastSelf {}
+
+impl Encode for CliSkillCastSelf {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastSelf {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        Ok(Self { slot })
+    }
+}
diff --git a/packet-service/src/packets/cli_skill_cast_target.rs b/packet-service/src/packets/cli_skill_cast_target.rs
new file mode 100644
index 0000000..d1b3338
--- /dev/null
+++ b/packet-service/src/packets/cli_skill_cast_target.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillCastTarget {
+    pub(crate) target: u16,
+    pub(crate) slot: u8,
+}
+
+impl PacketPayload for CliSkillCastTarget {}
+
+impl Encode for CliSkillCastTarget {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillCastTarget {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        Ok(Self { target, slot })
+    }
+}
diff --git a/packet-service/src/packets/cli_skill_level_req.rs b/packet-service/src/packets/cli_skill_level_req.rs
new file mode 100644
index 0000000..4d186e2
--- /dev/null
+++ b/packet-service/src/packets/cli_skill_level_req.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSkillLevelReq {
+    pub(crate) slot: u8,
+    pub(crate) next_index: i16,
+}
+
+impl PacketPayload for CliSkillLevelReq {}
+
+impl Encode for CliSkillLevelReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.next_index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSkillLevelReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let next_index = i16::decode(decoder)?;
+        Ok(Self { slot, next_index })
+    }
+}
diff --git a/packet-service/src/packets/cli_srv_select_req.rs b/packet-service/src/packets/cli_srv_select_req.rs
new file mode 100644
index 0000000..a98145f
--- /dev/null
+++ b/packet-service/src/packets/cli_srv_select_req.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliSrvSelectReq {
+    pub(crate) server_id: u32,
+    pub(crate) channel_id: u8,
+}
+
+impl PacketPayload for CliSrvSelectReq {}
+
+impl Encode for CliSrvSelectReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.server_id.encode(encoder)?;
+        self.channel_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliSrvSelectReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let server_id = u32::decode(decoder)?;
+        let channel_id = u8::decode(decoder)?;
+        Ok(Self { server_id, channel_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_stat_add_req.rs b/packet-service/src/packets/cli_stat_add_req.rs
new file mode 100644
index 0000000..0dfcfb6
--- /dev/null
+++ b/packet-service/src/packets/cli_stat_add_req.rs
@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Stat {
+    Str = 0,
+    Dex = 1,
+    Int = 2,
+    Con = 3,
+    Cha = 4,
+    Sen = 5,
+}
+
+impl Encode for Stat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Stat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Stat::Str),
+            1 => Ok(Stat::Dex),
+            2 => Ok(Stat::Int),
+            3 => Ok(Stat::Con),
+            4 => Ok(Stat::Cha),
+            5 => Ok(Stat::Sen),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Stat: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliStatAddReq {
+    pub(crate) stat: Stat,
+}
+
+impl PacketPayload for CliStatAddReq {}
+
+impl Encode for CliStatAddReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.stat.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStatAddReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let stat = Stat::decode(decoder)?;
+        Ok(Self { stat })
+    }
+}
diff --git a/packet-service/src/packets/cli_stop.rs b/packet-service/src/packets/cli_stop.rs
new file mode 100644
index 0000000..a52e8a8
--- /dev/null
+++ b/packet-service/src/packets/cli_stop.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliStop {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliStop {}
+
+impl Encode for CliStop {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStop {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { x, y })
+    }
+}
diff --git a/packet-service/src/packets/cli_stop_moving.rs b/packet-service/src/packets/cli_stop_moving.rs
new file mode 100644
index 0000000..a5ed270
--- /dev/null
+++ b/packet-service/src/packets/cli_stop_moving.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliStopMoving {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for CliStopMoving {}
+
+impl Encode for CliStopMoving {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStopMoving {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self { x, y, z })
+    }
+}
diff --git a/packet-service/src/packets/cli_store_trade_req.rs b/packet-service/src/packets/cli_store_trade_req.rs
new file mode 100644
index 0000000..c176101
--- /dev/null
+++ b/packet-service/src/packets/cli_store_trade_req.rs
@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum StoreTradeResult {
+    PriceDiff = 1,
+    InvalidNpc = 2,
+    TooFar = 3,
+    NoMoney = 4,
+    InvalidUnion = 5,
+    NoPoints = 6,
+}
+
+impl Encode for StoreTradeResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for StoreTradeResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(StoreTradeResult::PriceDiff),
+            2 => Ok(StoreTradeResult::InvalidNpc),
+            3 => Ok(StoreTradeResult::TooFar),
+            4 => Ok(StoreTradeResult::NoMoney),
+            5 => Ok(StoreTradeResult::InvalidUnion),
+            6 => Ok(StoreTradeResult::NoPoints),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for StoreTradeResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliStoreTradeReq {
+    pub(crate) result: StoreTradeResult,
+}
+
+impl PacketPayload for CliStoreTradeReq {}
+
+impl Encode for CliStoreTradeReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliStoreTradeReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = StoreTradeResult::decode(decoder)?;
+        Ok(Self { result })
+    }
+}
diff --git a/packet-service/src/packets/cli_teleport_req.rs b/packet-service/src/packets/cli_teleport_req.rs
new file mode 100644
index 0000000..e1e5c9a
--- /dev/null
+++ b/packet-service/src/packets/cli_teleport_req.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliTeleportReq {
+    pub(crate) id: i16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+}
+
+impl PacketPayload for CliTeleportReq {}
+
+impl Encode for CliTeleportReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTeleportReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = i16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        Ok(Self { id, x, y })
+    }
+}
diff --git a/packet-service/src/packets/cli_toggle_move.rs b/packet-service/src/packets/cli_toggle_move.rs
new file mode 100644
index 0000000..41cc7a1
--- /dev/null
+++ b/packet-service/src/packets/cli_toggle_move.rs
@@ -0,0 +1,60 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ToggleMove {
+    Run = 0,
+    Sit = 1,
+    Drive = 2,
+}
+
+impl Encode for ToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(ToggleMove::Run),
+            1 => Ok(ToggleMove::Sit),
+            2 => Ok(ToggleMove::Drive),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ToggleMove: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliToggleMove {
+    pub(crate) type_: ToggleMove,
+}
+
+impl PacketPayload for CliToggleMove {}
+
+impl Encode for CliToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = ToggleMove::decode(decoder)?;
+        Ok(Self { type_ })
+    }
+}
diff --git a/packet-service/src/packets/cli_trade.rs b/packet-service/src/packets/cli_trade.rs
new file mode 100644
index 0000000..9ff0e18
--- /dev/null
+++ b/packet-service/src/packets/cli_trade.rs
@@ -0,0 +1,84 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum TradeState {
+    Request = 0,
+    Accept = 1,
+    Reject = 2,
+    Cancel = 3,
+    Ready = 4,
+    Notready = 5,
+    Done = 6,
+    Busy = 7,
+    TooFar = 8,
+    InvalidTarget = 9,
+    NoSpace = 10,
+    TradeDisabled = 11,
+}
+
+impl Encode for TradeState {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for TradeState {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(TradeState::Request),
+            1 => Ok(TradeState::Accept),
+            2 => Ok(TradeState::Reject),
+            3 => Ok(TradeState::Cancel),
+            4 => Ok(TradeState::Ready),
+            5 => Ok(TradeState::Notready),
+            6 => Ok(TradeState::Done),
+            7 => Ok(TradeState::Busy),
+            8 => Ok(TradeState::TooFar),
+            9 => Ok(TradeState::InvalidTarget),
+            10 => Ok(TradeState::NoSpace),
+            11 => Ok(TradeState::TradeDisabled),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for TradeState: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CliTrade {
+    pub(crate) state: TradeState,
+    pub(crate) target: u16,
+    pub(crate) index: u8,
+}
+
+impl PacketPayload for CliTrade {}
+
+impl Encode for CliTrade {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.state.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTrade {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let state = TradeState::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        Ok(Self { state, target, index })
+    }
+}
diff --git a/packet-service/src/packets/cli_trade_item.rs b/packet-service/src/packets/cli_trade_item.rs
new file mode 100644
index 0000000..b634e66
--- /dev/null
+++ b/packet-service/src/packets/cli_trade_item.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliTradeItem {
+    pub(crate) slot: u8,
+    pub(crate) index: u16,
+    pub(crate) amount: u32,
+}
+
+impl PacketPayload for CliTradeItem {}
+
+impl Encode for CliTradeItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.index.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliTradeItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let index = u16::decode(decoder)?;
+        let amount = u32::decode(decoder)?;
+        Ok(Self { slot, index, amount })
+    }
+}
diff --git a/packet-service/src/packets/cli_use_item.rs b/packet-service/src/packets/cli_use_item.rs
new file mode 100644
index 0000000..3f3dd57
--- /dev/null
+++ b/packet-service/src/packets/cli_use_item.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliUseItem {
+    pub(crate) index: u16,
+    pub(crate) item_id: u16,
+}
+
+impl PacketPayload for CliUseItem {}
+
+impl Encode for CliUseItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliUseItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let item_id = u16::decode(decoder)?;
+        Ok(Self { index, item_id })
+    }
+}
diff --git a/packet-service/src/packets/cli_whisper_chat.rs b/packet-service/src/packets/cli_whisper_chat.rs
new file mode 100644
index 0000000..1ebb989
--- /dev/null
+++ b/packet-service/src/packets/cli_whisper_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct CliWhisperChat {
+    pub(crate) target: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for CliWhisperChat {}
+
+impl Encode for CliWhisperChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliWhisperChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { target, message })
+    }
+}
diff --git a/packet-service/src/packets/cli_wishlist_add.rs b/packet-service/src/packets/cli_wishlist_add.rs
new file mode 100644
index 0000000..b7ae7ec
--- /dev/null
+++ b/packet-service/src/packets/cli_wishlist_add.rs
@@ -0,0 +1,126 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct CliWishlistAdd {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for CliWishlistAdd {}
+
+impl Encode for CliWishlistAdd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CliWishlistAdd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
diff --git a/packet-service/src/packets/mod.rs b/packet-service/src/packets/mod.rs
new file mode 100644
index 0000000..5161c4c
--- /dev/null
+++ b/packet-service/src/packets/mod.rs
@@ -0,0 +1,199 @@
+pub mod cli_accept_req;
+pub mod cli_alive;
+pub mod cli_allied_chat;
+pub mod cli_allied_shout_chat;
+pub mod cli_appraisal_req;
+pub mod cli_attack;
+pub mod cli_bank_list_req;
+pub mod cli_bank_move_item;
+pub mod cli_bank_move_money;
+pub mod cli_change_char_req;
+pub mod cli_change_map_req;
+pub mod cli_channel_list_req;
+pub mod cli_char_list_req;
+pub mod cli_chatroom;
+pub mod cli_chatroom_message;
+pub mod cli_clan_chat;
+pub mod cli_clan_command;
+pub mod cli_clan_icon_req;
+pub mod cli_clan_icon_set;
+pub mod cli_clan_icon_timestamp;
+pub mod cli_craft_enhance_req;
+pub mod cli_craft_req;
+pub mod cli_craft_status;
+pub mod cli_create_char_req;
+pub mod cli_damage;
+pub mod cli_delete_char_req;
+pub mod cli_drop_item;
+pub mod cli_equip_item;
+pub mod cli_equip_item_ride;
+pub mod cli_equip_projectile;
+pub mod cli_hotbar_set_icon_req;
+pub mod cli_hp_req;
+pub mod cli_join_server_req;
+pub mod cli_join_server_token_req;
+pub mod cli_login_req;
+pub mod cli_login_token_req;
+pub mod cli_logout_req;
+pub mod cli_memo;
+pub mod cli_messenger;
+pub mod cli_messenger_chat;
+pub mod cli_mouse_cmd;
+pub mod cli_normal_chat;
+pub mod cli_party_chat;
+pub mod cli_party_reply;
+pub mod cli_party_req;
+pub mod cli_party_rule;
+pub mod cli_pickup_item_req;
+pub mod cli_quest_data_req;
+pub mod cli_repair_npc;
+pub mod cli_repair_use_item;
+pub mod cli_revive_req;
+pub mod cli_revive_set_pos;
+pub mod cli_ride_request;
+pub mod cli_screen_shot_time_req;
+pub mod cli_select_char_req;
+pub mod cli_set_animation;
+pub mod cli_set_position;
+pub mod cli_set_server_var_req;
+pub mod cli_set_weight_req;
+pub mod cli_shop_buy_req;
+pub mod cli_shop_buysell_reply;
+pub mod cli_shop_close;
+pub mod cli_shop_list_req;
+pub mod cli_shop_open;
+pub mod cli_shop_sell_req;
+pub mod cli_shout_chat;
+pub mod cli_skill_cast_position;
+pub mod cli_skill_cast_self;
+pub mod cli_skill_cast_target;
+pub mod cli_skill_level_req;
+pub mod cli_srv_select_req;
+pub mod cli_stat_add_req;
+pub mod cli_stop;
+pub mod cli_stop_moving;
+pub mod cli_store_trade_req;
+pub mod cli_teleport_req;
+pub mod cli_toggle_move;
+pub mod cli_trade;
+pub mod cli_trade_item;
+pub mod cli_use_item;
+pub mod cli_whisper_chat;
+pub mod cli_wishlist_add;
+pub mod srv_accept_reply;
+pub mod srv_allied_chat;
+pub mod srv_allied_shout_chat;
+pub mod srv_announce_chat;
+pub mod srv_appraisal_reply;
+pub mod srv_attack;
+pub mod srv_bank_list_reply;
+pub mod srv_bank_move_item;
+pub mod srv_bank_move_money;
+pub mod srv_billing_message;
+pub mod srv_chan_char_reply;
+pub mod srv_change_map_reply;
+pub mod srv_change_skin;
+pub mod srv_channel_list_reply;
+pub mod srv_char_list_reply;
+pub mod srv_char_state_change;
+pub mod srv_chatroom;
+pub mod srv_chatroom_message;
+pub mod srv_clan_chat;
+pub mod srv_clan_command;
+pub mod srv_clan_icon_reply;
+pub mod srv_clan_icon_timestamp;
+pub mod srv_clear_status;
+pub mod srv_craft_enhance_reply;
+pub mod srv_craft_reply;
+pub mod srv_craft_status;
+pub mod srv_create_char_reply;
+pub mod srv_damage;
+pub mod srv_delete_char_reply;
+pub mod srv_drop_item;
+pub mod srv_equip_item;
+pub mod srv_equip_item_ride;
+pub mod srv_equip_projectile;
+pub mod srv_event_add;
+pub mod srv_event_status;
+pub mod srv_fairy;
+pub mod srv_global_flags;
+pub mod srv_global_vars;
+pub mod srv_gm_command_code;
+pub mod srv_hotbar_set_icon_reply;
+pub mod srv_hp_reply;
+pub mod srv_inventory_data;
+pub mod srv_join_server_reply;
+pub mod srv_levelup;
+pub mod srv_login_reply;
+pub mod srv_logout_reply;
+pub mod srv_memo;
+pub mod srv_messenger;
+pub mod srv_messenger_chat;
+pub mod srv_mob_char;
+pub mod srv_mouse_cmd;
+pub mod srv_move;
+pub mod srv_normal_chat;
+pub mod srv_npc_char;
+pub mod srv_npc_event;
+pub mod srv_npc_show;
+pub mod srv_party_chat;
+pub mod srv_party_item;
+pub mod srv_party_levelexp;
+pub mod srv_party_member;
+pub mod srv_party_member_update;
+pub mod srv_party_reply;
+pub mod srv_party_req;
+pub mod srv_party_rule;
+pub mod srv_pickup_item_reply;
+pub mod srv_player_char;
+pub mod srv_quest_data;
+pub mod srv_quest_data_reply;
+pub mod srv_quest_reward_add_value;
+pub mod srv_quest_reward_set_value;
+pub mod srv_remove_object;
+pub mod srv_revive_reply;
+pub mod srv_ride_request;
+pub mod srv_ride_state_change;
+pub mod srv_screen_shot_time_reply;
+pub mod srv_select_char_reply;
+pub mod srv_server_data;
+pub mod srv_set_animation;
+pub mod srv_set_exp;
+pub mod srv_set_hp_and_mp;
+pub mod srv_set_item;
+pub mod srv_set_item_life;
+pub mod srv_set_money;
+pub mod srv_set_money_and_item;
+pub mod srv_set_position;
+pub mod srv_set_server_var_reply;
+pub mod srv_set_weight;
+pub mod srv_setexp;
+pub mod srv_shop_close;
+pub mod srv_shop_list_reply;
+pub mod srv_shop_open;
+pub mod srv_shout_chat;
+pub mod srv_skill_cancel;
+pub mod srv_skill_cast_position;
+pub mod srv_skill_cast_self;
+pub mod srv_skill_cast_target;
+pub mod srv_skill_damage;
+pub mod srv_skill_effect;
+pub mod srv_skill_finish;
+pub mod srv_skill_learn;
+pub mod srv_skill_level_reply;
+pub mod srv_skill_start;
+pub mod srv_speed_changed;
+pub mod srv_srv_select_reply;
+pub mod srv_stat_add_reply;
+pub mod srv_stop;
+pub mod srv_stop_moving;
+pub mod srv_store_trade_reply;
+pub mod srv_switch_server;
+pub mod srv_teleport_reply;
+pub mod srv_toggle_move;
+pub mod srv_trade;
+pub mod srv_trade_item;
+pub mod srv_update_name;
+pub mod srv_update_npc;
+pub mod srv_use_item;
+pub mod srv_whisper_chat;
diff --git a/packet-service/src/packets/srv_accept_reply.rs b/packet-service/src/packets/srv_accept_reply.rs
new file mode 100644
index 0000000..54d0e2c
--- /dev/null
+++ b/packet-service/src/packets/srv_accept_reply.rs
@@ -0,0 +1,65 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Connect = 1,
+    Accepted = 2,
+    Disconnect = 3,
+    Derverdead = 4,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(Result::Connect),
+            2 => Ok(Result::Accepted),
+            3 => Ok(Result::Disconnect),
+            4 => Ok(Result::Derverdead),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvAcceptReply {
+    pub(crate) result: Result,
+    pub(crate) rand_value: u32,
+}
+
+impl PacketPayload for SrvAcceptReply {}
+
+impl Encode for SrvAcceptReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.rand_value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAcceptReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let rand_value = u32::decode(decoder)?;
+        Ok(Self { result, rand_value })
+    }
+}
diff --git a/packet-service/src/packets/srv_allied_chat.rs b/packet-service/src/packets/srv_allied_chat.rs
new file mode 100644
index 0000000..299846f
--- /dev/null
+++ b/packet-service/src/packets/srv_allied_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAlliedChat {
+    pub(crate) team: u32,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAlliedChat {}
+
+impl Encode for SrvAlliedChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.team.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAlliedChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let team = u32::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { team, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_allied_shout_chat.rs b/packet-service/src/packets/srv_allied_shout_chat.rs
new file mode 100644
index 0000000..af0ab63
--- /dev/null
+++ b/packet-service/src/packets/srv_allied_shout_chat.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAlliedShoutChat {
+    pub(crate) team: u32,
+    pub(crate) sender: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAlliedShoutChat {}
+
+impl Encode for SrvAlliedShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.team.encode(encoder)?;
+        self.sender.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAlliedShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let team = u32::decode(decoder)?;
+        let sender = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { team, sender, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_announce_chat.rs b/packet-service/src/packets/srv_announce_chat.rs
new file mode 100644
index 0000000..cc9cc30
--- /dev/null
+++ b/packet-service/src/packets/srv_announce_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAnnounceChat {
+    pub(crate) message: NullTerminatedString,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvAnnounceChat {}
+
+impl Encode for SrvAnnounceChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.message.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAnnounceChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let message = NullTerminatedString::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { message, name })
+    }
+}
diff --git a/packet-service/src/packets/srv_appraisal_reply.rs b/packet-service/src/packets/srv_appraisal_reply.rs
new file mode 100644
index 0000000..0356b94
--- /dev/null
+++ b/packet-service/src/packets/srv_appraisal_reply.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct AppraisalReply {
+    pub(crate) index: u16,
+    pub(crate) result: u8,
+}
+
+impl Encode for AppraisalReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for AppraisalReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let result = u8::decode(decoder)?;
+        Ok(Self { index, result })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvAppraisalReply {
+    pub(crate) result: AppraisalReply,
+}
+
+impl PacketPayload for SrvAppraisalReply {}
+
+impl Encode for SrvAppraisalReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAppraisalReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = AppraisalReply::decode(decoder)?;
+        Ok(Self { result })
+    }
+}
diff --git a/packet-service/src/packets/srv_attack.rs b/packet-service/src/packets/srv_attack.rs
new file mode 100644
index 0000000..ed99eaa
--- /dev/null
+++ b/packet-service/src/packets/srv_attack.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvAttack {
+    pub(crate) attacker_id: u16,
+    pub(crate) defender_id: u16,
+    pub(crate) distance: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for SrvAttack {}
+
+impl Encode for SrvAttack {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.attacker_id.encode(encoder)?;
+        self.defender_id.encode(encoder)?;
+        self.distance.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvAttack {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let attacker_id = u16::decode(decoder)?;
+        let defender_id = u16::decode(decoder)?;
+        let distance = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self {
+            attacker_id,
+            defender_id,
+            distance,
+            x,
+            y,
+            z,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_bank_list_reply.rs b/packet-service/src/packets/srv_bank_list_reply.rs
new file mode 100644
index 0000000..a3e132e
--- /dev/null
+++ b/packet-service/src/packets/srv_bank_list_reply.rs
@@ -0,0 +1,183 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum BankListReply {
+    InitData = 0,
+    ShowData = 1,
+    NeedPassword = 2,
+    ChangedPassword = 3,
+    ClearedPassword = 4,
+    Platinum = 5,
+}
+
+impl Encode for BankListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for BankListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(BankListReply::InitData),
+            1 => Ok(BankListReply::ShowData),
+            2 => Ok(BankListReply::NeedPassword),
+            3 => Ok(BankListReply::ChangedPassword),
+            4 => Ok(BankListReply::ClearedPassword),
+            5 => Ok(BankListReply::Platinum),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for BankListReply: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct BankListItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for BankListItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for BankListItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvBankListReply {
+    pub(crate) reply: BankListReply,
+    pub(crate) items: Vec<BankListItem>,
+}
+
+impl PacketPayload for SrvBankListReply {}
+
+impl Encode for SrvBankListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.reply.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let reply = BankListReply::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { reply, items })
+    }
+}
diff --git a/packet-service/src/packets/srv_bank_move_item.rs b/packet-service/src/packets/srv_bank_move_item.rs
new file mode 100644
index 0000000..7f78300
--- /dev/null
+++ b/packet-service/src/packets/srv_bank_move_item.rs
@@ -0,0 +1,141 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvBankMoveItem {
+    pub(crate) inventory_index: i16,
+    pub(crate) bank_index: i16,
+    pub(crate) inventory_item: Item,
+    pub(crate) bank_item: Item,
+    pub(crate) money: i64,
+}
+
+impl PacketPayload for SrvBankMoveItem {}
+
+impl Encode for SrvBankMoveItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory_index.encode(encoder)?;
+        self.bank_index.encode(encoder)?;
+        self.inventory_item.encode(encoder)?;
+        self.bank_item.encode(encoder)?;
+        self.money.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankMoveItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory_index = i16::decode(decoder)?;
+        let bank_index = i16::decode(decoder)?;
+        let inventory_item = Item::decode(decoder)?;
+        let bank_item = Item::decode(decoder)?;
+        let money = i64::decode(decoder)?;
+        Ok(Self {
+            inventory_index,
+            bank_index,
+            inventory_item,
+            bank_item,
+            money,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_bank_move_money.rs b/packet-service/src/packets/srv_bank_move_money.rs
new file mode 100644
index 0000000..342ae29
--- /dev/null
+++ b/packet-service/src/packets/srv_bank_move_money.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvBankMoveMoney {
+    pub(crate) inventory: i64,
+    pub(crate) bank: i64,
+}
+
+impl PacketPayload for SrvBankMoveMoney {}
+
+impl Encode for SrvBankMoveMoney {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.inventory.encode(encoder)?;
+        self.bank.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBankMoveMoney {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let inventory = i64::decode(decoder)?;
+        let bank = i64::decode(decoder)?;
+        Ok(Self { inventory, bank })
+    }
+}
diff --git a/packet-service/src/packets/srv_billing_message.rs b/packet-service/src/packets/srv_billing_message.rs
new file mode 100644
index 0000000..df228b4
--- /dev/null
+++ b/packet-service/src/packets/srv_billing_message.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvBillingMessage {
+    pub(crate) function_type: u16,
+    pub(crate) pay_flag: u32,
+}
+
+impl PacketPayload for SrvBillingMessage {}
+
+impl Encode for SrvBillingMessage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.function_type.encode(encoder)?;
+        self.pay_flag.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvBillingMessage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let function_type = u16::decode(decoder)?;
+        let pay_flag = u32::decode(decoder)?;
+        Ok(Self {
+            function_type,
+            pay_flag,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_chan_char_reply.rs b/packet-service/src/packets/srv_chan_char_reply.rs
new file mode 100644
index 0000000..905f5b7
--- /dev/null
+++ b/packet-service/src/packets/srv_chan_char_reply.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChanCharReply {}
+
+impl PacketPayload for SrvChanCharReply {}
+
+impl Encode for SrvChanCharReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChanCharReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_change_map_reply.rs b/packet-service/src/packets/srv_change_map_reply.rs
new file mode 100644
index 0000000..8fe8917
--- /dev/null
+++ b/packet-service/src/packets/srv_change_map_reply.rs
@@ -0,0 +1,86 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChangeMapReply {
+    pub(crate) object_index: u16,
+    pub(crate) hp: u16,
+    pub(crate) mp: u16,
+    pub(crate) xp: u16,
+    pub(crate) penalize_xp: u16,
+    pub(crate) craft_rate: u16,
+    pub(crate) update_time: u16,
+    pub(crate) world_rate: u16,
+    pub(crate) town_rate: u8,
+    pub(crate) item_rate: [u8; (MAX_SELL_TYPE as usize)],
+    pub(crate) flags: u32,
+    pub(crate) world_time: u16,
+    pub(crate) team_number: u16,
+}
+
+impl PacketPayload for SrvChangeMapReply {}
+
+impl Encode for SrvChangeMapReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.object_index.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.mp.encode(encoder)?;
+        self.xp.encode(encoder)?;
+        self.penalize_xp.encode(encoder)?;
+        self.craft_rate.encode(encoder)?;
+        self.update_time.encode(encoder)?;
+        self.world_rate.encode(encoder)?;
+        self.town_rate.encode(encoder)?;
+        for value in &self.item_rate {
+            value.encode(encoder)?;
+        }
+        self.flags.encode(encoder)?;
+        self.world_time.encode(encoder)?;
+        self.team_number.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChangeMapReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let object_index = u16::decode(decoder)?;
+        let hp = u16::decode(decoder)?;
+        let mp = u16::decode(decoder)?;
+        let xp = u16::decode(decoder)?;
+        let penalize_xp = u16::decode(decoder)?;
+        let craft_rate = u16::decode(decoder)?;
+        let update_time = u16::decode(decoder)?;
+        let world_rate = u16::decode(decoder)?;
+        let town_rate = u8::decode(decoder)?;
+        let mut item_rate = [0u8; (MAX_SELL_TYPE as usize)];
+        for value in &mut item_rate {
+            *value = u8::decode(decoder)?;
+        }
+        let flags = u32::decode(decoder)?;
+        let world_time = u16::decode(decoder)?;
+        let team_number = u16::decode(decoder)?;
+        Ok(Self {
+            object_index,
+            hp,
+            mp,
+            xp,
+            penalize_xp,
+            craft_rate,
+            update_time,
+            world_rate,
+            town_rate,
+            item_rate,
+            flags,
+            world_time,
+            team_number,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_change_skin.rs b/packet-service/src/packets/srv_change_skin.rs
new file mode 100644
index 0000000..fca5e34
--- /dev/null
+++ b/packet-service/src/packets/srv_change_skin.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPositionRide {
+    Body = 0,
+    Engine = 1,
+    Leg = 2,
+    Ability = 3,
+    Arm = 4,
+}
+
+impl Encode for EquippedPositionRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPositionRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPositionRide::Body),
+            1 => Ok(EquippedPositionRide::Engine),
+            2 => Ok(EquippedPositionRide::Leg),
+            3 => Ok(EquippedPositionRide::Ability),
+            4 => Ok(EquippedPositionRide::Arm),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPositionRide: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvChangeSkin {
+    pub(crate) char_id: u16,
+    pub(crate) slot: EquippedPositionRide,
+    pub(crate) item_id: u32,
+}
+
+impl PacketPayload for SrvChangeSkin {}
+
+impl Encode for SrvChangeSkin {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.item_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChangeSkin {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let slot = EquippedPositionRide::decode(decoder)?;
+        let item_id = u32::decode(decoder)?;
+        Ok(Self { char_id, slot, item_id })
+    }
+}
diff --git a/packet-service/src/packets/srv_channel_list_reply.rs b/packet-service/src/packets/srv_channel_list_reply.rs
new file mode 100644
index 0000000..37b2dc5
--- /dev/null
+++ b/packet-service/src/packets/srv_channel_list_reply.rs
@@ -0,0 +1,71 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct ChannelInfo {
+    pub(crate) id: u8,
+    pub(crate) low_age: u8,
+    pub(crate) high_age: u8,
+    pub(crate) capacity: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl Encode for ChannelInfo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.low_age.encode(encoder)?;
+        self.high_age.encode(encoder)?;
+        self.capacity.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ChannelInfo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u8::decode(decoder)?;
+        let low_age = u8::decode(decoder)?;
+        let high_age = u8::decode(decoder)?;
+        let capacity = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            id,
+            low_age,
+            high_age,
+            capacity,
+            name,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvChannelListReply {
+    pub(crate) id: u32,
+    pub(crate) channels: Vec<ChannelInfo>,
+}
+
+impl PacketPayload for SrvChannelListReply {}
+
+impl Encode for SrvChannelListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.channels.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChannelListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u32::decode(decoder)?;
+        let channels = Vec::decode(decoder)?;
+        Ok(Self { id, channels })
+    }
+}
diff --git a/packet-service/src/packets/srv_char_list_reply.rs b/packet-service/src/packets/srv_char_list_reply.rs
new file mode 100644
index 0000000..68b17f2
--- /dev/null
+++ b/packet-service/src/packets/srv_char_list_reply.rs
@@ -0,0 +1,161 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPosition {
+    Helmet = 0,
+    Armor = 1,
+    Gauntlet = 2,
+    Boots = 3,
+    Googles = 4,
+    Backpack = 5,
+    WeaponR = 6,
+    WeaponL = 7,
+    MaxItems = 8,
+}
+
+impl Encode for EquippedPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPosition::Helmet),
+            1 => Ok(EquippedPosition::Armor),
+            2 => Ok(EquippedPosition::Gauntlet),
+            3 => Ok(EquippedPosition::Boots),
+            4 => Ok(EquippedPosition::Googles),
+            5 => Ok(EquippedPosition::Backpack),
+            6 => Ok(EquippedPosition::WeaponR),
+            7 => Ok(EquippedPosition::WeaponL),
+            8 => Ok(EquippedPosition::MaxItems),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPosition: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct CharInfo {
+    pub(crate) name: NullTerminatedString,
+    pub(crate) race: u8,
+    pub(crate) level: u16,
+    pub(crate) job: u16,
+    pub(crate) remain_secs_until_delete: u32,
+    pub(crate) platinium: u8,
+    pub(crate) face: u32,
+    pub(crate) hair: u32,
+    pub(crate) items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)],
+}
+
+impl Encode for CharInfo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.name.encode(encoder)?;
+        self.race.encode(encoder)?;
+        self.level.encode(encoder)?;
+        self.job.encode(encoder)?;
+        self.remain_secs_until_delete.encode(encoder)?;
+        self.platinium.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for CharInfo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let name = NullTerminatedString::decode(decoder)?;
+        let race = u8::decode(decoder)?;
+        let level = u16::decode(decoder)?;
+        let job = u16::decode(decoder)?;
+        let remain_secs_until_delete = u32::decode(decoder)?;
+        let platinium = u8::decode(decoder)?;
+        let face = u32::decode(decoder)?;
+        let hair = u32::decode(decoder)?;
+        let mut items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)] = core::array::from_fn(|i| EquippedItem::default());
+        for index in 0..MAX_VISIBLE_ITEMS as usize {
+            items[index] = EquippedItem::decode(decoder)?;
+        }
+        Ok(Self {
+            name,
+            race,
+            level,
+            job,
+            remain_secs_until_delete,
+            platinium,
+            face,
+            hair,
+            items,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCharListReply {
+    pub(crate) characters: Vec<CharInfo>,
+}
+
+impl PacketPayload for SrvCharListReply {}
+
+impl Encode for SrvCharListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.characters.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCharListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let characters = Vec::decode(decoder)?;
+        Ok(Self { characters })
+    }
+}
diff --git a/packet-service/src/packets/srv_char_state_change.rs b/packet-service/src/packets/srv_char_state_change.rs
new file mode 100644
index 0000000..b4a6750
--- /dev/null
+++ b/packet-service/src/packets/srv_char_state_change.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvCharStateChange {
+    pub(crate) target: u16,
+    pub(crate) flag: u32,
+}
+
+impl PacketPayload for SrvCharStateChange {}
+
+impl Encode for SrvCharStateChange {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.flag.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCharStateChange {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let flag = u32::decode(decoder)?;
+        Ok(Self { target, flag })
+    }
+}
diff --git a/packet-service/src/packets/srv_chatroom.rs b/packet-service/src/packets/srv_chatroom.rs
new file mode 100644
index 0000000..2d4b747
--- /dev/null
+++ b/packet-service/src/packets/srv_chatroom.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChatroom {}
+
+impl PacketPayload for SrvChatroom {}
+
+impl Encode for SrvChatroom {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChatroom {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_chatroom_message.rs b/packet-service/src/packets/srv_chatroom_message.rs
new file mode 100644
index 0000000..1474205
--- /dev/null
+++ b/packet-service/src/packets/srv_chatroom_message.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvChatroomMessage {
+    pub(crate) target: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvChatroomMessage {}
+
+impl Encode for SrvChatroomMessage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvChatroomMessage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { target, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_clan_chat.rs b/packet-service/src/packets/srv_clan_chat.rs
new file mode 100644
index 0000000..f175eb0
--- /dev/null
+++ b/packet-service/src/packets/srv_clan_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvClanChat {
+    pub(crate) sender: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvClanChat {}
+
+impl Encode for SrvClanChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sender.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvClanChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sender = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { sender, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_clan_command.rs b/packet-service/src/packets/srv_clan_command.rs
new file mode 100644
index 0000000..39d3c47
--- /dev/null
+++ b/packet-service/src/packets/srv_clan_command.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvClanCommand {}
+
+impl PacketPayload for SrvClanCommand {}
+
+impl Encode for SrvClanCommand {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvClanCommand {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_clan_icon_reply.rs b/packet-service/src/packets/srv_clan_icon_reply.rs
new file mode 100644
index 0000000..ffc7d14
--- /dev/null
+++ b/packet-service/src/packets/srv_clan_icon_reply.rs
@@ -0,0 +1,63 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum IconError {
+    TooManyUpdates = 0,
+    DbError = 1,
+    SpError = 2,
+}
+
+impl Encode for IconError {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for IconError {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(IconError::TooManyUpdates),
+            1 => Ok(IconError::DbError),
+            2 => Ok(IconError::SpError),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for IconError: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvClanIconReply {
+    pub(crate) id: u16,
+    pub(crate) data: Vec<u8>,
+}
+
+impl PacketPayload for SrvClanIconReply {}
+
+impl Encode for SrvClanIconReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvClanIconReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let data = Vec::decode(decoder)?;
+        Ok(Self { id, data })
+    }
+}
diff --git a/packet-service/src/packets/srv_clan_icon_timestamp.rs b/packet-service/src/packets/srv_clan_icon_timestamp.rs
new file mode 100644
index 0000000..d837cb7
--- /dev/null
+++ b/packet-service/src/packets/srv_clan_icon_timestamp.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvClanIconTimestamp {
+    pub(crate) year: u16,
+    pub(crate) month: u8,
+    pub(crate) day: u8,
+    pub(crate) hour: u8,
+    pub(crate) min: u8,
+    pub(crate) sec: u8,
+}
+
+impl PacketPayload for SrvClanIconTimestamp {}
+
+impl Encode for SrvClanIconTimestamp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.year.encode(encoder)?;
+        self.month.encode(encoder)?;
+        self.day.encode(encoder)?;
+        self.hour.encode(encoder)?;
+        self.min.encode(encoder)?;
+        self.sec.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvClanIconTimestamp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let year = u16::decode(decoder)?;
+        let month = u8::decode(decoder)?;
+        let day = u8::decode(decoder)?;
+        let hour = u8::decode(decoder)?;
+        let min = u8::decode(decoder)?;
+        let sec = u8::decode(decoder)?;
+        Ok(Self {
+            year,
+            month,
+            day,
+            hour,
+            min,
+            sec,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_clear_status.rs b/packet-service/src/packets/srv_clear_status.rs
new file mode 100644
index 0000000..963d0fe
--- /dev/null
+++ b/packet-service/src/packets/srv_clear_status.rs
@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvClearStatus {
+    pub(crate) target: u16,
+    pub(crate) status: u32,
+    pub(crate) hp: i16,
+    pub(crate) mp: i16,
+}
+
+impl PacketPayload for SrvClearStatus {}
+
+impl Encode for SrvClearStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.status.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.mp.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvClearStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let status = u32::decode(decoder)?;
+        let hp = i16::decode(decoder)?;
+        let mp = i16::decode(decoder)?;
+        Ok(Self { target, status, hp, mp })
+    }
+}
diff --git a/packet-service/src/packets/srv_craft_enhance_reply.rs b/packet-service/src/packets/srv_craft_enhance_reply.rs
new file mode 100644
index 0000000..b733ec0
--- /dev/null
+++ b/packet-service/src/packets/srv_craft_enhance_reply.rs
@@ -0,0 +1,169 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum CraftEnhancementResult {
+    GemSuccess = 0,
+    GemNoSocket = 1,
+    GemSocketFull = 2,
+    DisassembleGemSuccess = 3,
+    DisassembleGemDegraded = 4,
+    DisassembleGemLost = 5,
+    DisassembleSuccess = 6,
+    UpgradeSuccess = 16,
+    UpgradeFail = 17,
+    UpgradeInvalidMaterials = 18,
+}
+
+impl Encode for CraftEnhancementResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for CraftEnhancementResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(CraftEnhancementResult::GemSuccess),
+            1 => Ok(CraftEnhancementResult::GemNoSocket),
+            2 => Ok(CraftEnhancementResult::GemSocketFull),
+            3 => Ok(CraftEnhancementResult::DisassembleGemSuccess),
+            4 => Ok(CraftEnhancementResult::DisassembleGemDegraded),
+            5 => Ok(CraftEnhancementResult::DisassembleGemLost),
+            6 => Ok(CraftEnhancementResult::DisassembleSuccess),
+            16 => Ok(CraftEnhancementResult::UpgradeSuccess),
+            17 => Ok(CraftEnhancementResult::UpgradeFail),
+            18 => Ok(CraftEnhancementResult::UpgradeInvalidMaterials),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for CraftEnhancementResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCraftEnhanceReply {
+    pub(crate) result: CraftEnhancementResult,
+    pub(crate) items: Vec<Item>,
+}
+
+impl PacketPayload for SrvCraftEnhanceReply {}
+
+impl Encode for SrvCraftEnhanceReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCraftEnhanceReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = CraftEnhancementResult::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { result, items })
+    }
+}
diff --git a/packet-service/src/packets/srv_craft_reply.rs b/packet-service/src/packets/srv_craft_reply.rs
new file mode 100644
index 0000000..ec182c5
--- /dev/null
+++ b/packet-service/src/packets/srv_craft_reply.rs
@@ -0,0 +1,177 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum CraftResult {
+    Successs = 0,
+    Fail = 1,
+    InvalidCondition = 2,
+    MissingItem = 3,
+    InvalidItem = 4,
+    InvalidSkillLevel = 5,
+}
+
+impl Encode for CraftResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for CraftResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(CraftResult::Successs),
+            1 => Ok(CraftResult::Fail),
+            2 => Ok(CraftResult::InvalidCondition),
+            3 => Ok(CraftResult::MissingItem),
+            4 => Ok(CraftResult::InvalidItem),
+            5 => Ok(CraftResult::InvalidSkillLevel),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for CraftResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCraftReply {
+    pub(crate) result: CraftResult,
+    pub(crate) step_or_index: i16,
+    pub(crate) progress: [i16; 4],
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for SrvCraftReply {}
+
+impl Encode for SrvCraftReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.step_or_index.encode(encoder)?;
+        for value in &self.progress {
+            value.encode(encoder)?;
+        }
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCraftReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = CraftResult::decode(decoder)?;
+        let step_or_index = i16::decode(decoder)?;
+        let mut progress = [0i16; 4];
+        for value in &mut progress {
+            *value = i16::decode(decoder)?;
+        }
+        let item = Item::decode(decoder)?;
+        Ok(Self {
+            result,
+            step_or_index,
+            progress,
+            item,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_craft_status.rs b/packet-service/src/packets/srv_craft_status.rs
new file mode 100644
index 0000000..9931af4
--- /dev/null
+++ b/packet-service/src/packets/srv_craft_status.rs
@@ -0,0 +1,80 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum CraftStatus {
+    CraftStart = 0,
+    CraftSuccess = 1,
+    CraftFail = 2,
+    UpgradeStart = 3,
+    UpgradeSuccess = 4,
+    UpgradeFail = 5,
+}
+
+impl Encode for CraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for CraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(CraftStatus::CraftStart),
+            1 => Ok(CraftStatus::CraftSuccess),
+            2 => Ok(CraftStatus::CraftFail),
+            3 => Ok(CraftStatus::UpgradeStart),
+            4 => Ok(CraftStatus::UpgradeSuccess),
+            5 => Ok(CraftStatus::UpgradeFail),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for CraftStatus: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCraftStatus {
+    pub(crate) target: u16,
+    pub(crate) stats: CraftStatus,
+    pub(crate) type_: i8,
+    pub(crate) id: i16,
+}
+
+impl PacketPayload for SrvCraftStatus {}
+
+impl Encode for SrvCraftStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.stats.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCraftStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let stats = CraftStatus::decode(decoder)?;
+        let type_ = i8::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        Ok(Self {
+            target,
+            stats,
+            type_,
+            id,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_create_char_reply.rs b/packet-service/src/packets/srv_create_char_reply.rs
new file mode 100644
index 0000000..3c2d652
--- /dev/null
+++ b/packet-service/src/packets/srv_create_char_reply.rs
@@ -0,0 +1,69 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Ok = 0,
+    Failed = 1,
+    NameTaken = 2,
+    InvalidValue = 3,
+    TooManyChars = 4,
+    Blocked = 5,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Result::Ok),
+            1 => Ok(Result::Failed),
+            2 => Ok(Result::NameTaken),
+            3 => Ok(Result::InvalidValue),
+            4 => Ok(Result::TooManyChars),
+            5 => Ok(Result::Blocked),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvCreateCharReply {
+    pub(crate) result: Result,
+    pub(crate) platininum: u8,
+}
+
+impl PacketPayload for SrvCreateCharReply {}
+
+impl Encode for SrvCreateCharReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.platininum.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvCreateCharReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let platininum = u8::decode(decoder)?;
+        Ok(Self { result, platininum })
+    }
+}
diff --git a/packet-service/src/packets/srv_damage.rs b/packet-service/src/packets/srv_damage.rs
new file mode 100644
index 0000000..775c238
--- /dev/null
+++ b/packet-service/src/packets/srv_damage.rs
@@ -0,0 +1,157 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvDamage {
+    pub(crate) attacker_id: u16,
+    pub(crate) defender_id: u16,
+    pub(crate) damage: u32,
+    pub(crate) action: u32,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) item: Item,
+    pub(crate) id: u16,
+    pub(crate) owner_id: u16,
+}
+
+impl PacketPayload for SrvDamage {}
+
+impl Encode for SrvDamage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.attacker_id.encode(encoder)?;
+        self.defender_id.encode(encoder)?;
+        self.damage.encode(encoder)?;
+        self.action.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.owner_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvDamage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let attacker_id = u16::decode(decoder)?;
+        let defender_id = u16::decode(decoder)?;
+        let damage = u32::decode(decoder)?;
+        let action = u32::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let owner_id = u16::decode(decoder)?;
+        Ok(Self {
+            attacker_id,
+            defender_id,
+            damage,
+            action,
+            x,
+            y,
+            item,
+            id,
+            owner_id,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_delete_char_reply.rs b/packet-service/src/packets/srv_delete_char_reply.rs
new file mode 100644
index 0000000..b10bf34
--- /dev/null
+++ b/packet-service/src/packets/srv_delete_char_reply.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvDeleteCharReply {
+    pub(crate) remaining_time: u32,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvDeleteCharReply {}
+
+impl Encode for SrvDeleteCharReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.remaining_time.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvDeleteCharReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let remaining_time = u32::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { remaining_time, name })
+    }
+}
diff --git a/packet-service/src/packets/srv_drop_item.rs b/packet-service/src/packets/srv_drop_item.rs
new file mode 100644
index 0000000..a9983a0
--- /dev/null
+++ b/packet-service/src/packets/srv_drop_item.rs
@@ -0,0 +1,145 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvDropItem {
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) item: Item,
+    pub(crate) id: u16,
+    pub(crate) owner_id: u16,
+    pub(crate) time_to_live: u16,
+}
+
+impl PacketPayload for SrvDropItem {}
+
+impl Encode for SrvDropItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.owner_id.encode(encoder)?;
+        self.time_to_live.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvDropItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let owner_id = u16::decode(decoder)?;
+        let time_to_live = u16::decode(decoder)?;
+        Ok(Self {
+            x,
+            y,
+            item,
+            id,
+            owner_id,
+            time_to_live,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_equip_item.rs b/packet-service/src/packets/srv_equip_item.rs
new file mode 100644
index 0000000..bc10787
--- /dev/null
+++ b/packet-service/src/packets/srv_equip_item.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvEquipItem {
+    pub(crate) id: u16,
+    pub(crate) slot: i16,
+    pub(crate) item: EquippedItem,
+}
+
+impl PacketPayload for SrvEquipItem {}
+
+impl Encode for SrvEquipItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvEquipItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let slot = i16::decode(decoder)?;
+        let item = EquippedItem::decode(decoder)?;
+        Ok(Self { id, slot, item })
+    }
+}
diff --git a/packet-service/src/packets/srv_equip_item_ride.rs b/packet-service/src/packets/srv_equip_item_ride.rs
new file mode 100644
index 0000000..8ab697d
--- /dev/null
+++ b/packet-service/src/packets/srv_equip_item_ride.rs
@@ -0,0 +1,111 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum EquippedPositionRide {
+    Body = 0,
+    Engine = 1,
+    Leg = 2,
+    Ability = 3,
+    Arm = 4,
+}
+
+impl Encode for EquippedPositionRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for EquippedPositionRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            0 => Ok(EquippedPositionRide::Body),
+            1 => Ok(EquippedPositionRide::Engine),
+            2 => Ok(EquippedPositionRide::Leg),
+            3 => Ok(EquippedPositionRide::Ability),
+            4 => Ok(EquippedPositionRide::Arm),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for EquippedPositionRide: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvEquipItemRide {
+    pub(crate) char_id: u16,
+    pub(crate) slot: EquippedPositionRide,
+    pub(crate) item: EquippedItem,
+    pub(crate) move_speed: u16,
+}
+
+impl PacketPayload for SrvEquipItemRide {}
+
+impl Encode for SrvEquipItemRide {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.move_speed.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvEquipItemRide {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let slot = EquippedPositionRide::decode(decoder)?;
+        let item = EquippedItem::decode(decoder)?;
+        let move_speed = u16::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            slot,
+            item,
+            move_speed,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_equip_projectile.rs b/packet-service/src/packets/srv_equip_projectile.rs
new file mode 100644
index 0000000..cf8f537
--- /dev/null
+++ b/packet-service/src/packets/srv_equip_projectile.rs
@@ -0,0 +1,56 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct ProjectileData {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+}
+
+impl Encode for ProjectileData {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ProjectileData {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        Ok(Self { type_, id })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvEquipProjectile {
+    pub(crate) char_id: u16,
+    pub(crate) projectile: ProjectileData,
+}
+
+impl PacketPayload for SrvEquipProjectile {}
+
+impl Encode for SrvEquipProjectile {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.projectile.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvEquipProjectile {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let projectile = ProjectileData::decode(decoder)?;
+        Ok(Self { char_id, projectile })
+    }
+}
diff --git a/packet-service/src/packets/srv_event_add.rs b/packet-service/src/packets/srv_event_add.rs
new file mode 100644
index 0000000..ba9e44d
--- /dev/null
+++ b/packet-service/src/packets/srv_event_add.rs
@@ -0,0 +1,49 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvEventAdd {
+    pub(crate) id: u16,
+    pub(crate) x: i8,
+    pub(crate) y: i8,
+    pub(crate) event_id: u16,
+    pub(crate) status: i16,
+}
+
+impl PacketPayload for SrvEventAdd {}
+
+impl Encode for SrvEventAdd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.event_id.encode(encoder)?;
+        self.status.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvEventAdd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let x = i8::decode(decoder)?;
+        let y = i8::decode(decoder)?;
+        let event_id = u16::decode(decoder)?;
+        let status = i16::decode(decoder)?;
+        Ok(Self {
+            id,
+            x,
+            y,
+            event_id,
+            status,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_event_status.rs b/packet-service/src/packets/srv_event_status.rs
new file mode 100644
index 0000000..a6b73a0
--- /dev/null
+++ b/packet-service/src/packets/srv_event_status.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvEventStatus {
+    pub(crate) object_id: u16,
+    pub(crate) status: i16,
+}
+
+impl PacketPayload for SrvEventStatus {}
+
+impl Encode for SrvEventStatus {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.object_id.encode(encoder)?;
+        self.status.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvEventStatus {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let object_id = u16::decode(decoder)?;
+        let status = i16::decode(decoder)?;
+        Ok(Self { object_id, status })
+    }
+}
diff --git a/packet-service/src/packets/srv_fairy.rs b/packet-service/src/packets/srv_fairy.rs
new file mode 100644
index 0000000..209d152
--- /dev/null
+++ b/packet-service/src/packets/srv_fairy.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvFairy {
+    pub(crate) enabled: i8,
+    pub(crate) target: u16,
+}
+
+impl PacketPayload for SrvFairy {}
+
+impl Encode for SrvFairy {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.enabled.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvFairy {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let enabled = i8::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        Ok(Self { enabled, target })
+    }
+}
diff --git a/packet-service/src/packets/srv_global_flags.rs b/packet-service/src/packets/srv_global_flags.rs
new file mode 100644
index 0000000..ba05020
--- /dev/null
+++ b/packet-service/src/packets/srv_global_flags.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvGlobalFlags {
+    pub(crate) flags: i32,
+}
+
+impl PacketPayload for SrvGlobalFlags {}
+
+impl Encode for SrvGlobalFlags {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.flags.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvGlobalFlags {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let flags = i32::decode(decoder)?;
+        Ok(Self { flags })
+    }
+}
diff --git a/packet-service/src/packets/srv_global_vars.rs b/packet-service/src/packets/srv_global_vars.rs
new file mode 100644
index 0000000..c865792
--- /dev/null
+++ b/packet-service/src/packets/srv_global_vars.rs
@@ -0,0 +1,58 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvGlobalVars {
+    pub(crate) world_product: i16,
+    pub(crate) update_time: i32,
+    pub(crate) world_rate: i16,
+    pub(crate) town_rate: u8,
+    pub(crate) item_rate: [u8; (MAX_SELL_TYPE as usize)],
+    pub(crate) flags: u32,
+}
+
+impl PacketPayload for SrvGlobalVars {}
+
+impl Encode for SrvGlobalVars {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.world_product.encode(encoder)?;
+        self.update_time.encode(encoder)?;
+        self.world_rate.encode(encoder)?;
+        self.town_rate.encode(encoder)?;
+        for value in &self.item_rate {
+            value.encode(encoder)?;
+        }
+        self.flags.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvGlobalVars {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let world_product = i16::decode(decoder)?;
+        let update_time = i32::decode(decoder)?;
+        let world_rate = i16::decode(decoder)?;
+        let town_rate = u8::decode(decoder)?;
+        let mut item_rate = [0u8; (MAX_SELL_TYPE as usize)];
+        for value in &mut item_rate {
+            *value = u8::decode(decoder)?;
+        }
+        let flags = u32::decode(decoder)?;
+        Ok(Self {
+            world_product,
+            update_time,
+            world_rate,
+            town_rate,
+            item_rate,
+            flags,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_gm_command_code.rs b/packet-service/src/packets/srv_gm_command_code.rs
new file mode 100644
index 0000000..7c60af1
--- /dev/null
+++ b/packet-service/src/packets/srv_gm_command_code.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvGmCommandCode {
+    pub(crate) target: u16,
+    pub(crate) command: NullTerminatedString,
+}
+
+impl PacketPayload for SrvGmCommandCode {}
+
+impl Encode for SrvGmCommandCode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.command.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvGmCommandCode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let command = NullTerminatedString::decode(decoder)?;
+        Ok(Self { target, command })
+    }
+}
diff --git a/packet-service/src/packets/srv_hotbar_set_icon_reply.rs b/packet-service/src/packets/srv_hotbar_set_icon_reply.rs
new file mode 100644
index 0000000..cfcee7a
--- /dev/null
+++ b/packet-service/src/packets/srv_hotbar_set_icon_reply.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvHotbarSetIconReply {}
+
+impl PacketPayload for SrvHotbarSetIconReply {}
+
+impl Encode for SrvHotbarSetIconReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvHotbarSetIconReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_hp_reply.rs b/packet-service/src/packets/srv_hp_reply.rs
new file mode 100644
index 0000000..a49bed3
--- /dev/null
+++ b/packet-service/src/packets/srv_hp_reply.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvHpReply {
+    pub(crate) id: u16,
+    pub(crate) hp: i32,
+}
+
+impl PacketPayload for SrvHpReply {}
+
+impl Encode for SrvHpReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvHpReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        Ok(Self { id, hp })
+    }
+}
diff --git a/packet-service/src/packets/srv_inventory_data.rs b/packet-service/src/packets/srv_inventory_data.rs
new file mode 100644
index 0000000..7ae6c22
--- /dev/null
+++ b/packet-service/src/packets/srv_inventory_data.rs
@@ -0,0 +1,131 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvInventoryData {
+    pub(crate) zuly: i64,
+    pub(crate) items: [Item; (MAX_ITEMS as usize)],
+}
+
+impl PacketPayload for SrvInventoryData {}
+
+impl Encode for SrvInventoryData {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.zuly.encode(encoder)?;
+        for value in &self.items {
+            value.encode(encoder)?;
+        }
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvInventoryData {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let zuly = i64::decode(decoder)?;
+        let mut items: [Item; (MAX_ITEMS as usize)] = core::array::from_fn(|i| Item::default());
+        for index in 0..MAX_ITEMS as usize {
+            items[index] = Item::decode(decoder)?;
+        }
+        Ok(Self { zuly, items })
+    }
+}
diff --git a/packet-service/src/packets/srv_join_server_reply.rs b/packet-service/src/packets/srv_join_server_reply.rs
new file mode 100644
index 0000000..61e8514
--- /dev/null
+++ b/packet-service/src/packets/srv_join_server_reply.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Ok = 0,
+    Failed = 1,
+    TimeOut = 2,
+    InvalidPassword = 3,
+    AlreadyLoggedin = 4,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Result::Ok),
+            1 => Ok(Result::Failed),
+            2 => Ok(Result::TimeOut),
+            3 => Ok(Result::InvalidPassword),
+            4 => Ok(Result::AlreadyLoggedin),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvJoinServerReply {
+    pub(crate) result: Result,
+    pub(crate) id: u32,
+    pub(crate) pay_flag: u32,
+}
+
+impl PacketPayload for SrvJoinServerReply {}
+
+impl Encode for SrvJoinServerReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.pay_flag.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvJoinServerReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let id = u32::decode(decoder)?;
+        let pay_flag = u32::decode(decoder)?;
+        Ok(Self { result, id, pay_flag })
+    }
+}
diff --git a/packet-service/src/packets/srv_levelup.rs b/packet-service/src/packets/srv_levelup.rs
new file mode 100644
index 0000000..edafdb7
--- /dev/null
+++ b/packet-service/src/packets/srv_levelup.rs
@@ -0,0 +1,49 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvLevelup {
+    pub(crate) id: u16,
+    pub(crate) level: i16,
+    pub(crate) exp: i64,
+    pub(crate) stat_points: i16,
+    pub(crate) skill_points: i16,
+}
+
+impl PacketPayload for SrvLevelup {}
+
+impl Encode for SrvLevelup {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.level.encode(encoder)?;
+        self.exp.encode(encoder)?;
+        self.stat_points.encode(encoder)?;
+        self.skill_points.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvLevelup {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let level = i16::decode(decoder)?;
+        let exp = i64::decode(decoder)?;
+        let stat_points = i16::decode(decoder)?;
+        let skill_points = i16::decode(decoder)?;
+        Ok(Self {
+            id,
+            level,
+            exp,
+            stat_points,
+            skill_points,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_login_reply.rs b/packet-service/src/packets/srv_login_reply.rs
new file mode 100644
index 0000000..60a14bc
--- /dev/null
+++ b/packet-service/src/packets/srv_login_reply.rs
@@ -0,0 +1,117 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Ok = 0,
+    Failed = 1,
+    UnknownAccount = 2,
+    InvalidPassword = 3,
+    AlreadyLoggedin = 4,
+    RefusedAccount = 5,
+    NeedCharge = 6,
+    NoRightToConnect = 7,
+    TooManyUsers = 8,
+    NoName = 9,
+    InvalidVersion = 10,
+    OutsideRegion = 11,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Result::Ok),
+            1 => Ok(Result::Failed),
+            2 => Ok(Result::UnknownAccount),
+            3 => Ok(Result::InvalidPassword),
+            4 => Ok(Result::AlreadyLoggedin),
+            5 => Ok(Result::RefusedAccount),
+            6 => Ok(Result::NeedCharge),
+            7 => Ok(Result::NoRightToConnect),
+            8 => Ok(Result::TooManyUsers),
+            9 => Ok(Result::NoName),
+            10 => Ok(Result::InvalidVersion),
+            11 => Ok(Result::OutsideRegion),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ServerInfo {
+    pub(crate) test: u8,
+    pub(crate) name: NullTerminatedString,
+    pub(crate) id: u32,
+}
+
+impl Encode for ServerInfo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.test.encode(encoder)?;
+        self.name.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ServerInfo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let test = u8::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        let id = u32::decode(decoder)?;
+        Ok(Self { test, name, id })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvLoginReply {
+    pub(crate) result: Result,
+    pub(crate) right: u16,
+    pub(crate) type_: u16,
+    pub(crate) servers_info: Vec<ServerInfo>,
+}
+
+impl PacketPayload for SrvLoginReply {}
+
+impl Encode for SrvLoginReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.right.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.servers_info.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvLoginReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let right = u16::decode(decoder)?;
+        let type_ = u16::decode(decoder)?;
+        let servers_info = Vec::decode(decoder)?;
+        Ok(Self {
+            result,
+            right,
+            type_,
+            servers_info,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_logout_reply.rs b/packet-service/src/packets/srv_logout_reply.rs
new file mode 100644
index 0000000..e48516d
--- /dev/null
+++ b/packet-service/src/packets/srv_logout_reply.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvLogoutReply {
+    pub(crate) wait_time: u16,
+}
+
+impl PacketPayload for SrvLogoutReply {}
+
+impl Encode for SrvLogoutReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.wait_time.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvLogoutReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let wait_time = u16::decode(decoder)?;
+        Ok(Self { wait_time })
+    }
+}
diff --git a/packet-service/src/packets/srv_memo.rs b/packet-service/src/packets/srv_memo.rs
new file mode 100644
index 0000000..f57d1f4
--- /dev/null
+++ b/packet-service/src/packets/srv_memo.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvMemo {}
+
+impl PacketPayload for SrvMemo {}
+
+impl Encode for SrvMemo {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMemo {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_messenger.rs b/packet-service/src/packets/srv_messenger.rs
new file mode 100644
index 0000000..6ebc8e1
--- /dev/null
+++ b/packet-service/src/packets/srv_messenger.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvMessenger {}
+
+impl PacketPayload for SrvMessenger {}
+
+impl Encode for SrvMessenger {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMessenger {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_messenger_chat.rs b/packet-service/src/packets/srv_messenger_chat.rs
new file mode 100644
index 0000000..ac2ebea
--- /dev/null
+++ b/packet-service/src/packets/srv_messenger_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvMessengerChat {
+    pub(crate) tag: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvMessengerChat {}
+
+impl Encode for SrvMessengerChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.tag.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMessengerChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let tag = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { tag, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_mob_char.rs b/packet-service/src/packets/srv_mob_char.rs
new file mode 100644
index 0000000..1b6c93a
--- /dev/null
+++ b/packet-service/src/packets/srv_mob_char.rs
@@ -0,0 +1,81 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvMobChar {
+    pub(crate) id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) dest_x: f32,
+    pub(crate) dest_y: f32,
+    pub(crate) command: u16,
+    pub(crate) target_id: u16,
+    pub(crate) move_mode: u8,
+    pub(crate) hp: i32,
+    pub(crate) team_id: i32,
+    pub(crate) status_flag: u32,
+    pub(crate) npc_id: u16,
+    pub(crate) quest_id: u16,
+}
+
+impl PacketPayload for SrvMobChar {}
+
+impl Encode for SrvMobChar {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.dest_x.encode(encoder)?;
+        self.dest_y.encode(encoder)?;
+        self.command.encode(encoder)?;
+        self.target_id.encode(encoder)?;
+        self.move_mode.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.team_id.encode(encoder)?;
+        self.status_flag.encode(encoder)?;
+        self.npc_id.encode(encoder)?;
+        self.quest_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMobChar {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let dest_x = f32::decode(decoder)?;
+        let dest_y = f32::decode(decoder)?;
+        let command = u16::decode(decoder)?;
+        let target_id = u16::decode(decoder)?;
+        let move_mode = u8::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        let team_id = i32::decode(decoder)?;
+        let status_flag = u32::decode(decoder)?;
+        let npc_id = u16::decode(decoder)?;
+        let quest_id = u16::decode(decoder)?;
+        Ok(Self {
+            id,
+            x,
+            y,
+            dest_x,
+            dest_y,
+            command,
+            target_id,
+            move_mode,
+            hp,
+            team_id,
+            status_flag,
+            npc_id,
+            quest_id,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_mouse_cmd.rs b/packet-service/src/packets/srv_mouse_cmd.rs
new file mode 100644
index 0000000..5094954
--- /dev/null
+++ b/packet-service/src/packets/srv_mouse_cmd.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvMouseCmd {
+    pub(crate) id: u16,
+    pub(crate) target_id: u16,
+    pub(crate) distance: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+}
+
+impl PacketPayload for SrvMouseCmd {}
+
+impl Encode for SrvMouseCmd {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.target_id.encode(encoder)?;
+        self.distance.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMouseCmd {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let target_id = u16::decode(decoder)?;
+        let distance = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        Ok(Self {
+            id,
+            target_id,
+            distance,
+            x,
+            y,
+            z,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_move.rs b/packet-service/src/packets/srv_move.rs
new file mode 100644
index 0000000..6a1f4d1
--- /dev/null
+++ b/packet-service/src/packets/srv_move.rs
@@ -0,0 +1,88 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MoveMode {
+    Walk = 0,
+    Run = 1,
+    Drive = 2,
+    Rideon = 3,
+}
+
+impl Encode for MoveMode {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MoveMode {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MoveMode::Walk),
+            1 => Ok(MoveMode::Run),
+            2 => Ok(MoveMode::Drive),
+            3 => Ok(MoveMode::Rideon),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MoveMode: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvMove {
+    pub(crate) id: u16,
+    pub(crate) target_id: u16,
+    pub(crate) distance: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: u16,
+    pub(crate) move_mode: MoveMode,
+}
+
+impl PacketPayload for SrvMove {}
+
+impl Encode for SrvMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.target_id.encode(encoder)?;
+        self.distance.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        self.move_mode.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let target_id = u16::decode(decoder)?;
+        let distance = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = u16::decode(decoder)?;
+        let move_mode = MoveMode::decode(decoder)?;
+        Ok(Self {
+            id,
+            target_id,
+            distance,
+            x,
+            y,
+            z,
+            move_mode,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_normal_chat.rs b/packet-service/src/packets/srv_normal_chat.rs
new file mode 100644
index 0000000..a0af00a
--- /dev/null
+++ b/packet-service/src/packets/srv_normal_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvNormalChat {
+    pub(crate) char_id: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvNormalChat {}
+
+impl Encode for SrvNormalChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvNormalChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { char_id, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_npc_char.rs b/packet-service/src/packets/srv_npc_char.rs
new file mode 100644
index 0000000..d87c1c2
--- /dev/null
+++ b/packet-service/src/packets/srv_npc_char.rs
@@ -0,0 +1,89 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvNpcChar {
+    pub(crate) id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) dest_x: f32,
+    pub(crate) dest_y: f32,
+    pub(crate) command: u16,
+    pub(crate) target_id: u16,
+    pub(crate) move_mode: u8,
+    pub(crate) hp: i32,
+    pub(crate) team_id: i32,
+    pub(crate) status_flag: u32,
+    pub(crate) npc_id: u16,
+    pub(crate) quest_id: u16,
+    pub(crate) angle: f32,
+    pub(crate) event_status: u16,
+}
+
+impl PacketPayload for SrvNpcChar {}
+
+impl Encode for SrvNpcChar {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.dest_x.encode(encoder)?;
+        self.dest_y.encode(encoder)?;
+        self.command.encode(encoder)?;
+        self.target_id.encode(encoder)?;
+        self.move_mode.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.team_id.encode(encoder)?;
+        self.status_flag.encode(encoder)?;
+        self.npc_id.encode(encoder)?;
+        self.quest_id.encode(encoder)?;
+        self.angle.encode(encoder)?;
+        self.event_status.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvNpcChar {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let dest_x = f32::decode(decoder)?;
+        let dest_y = f32::decode(decoder)?;
+        let command = u16::decode(decoder)?;
+        let target_id = u16::decode(decoder)?;
+        let move_mode = u8::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        let team_id = i32::decode(decoder)?;
+        let status_flag = u32::decode(decoder)?;
+        let npc_id = u16::decode(decoder)?;
+        let quest_id = u16::decode(decoder)?;
+        let angle = f32::decode(decoder)?;
+        let event_status = u16::decode(decoder)?;
+        Ok(Self {
+            id,
+            x,
+            y,
+            dest_x,
+            dest_y,
+            command,
+            target_id,
+            move_mode,
+            hp,
+            team_id,
+            status_flag,
+            npc_id,
+            quest_id,
+            angle,
+            event_status,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_npc_event.rs b/packet-service/src/packets/srv_npc_event.rs
new file mode 100644
index 0000000..36d25aa
--- /dev/null
+++ b/packet-service/src/packets/srv_npc_event.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvNpcEvent {
+    pub(crate) id: i16,
+}
+
+impl PacketPayload for SrvNpcEvent {}
+
+impl Encode for SrvNpcEvent {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvNpcEvent {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = i16::decode(decoder)?;
+        Ok(Self { id })
+    }
+}
diff --git a/packet-service/src/packets/srv_npc_show.rs b/packet-service/src/packets/srv_npc_show.rs
new file mode 100644
index 0000000..df57af5
--- /dev/null
+++ b/packet-service/src/packets/srv_npc_show.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvNpcShow {
+    pub(crate) id: u16,
+    pub(crate) show: u8,
+}
+
+impl PacketPayload for SrvNpcShow {}
+
+impl Encode for SrvNpcShow {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.show.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvNpcShow {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let show = u8::decode(decoder)?;
+        Ok(Self { id, show })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_chat.rs b/packet-service/src/packets/srv_party_chat.rs
new file mode 100644
index 0000000..2622d63
--- /dev/null
+++ b/packet-service/src/packets/srv_party_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvPartyChat {
+    pub(crate) char_id: u16,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvPartyChat {}
+
+impl Encode for SrvPartyChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { char_id, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_item.rs b/packet-service/src/packets/srv_party_item.rs
new file mode 100644
index 0000000..6c70c80
--- /dev/null
+++ b/packet-service/src/packets/srv_party_item.rs
@@ -0,0 +1,126 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyItem {
+    pub(crate) target: u16,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for SrvPartyItem {}
+
+impl Encode for SrvPartyItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { target, item })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_levelexp.rs b/packet-service/src/packets/srv_party_levelexp.rs
new file mode 100644
index 0000000..0914e3d
--- /dev/null
+++ b/packet-service/src/packets/srv_party_levelexp.rs
@@ -0,0 +1,56 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct PartyExpData {
+    pub(crate) exp: u32,
+    pub(crate) level_up: u8,
+}
+
+impl Encode for PartyExpData {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.exp.encode(encoder)?;
+        self.level_up.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for PartyExpData {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let exp = u32::decode(decoder)?;
+        let level_up = u8::decode(decoder)?;
+        Ok(Self { exp, level_up })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyLevelexp {
+    pub(crate) level: u8,
+    pub(crate) exp_data: PartyExpData,
+}
+
+impl PacketPayload for SrvPartyLevelexp {}
+
+impl Encode for SrvPartyLevelexp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.level.encode(encoder)?;
+        self.exp_data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyLevelexp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let level = u8::decode(decoder)?;
+        let exp_data = PartyExpData::decode(decoder)?;
+        Ok(Self { level, exp_data })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_member.rs b/packet-service/src/packets/srv_party_member.rs
new file mode 100644
index 0000000..8602272
--- /dev/null
+++ b/packet-service/src/packets/srv_party_member.rs
@@ -0,0 +1,148 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyRule {
+    ExpPerPlayer = 1,
+    ItemInOrder = 128,
+}
+
+impl Encode for PartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(PartyRule::ExpPerPlayer),
+            128 => Ok(PartyRule::ItemInOrder),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyRule: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[repr(i8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyMemberAction {
+    Remove = -1,
+    Add = 1,
+}
+
+impl Encode for PartyMemberAction {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyMemberAction {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = i8::decode(decoder)?;
+        match value {
+            -1 => Ok(PartyMemberAction::Remove),
+            1 => Ok(PartyMemberAction::Add),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyMemberAction: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct PartyMember {
+    pub(crate) tag: u32,
+    pub(crate) id: u16,
+    pub(crate) max_hp: u32,
+    pub(crate) hp: u32,
+    pub(crate) status: u32,
+    pub(crate) con: u16,
+    pub(crate) hp_recovery: u16,
+    pub(crate) mp_recovery: u16,
+    pub(crate) stamina: i16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl Encode for PartyMember {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.tag.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.max_hp.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.status.encode(encoder)?;
+        self.con.encode(encoder)?;
+        self.hp_recovery.encode(encoder)?;
+        self.mp_recovery.encode(encoder)?;
+        self.stamina.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for PartyMember {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let tag = u32::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let max_hp = u32::decode(decoder)?;
+        let hp = u32::decode(decoder)?;
+        let status = u32::decode(decoder)?;
+        let con = u16::decode(decoder)?;
+        let hp_recovery = u16::decode(decoder)?;
+        let mp_recovery = u16::decode(decoder)?;
+        let stamina = i16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            tag,
+            id,
+            max_hp,
+            hp,
+            status,
+            con,
+            hp_recovery,
+            mp_recovery,
+            stamina,
+            name,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyMember {
+    pub(crate) rule: PartyRule,
+    pub(crate) action: PartyMemberAction,
+    pub(crate) member: PartyMember,
+}
+
+impl PacketPayload for SrvPartyMember {}
+
+impl Encode for SrvPartyMember {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.rule.encode(encoder)?;
+        self.action.encode(encoder)?;
+        self.member.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyMember {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let rule = PartyRule::decode(decoder)?;
+        let action = PartyMemberAction::decode(decoder)?;
+        let member = PartyMember::decode(decoder)?;
+        Ok(Self { rule, action, member })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_member_update.rs b/packet-service/src/packets/srv_party_member_update.rs
new file mode 100644
index 0000000..bbbdd4d
--- /dev/null
+++ b/packet-service/src/packets/srv_party_member_update.rs
@@ -0,0 +1,88 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct PartyMember {
+    pub(crate) tag: u32,
+    pub(crate) id: u16,
+    pub(crate) max_hp: u32,
+    pub(crate) hp: u32,
+    pub(crate) status: u32,
+    pub(crate) con: u16,
+    pub(crate) hp_recovery: u16,
+    pub(crate) mp_recovery: u16,
+    pub(crate) stamina: i16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl Encode for PartyMember {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.tag.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.max_hp.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.status.encode(encoder)?;
+        self.con.encode(encoder)?;
+        self.hp_recovery.encode(encoder)?;
+        self.mp_recovery.encode(encoder)?;
+        self.stamina.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for PartyMember {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let tag = u32::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let max_hp = u32::decode(decoder)?;
+        let hp = u32::decode(decoder)?;
+        let status = u32::decode(decoder)?;
+        let con = u16::decode(decoder)?;
+        let hp_recovery = u16::decode(decoder)?;
+        let mp_recovery = u16::decode(decoder)?;
+        let stamina = i16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            tag,
+            id,
+            max_hp,
+            hp,
+            status,
+            con,
+            hp_recovery,
+            mp_recovery,
+            stamina,
+            name,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyMemberUpdate {
+    pub(crate) member: PartyMember,
+}
+
+impl PacketPayload for SrvPartyMemberUpdate {}
+
+impl Encode for SrvPartyMemberUpdate {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.member.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyMemberUpdate {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let member = PartyMember::decode(decoder)?;
+        Ok(Self { member })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_reply.rs b/packet-service/src/packets/srv_party_reply.rs
new file mode 100644
index 0000000..3eb0450
--- /dev/null
+++ b/packet-service/src/packets/srv_party_reply.rs
@@ -0,0 +1,85 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReplyType {
+    NotFound = 0,
+    Busy = 1,
+    AcceptCreate = 2,
+    AcceptJoin = 3,
+    RejectJoin = 4,
+    Destroy = 5,
+    Full = 6,
+    InvalidLevel = 7,
+    ChangeOwner = 8,
+    ChangeOwnerAndLeave = 9,
+    NoPremium = 10,
+    Bad = 128,
+    Leave = 129,
+    Rejoin = 130,
+}
+
+impl Encode for PartyReplyType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReplyType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReplyType::NotFound),
+            1 => Ok(PartyReplyType::Busy),
+            2 => Ok(PartyReplyType::AcceptCreate),
+            3 => Ok(PartyReplyType::AcceptJoin),
+            4 => Ok(PartyReplyType::RejectJoin),
+            5 => Ok(PartyReplyType::Destroy),
+            6 => Ok(PartyReplyType::Full),
+            7 => Ok(PartyReplyType::InvalidLevel),
+            8 => Ok(PartyReplyType::ChangeOwner),
+            9 => Ok(PartyReplyType::ChangeOwnerAndLeave),
+            10 => Ok(PartyReplyType::NoPremium),
+            128 => Ok(PartyReplyType::Bad),
+            129 => Ok(PartyReplyType::Leave),
+            130 => Ok(PartyReplyType::Rejoin),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReplyType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyReply {
+    pub(crate) type_: PartyReplyType,
+    pub(crate) source: u32,
+}
+
+impl PacketPayload for SrvPartyReply {}
+
+impl Encode for SrvPartyReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.source.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReplyType::decode(decoder)?;
+        let source = u32::decode(decoder)?;
+        Ok(Self { type_, source })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_req.rs b/packet-service/src/packets/srv_party_req.rs
new file mode 100644
index 0000000..1284db5
--- /dev/null
+++ b/packet-service/src/packets/srv_party_req.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyReqType {
+    Create = 0,
+    Join = 1,
+    Leave = 2,
+    ChangeOwner = 3,
+    Ban = 129,
+}
+
+impl Encode for PartyReqType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyReqType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(PartyReqType::Create),
+            1 => Ok(PartyReqType::Join),
+            2 => Ok(PartyReqType::Leave),
+            3 => Ok(PartyReqType::ChangeOwner),
+            129 => Ok(PartyReqType::Ban),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyReqType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyReq {
+    pub(crate) type_: PartyReqType,
+    pub(crate) source: u32,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvPartyReq {}
+
+impl Encode for SrvPartyReq {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.source.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyReq {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = PartyReqType::decode(decoder)?;
+        let source = u32::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { type_, source, name })
+    }
+}
diff --git a/packet-service/src/packets/srv_party_rule.rs b/packet-service/src/packets/srv_party_rule.rs
new file mode 100644
index 0000000..6278747
--- /dev/null
+++ b/packet-service/src/packets/srv_party_rule.rs
@@ -0,0 +1,58 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum PartyRule {
+    ExpPerPlayer = 1,
+    ItemInOrder = 128,
+}
+
+impl Encode for PartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for PartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(PartyRule::ExpPerPlayer),
+            128 => Ok(PartyRule::ItemInOrder),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for PartyRule: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPartyRule {
+    pub(crate) rule: PartyRule,
+}
+
+impl PacketPayload for SrvPartyRule {}
+
+impl Encode for SrvPartyRule {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.rule.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPartyRule {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let rule = PartyRule::decode(decoder)?;
+        Ok(Self { rule })
+    }
+}
diff --git a/packet-service/src/packets/srv_pickup_item_reply.rs b/packet-service/src/packets/srv_pickup_item_reply.rs
new file mode 100644
index 0000000..39fb453
--- /dev/null
+++ b/packet-service/src/packets/srv_pickup_item_reply.rs
@@ -0,0 +1,163 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Ok = 0,
+    NoItem = 1,
+    NotOwner = 2,
+    InventoryFull = 3,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Result::Ok),
+            1 => Ok(Result::NoItem),
+            2 => Ok(Result::NotOwner),
+            3 => Ok(Result::InventoryFull),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPickupItemReply {
+    pub(crate) id: u16,
+    pub(crate) result: Result,
+    pub(crate) slot: u16,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for SrvPickupItemReply {}
+
+impl Encode for SrvPickupItemReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.result.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPickupItemReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let result = Result::decode(decoder)?;
+        let slot = u16::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { id, result, slot, item })
+    }
+}
diff --git a/packet-service/src/packets/srv_player_char.rs b/packet-service/src/packets/srv_player_char.rs
new file mode 100644
index 0000000..fd936df
--- /dev/null
+++ b/packet-service/src/packets/srv_player_char.rs
@@ -0,0 +1,208 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvPlayerChar {
+    pub(crate) id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) dest_x: f32,
+    pub(crate) dest_y: f32,
+    pub(crate) command: u16,
+    pub(crate) target_id: u16,
+    pub(crate) move_mode: u8,
+    pub(crate) hp: i32,
+    pub(crate) team_id: i32,
+    pub(crate) status_flag: u32,
+    pub(crate) race: u8,
+    pub(crate) run_speed: i16,
+    pub(crate) atk_speed: i16,
+    pub(crate) weight_rate: u8,
+    pub(crate) face: u32,
+    pub(crate) hair: u32,
+    pub(crate) inventory: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)],
+    pub(crate) bullets: [Header; (BulletType::MaxBulletTypes as usize)],
+    pub(crate) job: i16,
+    pub(crate) level: u8,
+    pub(crate) riding_items: [EquippedItem; (RidingItem::MaxRidingItems as usize)],
+    pub(crate) z: i16,
+    pub(crate) sub_flag: u32,
+    pub(crate) name: NullTerminatedString,
+    pub(crate) other_name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvPlayerChar {}
+
+impl Encode for SrvPlayerChar {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.dest_x.encode(encoder)?;
+        self.dest_y.encode(encoder)?;
+        self.command.encode(encoder)?;
+        self.target_id.encode(encoder)?;
+        self.move_mode.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.team_id.encode(encoder)?;
+        self.status_flag.encode(encoder)?;
+        self.race.encode(encoder)?;
+        self.run_speed.encode(encoder)?;
+        self.atk_speed.encode(encoder)?;
+        self.weight_rate.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        for value in &self.inventory {
+            value.encode(encoder)?;
+        }
+        for value in &self.bullets {
+            value.encode(encoder)?;
+        }
+        self.job.encode(encoder)?;
+        self.level.encode(encoder)?;
+        for value in &self.riding_items {
+            value.encode(encoder)?;
+        }
+        self.z.encode(encoder)?;
+        self.sub_flag.encode(encoder)?;
+        self.name.encode(encoder)?;
+        self.other_name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvPlayerChar {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let dest_x = f32::decode(decoder)?;
+        let dest_y = f32::decode(decoder)?;
+        let command = u16::decode(decoder)?;
+        let target_id = u16::decode(decoder)?;
+        let move_mode = u8::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        let team_id = i32::decode(decoder)?;
+        let status_flag = u32::decode(decoder)?;
+        let race = u8::decode(decoder)?;
+        let run_speed = i16::decode(decoder)?;
+        let atk_speed = i16::decode(decoder)?;
+        let weight_rate = u8::decode(decoder)?;
+        let face = u32::decode(decoder)?;
+        let hair = u32::decode(decoder)?;
+        let mut inventory: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)] =
+            core::array::from_fn(|i| EquippedItem::default());
+        for index in 0..MAX_VISIBLE_ITEMS as usize {
+            inventory[index] = EquippedItem::decode(decoder)?;
+        }
+        let mut bullets: [Header; (BulletType::MaxBulletTypes as usize)] = core::array::from_fn(|i| Header::default());
+        for index in 0..BulletType::MaxBulletTypes as usize {
+            bullets[index] = Header::decode(decoder)?;
+        }
+        let job = i16::decode(decoder)?;
+        let level = u8::decode(decoder)?;
+        let mut riding_items: [EquippedItem; (RidingItem::MaxRidingItems as usize)] =
+            core::array::from_fn(|i| EquippedItem::default());
+        for index in 0..RidingItem::MaxRidingItems as usize {
+            riding_items[index] = EquippedItem::decode(decoder)?;
+        }
+        let z = i16::decode(decoder)?;
+        let sub_flag = u32::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        let other_name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            id,
+            x,
+            y,
+            dest_x,
+            dest_y,
+            command,
+            target_id,
+            move_mode,
+            hp,
+            team_id,
+            status_flag,
+            race,
+            run_speed,
+            atk_speed,
+            weight_rate,
+            face,
+            hair,
+            inventory,
+            bullets,
+            job,
+            level,
+            riding_items,
+            z,
+            sub_flag,
+            name,
+            other_name,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_quest_data.rs b/packet-service/src/packets/srv_quest_data.rs
new file mode 100644
index 0000000..0b46d9a
--- /dev/null
+++ b/packet-service/src/packets/srv_quest_data.rs
@@ -0,0 +1,228 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Quest {
+    pub(crate) id: u16,
+    // timer: Unlimited if 0
+    pub(crate) timer: u32,
+    pub(crate) vars: [u16; (MAX_QUEST_VARS as usize)],
+    pub(crate) switches: u32,
+    pub(crate) items: [Item; (MAX_QUEST_ITEMS as usize)],
+}
+
+impl Encode for Quest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.timer.encode(encoder)?;
+        self.vars.encode(encoder)?;
+        self.switches.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Quest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let timer = u32::decode(decoder)?;
+        let mut vars = [0u16; (MAX_QUEST_VARS as usize)];
+        for value in &mut vars {
+            *value = u16::decode(decoder)?;
+        }
+        let switches = u32::decode(decoder)?;
+        let mut items: [Item; (MAX_QUEST_ITEMS as usize)] = core::array::from_fn(|i| Item::default());
+        for index in 0..MAX_QUEST_ITEMS as usize {
+            items[index] = Item::decode(decoder)?;
+        }
+        Ok(Self {
+            id,
+            timer,
+            vars,
+            switches,
+            items,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvQuestData {
+    pub(crate) episodes: [u16; (MAX_CONDITIONS_EPISODE as usize)],
+    pub(crate) jobs: [u16; (MAX_CONDITIONS_JOB as usize)],
+    pub(crate) planets: [u16; (MAX_CONDITIONS_PLANET as usize)],
+    pub(crate) unions: [u16; (MAX_CONDITIONS_UNION as usize)],
+    pub(crate) quests: [Quest; (MAX_QUESTS as usize)],
+    pub(crate) switches: [u32; (MAX_SWITCHES as usize)],
+    pub(crate) wishlist: [Item; (MAX_WISHLIST as usize)],
+}
+
+impl PacketPayload for SrvQuestData {}
+
+impl Encode for SrvQuestData {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        for value in &self.episodes {
+            value.encode(encoder)?;
+        }
+        for value in &self.jobs {
+            value.encode(encoder)?;
+        }
+        for value in &self.planets {
+            value.encode(encoder)?;
+        }
+        for value in &self.unions {
+            value.encode(encoder)?;
+        }
+        for value in &self.quests {
+            value.encode(encoder)?;
+        }
+        for value in &self.switches {
+            value.encode(encoder)?;
+        }
+        for value in &self.wishlist {
+            value.encode(encoder)?;
+        }
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvQuestData {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let mut episodes = [0u16; (MAX_CONDITIONS_EPISODE as usize)];
+        for value in &mut episodes {
+            *value = u16::decode(decoder)?;
+        }
+        let mut jobs = [0u16; (MAX_CONDITIONS_JOB as usize)];
+        for value in &mut jobs {
+            *value = u16::decode(decoder)?;
+        }
+        let mut planets = [0u16; (MAX_CONDITIONS_PLANET as usize)];
+        for value in &mut planets {
+            *value = u16::decode(decoder)?;
+        }
+        let mut unions = [0u16; (MAX_CONDITIONS_UNION as usize)];
+        for value in &mut unions {
+            *value = u16::decode(decoder)?;
+        }
+        let mut quests: [Quest; (MAX_QUESTS as usize)] = core::array::from_fn(|i| Quest::default());
+        for index in 0..MAX_QUESTS as usize {
+            quests[index] = Quest::decode(decoder)?;
+        }
+        let mut switches = [0u32; (MAX_SWITCHES as usize)];
+        for value in &mut switches {
+            *value = u32::decode(decoder)?;
+        }
+        let mut wishlist: [Item; (MAX_WISHLIST as usize)] = core::array::from_fn(|i| Item::default());
+        for index in 0..MAX_WISHLIST as usize {
+            wishlist[index] = Item::decode(decoder)?;
+        }
+        Ok(Self {
+            episodes,
+            jobs,
+            planets,
+            unions,
+            quests,
+            switches,
+            wishlist,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_quest_data_reply.rs b/packet-service/src/packets/srv_quest_data_reply.rs
new file mode 100644
index 0000000..c2edae0
--- /dev/null
+++ b/packet-service/src/packets/srv_quest_data_reply.rs
@@ -0,0 +1,72 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum QuestDataResult {
+    AddSuccess = 0,
+    AddFail = 1,
+    RemoveSuccess = 2,
+    RemoveFail = 3,
+    TriggerSuccess = 4,
+    TriggerFail = 5,
+}
+
+impl Encode for QuestDataResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for QuestDataResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(QuestDataResult::AddSuccess),
+            1 => Ok(QuestDataResult::AddFail),
+            2 => Ok(QuestDataResult::RemoveSuccess),
+            3 => Ok(QuestDataResult::RemoveFail),
+            4 => Ok(QuestDataResult::TriggerSuccess),
+            5 => Ok(QuestDataResult::TriggerFail),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for QuestDataResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvQuestDataReply {
+    pub(crate) result: QuestDataResult,
+    pub(crate) slot: u8,
+    pub(crate) id: i32,
+}
+
+impl PacketPayload for SrvQuestDataReply {}
+
+impl Encode for SrvQuestDataReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvQuestDataReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = QuestDataResult::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        let id = i32::decode(decoder)?;
+        Ok(Self { result, slot, id })
+    }
+}
diff --git a/packet-service/src/packets/srv_quest_reward_add_value.rs b/packet-service/src/packets/srv_quest_reward_add_value.rs
new file mode 100644
index 0000000..9fa4400
--- /dev/null
+++ b/packet-service/src/packets/srv_quest_reward_add_value.rs
@@ -0,0 +1,109 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum QuestRewardValueType {
+    Sex = 2,
+    Face = 8,
+    Hair = 9,
+    Str = 10,
+    Dex = 11,
+    Int = 12,
+    Con = 13,
+    Cha = 14,
+    Sen = 15,
+    Hp = 16,
+    Mp = 17,
+    Exp = 30,
+    Statpoint = 32,
+    Skillpoint = 37,
+    Money = 40,
+    Stamina = 76,
+    Unionpoint1 = 81,
+    Unionpoint2 = 82,
+    Unionpoint3 = 83,
+    Unionpoint4 = 84,
+    Unionpoint5 = 85,
+    Unionpoint6 = 86,
+    Unionpoint7 = 87,
+    Unionpoint8 = 88,
+    Unionpoint9 = 89,
+    Unionpoint10 = 90,
+}
+
+impl Encode for QuestRewardValueType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for QuestRewardValueType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            2 => Ok(QuestRewardValueType::Sex),
+            8 => Ok(QuestRewardValueType::Face),
+            9 => Ok(QuestRewardValueType::Hair),
+            10 => Ok(QuestRewardValueType::Str),
+            11 => Ok(QuestRewardValueType::Dex),
+            12 => Ok(QuestRewardValueType::Int),
+            13 => Ok(QuestRewardValueType::Con),
+            14 => Ok(QuestRewardValueType::Cha),
+            15 => Ok(QuestRewardValueType::Sen),
+            16 => Ok(QuestRewardValueType::Hp),
+            17 => Ok(QuestRewardValueType::Mp),
+            30 => Ok(QuestRewardValueType::Exp),
+            32 => Ok(QuestRewardValueType::Statpoint),
+            37 => Ok(QuestRewardValueType::Skillpoint),
+            40 => Ok(QuestRewardValueType::Money),
+            76 => Ok(QuestRewardValueType::Stamina),
+            81 => Ok(QuestRewardValueType::Unionpoint1),
+            82 => Ok(QuestRewardValueType::Unionpoint2),
+            83 => Ok(QuestRewardValueType::Unionpoint3),
+            84 => Ok(QuestRewardValueType::Unionpoint4),
+            85 => Ok(QuestRewardValueType::Unionpoint5),
+            86 => Ok(QuestRewardValueType::Unionpoint6),
+            87 => Ok(QuestRewardValueType::Unionpoint7),
+            88 => Ok(QuestRewardValueType::Unionpoint8),
+            89 => Ok(QuestRewardValueType::Unionpoint9),
+            90 => Ok(QuestRewardValueType::Unionpoint10),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for QuestRewardValueType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvQuestRewardAddValue {
+    pub(crate) type_: QuestRewardValueType,
+    pub(crate) value: i32,
+}
+
+impl PacketPayload for SrvQuestRewardAddValue {}
+
+impl Encode for SrvQuestRewardAddValue {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvQuestRewardAddValue {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = QuestRewardValueType::decode(decoder)?;
+        let value = i32::decode(decoder)?;
+        Ok(Self { type_, value })
+    }
+}
diff --git a/packet-service/src/packets/srv_quest_reward_set_value.rs b/packet-service/src/packets/srv_quest_reward_set_value.rs
new file mode 100644
index 0000000..4031210
--- /dev/null
+++ b/packet-service/src/packets/srv_quest_reward_set_value.rs
@@ -0,0 +1,111 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u16)]
+#[derive(Debug, Clone)]
+pub(crate) enum QuestRewardValueType {
+    Sex = 2,
+    Class = 4,
+    Union = 5,
+    Face = 8,
+    Hair = 9,
+    Str = 10,
+    Dex = 11,
+    Int = 12,
+    Con = 13,
+    Cha = 14,
+    Sen = 15,
+    Hp = 16,
+    Mp = 17,
+    Exp = 30,
+    Level = 31,
+    PkFlag = 33,
+    Team = 34,
+    Unionpoint1 = 81,
+    Unionpoint2 = 82,
+    Unionpoint3 = 83,
+    Unionpoint4 = 84,
+    Unionpoint5 = 85,
+    Unionpoint6 = 86,
+    Unionpoint7 = 87,
+    Unionpoint8 = 88,
+    Unionpoint9 = 89,
+    Unionpoint10 = 90,
+}
+
+impl Encode for QuestRewardValueType {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for QuestRewardValueType {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u16::decode(decoder)?;
+        match value {
+            2 => Ok(QuestRewardValueType::Sex),
+            4 => Ok(QuestRewardValueType::Class),
+            5 => Ok(QuestRewardValueType::Union),
+            8 => Ok(QuestRewardValueType::Face),
+            9 => Ok(QuestRewardValueType::Hair),
+            10 => Ok(QuestRewardValueType::Str),
+            11 => Ok(QuestRewardValueType::Dex),
+            12 => Ok(QuestRewardValueType::Int),
+            13 => Ok(QuestRewardValueType::Con),
+            14 => Ok(QuestRewardValueType::Cha),
+            15 => Ok(QuestRewardValueType::Sen),
+            16 => Ok(QuestRewardValueType::Hp),
+            17 => Ok(QuestRewardValueType::Mp),
+            30 => Ok(QuestRewardValueType::Exp),
+            31 => Ok(QuestRewardValueType::Level),
+            33 => Ok(QuestRewardValueType::PkFlag),
+            34 => Ok(QuestRewardValueType::Team),
+            81 => Ok(QuestRewardValueType::Unionpoint1),
+            82 => Ok(QuestRewardValueType::Unionpoint2),
+            83 => Ok(QuestRewardValueType::Unionpoint3),
+            84 => Ok(QuestRewardValueType::Unionpoint4),
+            85 => Ok(QuestRewardValueType::Unionpoint5),
+            86 => Ok(QuestRewardValueType::Unionpoint6),
+            87 => Ok(QuestRewardValueType::Unionpoint7),
+            88 => Ok(QuestRewardValueType::Unionpoint8),
+            89 => Ok(QuestRewardValueType::Unionpoint9),
+            90 => Ok(QuestRewardValueType::Unionpoint10),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for QuestRewardValueType: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvQuestRewardSetValue {
+    pub(crate) type_: QuestRewardValueType,
+    pub(crate) value: i32,
+}
+
+impl PacketPayload for SrvQuestRewardSetValue {}
+
+impl Encode for SrvQuestRewardSetValue {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvQuestRewardSetValue {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = QuestRewardValueType::decode(decoder)?;
+        let value = i32::decode(decoder)?;
+        Ok(Self { type_, value })
+    }
+}
diff --git a/packet-service/src/packets/srv_remove_object.rs b/packet-service/src/packets/srv_remove_object.rs
new file mode 100644
index 0000000..e3dbd6e
--- /dev/null
+++ b/packet-service/src/packets/srv_remove_object.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvRemoveObject {
+    pub(crate) id: u16,
+}
+
+impl PacketPayload for SrvRemoveObject {}
+
+impl Encode for SrvRemoveObject {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvRemoveObject {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        Ok(Self { id })
+    }
+}
diff --git a/packet-service/src/packets/srv_revive_reply.rs b/packet-service/src/packets/srv_revive_reply.rs
new file mode 100644
index 0000000..93d99aa
--- /dev/null
+++ b/packet-service/src/packets/srv_revive_reply.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvReviveReply {
+    pub(crate) map_id: u16,
+}
+
+impl PacketPayload for SrvReviveReply {}
+
+impl Encode for SrvReviveReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.map_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvReviveReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let map_id = u16::decode(decoder)?;
+        Ok(Self { map_id })
+    }
+}
diff --git a/packet-service/src/packets/srv_ride_request.rs b/packet-service/src/packets/srv_ride_request.rs
new file mode 100644
index 0000000..b5e80ae
--- /dev/null
+++ b/packet-service/src/packets/srv_ride_request.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum RideAction {
+    Request = 0,
+    Accept = 1,
+    Refuse = 2,
+    OwnerNotFound = 3,
+    GuestNotFound = 4,
+}
+
+impl Encode for RideAction {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for RideAction {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(RideAction::Request),
+            1 => Ok(RideAction::Accept),
+            2 => Ok(RideAction::Refuse),
+            3 => Ok(RideAction::OwnerNotFound),
+            4 => Ok(RideAction::GuestNotFound),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for RideAction: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvRideRequest {
+    pub(crate) action: RideAction,
+    pub(crate) owner: u16,
+    pub(crate) guest: u32,
+}
+
+impl PacketPayload for SrvRideRequest {}
+
+impl Encode for SrvRideRequest {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.action.encode(encoder)?;
+        self.owner.encode(encoder)?;
+        self.guest.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvRideRequest {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let action = RideAction::decode(decoder)?;
+        let owner = u16::decode(decoder)?;
+        let guest = u32::decode(decoder)?;
+        Ok(Self { action, owner, guest })
+    }
+}
diff --git a/packet-service/src/packets/srv_ride_state_change.rs b/packet-service/src/packets/srv_ride_state_change.rs
new file mode 100644
index 0000000..f2c83f9
--- /dev/null
+++ b/packet-service/src/packets/srv_ride_state_change.rs
@@ -0,0 +1,45 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvRideStateChange {
+    pub(crate) enabled: i8,
+    pub(crate) cooldown: u32,
+    pub(crate) max_hp: i16,
+    pub(crate) target: u16,
+}
+
+impl PacketPayload for SrvRideStateChange {}
+
+impl Encode for SrvRideStateChange {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.enabled.encode(encoder)?;
+        self.cooldown.encode(encoder)?;
+        self.max_hp.encode(encoder)?;
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvRideStateChange {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let enabled = i8::decode(decoder)?;
+        let cooldown = u32::decode(decoder)?;
+        let max_hp = i16::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        Ok(Self {
+            enabled,
+            cooldown,
+            max_hp,
+            target,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_screen_shot_time_reply.rs b/packet-service/src/packets/srv_screen_shot_time_reply.rs
new file mode 100644
index 0000000..d3f5fcc
--- /dev/null
+++ b/packet-service/src/packets/srv_screen_shot_time_reply.rs
@@ -0,0 +1,49 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvScreenShotTimeReply {
+    pub(crate) year: u16,
+    pub(crate) month: u8,
+    pub(crate) day: u8,
+    pub(crate) hour: u8,
+    pub(crate) min: u8,
+}
+
+impl PacketPayload for SrvScreenShotTimeReply {}
+
+impl Encode for SrvScreenShotTimeReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.year.encode(encoder)?;
+        self.month.encode(encoder)?;
+        self.day.encode(encoder)?;
+        self.hour.encode(encoder)?;
+        self.min.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvScreenShotTimeReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let year = u16::decode(decoder)?;
+        let month = u8::decode(decoder)?;
+        let day = u8::decode(decoder)?;
+        let hour = u8::decode(decoder)?;
+        let min = u8::decode(decoder)?;
+        Ok(Self {
+            year,
+            month,
+            day,
+            hour,
+            min,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_select_char_reply.rs b/packet-service/src/packets/srv_select_char_reply.rs
new file mode 100644
index 0000000..08826dc
--- /dev/null
+++ b/packet-service/src/packets/srv_select_char_reply.rs
@@ -0,0 +1,272 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct EquippedItem {
+    pub(crate) id: u16,
+    pub(crate) gem_opt: u16,
+    pub(crate) socket: i8,
+    pub(crate) grade: u8,
+}
+
+impl Encode for EquippedItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.gem_opt.encode(encoder)?;
+        self.socket.encode(encoder)?;
+        self.grade.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for EquippedItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let gem_opt = u16::decode(decoder)?;
+        let socket = i8::decode(decoder)?;
+        let grade = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            gem_opt,
+            socket,
+            grade,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSelectCharReply {
+    pub(crate) race: u8,
+    pub(crate) map: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) spawn: u16,
+    // It's actually the face that is expected here
+    pub(crate) body_face: u32,
+    // It's actually the hair that is expected here
+    pub(crate) body_hair: u32,
+    pub(crate) equipped_items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)],
+    pub(crate) stone: u8,
+    pub(crate) face: u8,
+    pub(crate) hair: u8,
+    pub(crate) job: u16,
+    pub(crate) faction_id: u8,
+    pub(crate) faction_rank: u8,
+    pub(crate) fame: u8,
+    pub(crate) str: u16,
+    pub(crate) dex: u16,
+    pub(crate) int: u16,
+    pub(crate) con: u16,
+    pub(crate) charm: u16,
+    pub(crate) sense: u16,
+    pub(crate) hp: i32,
+    pub(crate) mp: i32,
+    pub(crate) xp: u32,
+    pub(crate) level: u16,
+    pub(crate) stat_points: u32,
+    pub(crate) skill_points: u32,
+    pub(crate) body_size: u8,
+    pub(crate) head_size: u8,
+    pub(crate) penalty_xp: u32,
+    pub(crate) faction_fame: [u16; 2],
+    pub(crate) faction_points: [u16; 10],
+    pub(crate) guild_id: u32,
+    pub(crate) guild_contribution: u16,
+    pub(crate) guild_rank: u8,
+    pub(crate) pk_flag: u16,
+    pub(crate) stamina: u16,
+    pub(crate) effects: [StatusEffect; (MAX_STATUS_EFFECTS as usize)],
+    pub(crate) pat_hp: u16,
+    pub(crate) pat_cooldown_time: u32,
+    pub(crate) skills: [u16; (MAX_SKILL_COUNT as usize)],
+    pub(crate) hotbar: [HotbarItem; (MAX_HOTBAR_ITEMS as usize)],
+    pub(crate) tag: u32,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvSelectCharReply {}
+
+impl Encode for SrvSelectCharReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.race.encode(encoder)?;
+        self.map.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.spawn.encode(encoder)?;
+        self.body_face.encode(encoder)?;
+        self.body_hair.encode(encoder)?;
+        for value in &self.equipped_items {
+            value.encode(encoder)?;
+        }
+        self.stone.encode(encoder)?;
+        self.face.encode(encoder)?;
+        self.hair.encode(encoder)?;
+        self.job.encode(encoder)?;
+        self.faction_id.encode(encoder)?;
+        self.faction_rank.encode(encoder)?;
+        self.fame.encode(encoder)?;
+        self.str.encode(encoder)?;
+        self.dex.encode(encoder)?;
+        self.int.encode(encoder)?;
+        self.con.encode(encoder)?;
+        self.charm.encode(encoder)?;
+        self.sense.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.mp.encode(encoder)?;
+        self.xp.encode(encoder)?;
+        self.level.encode(encoder)?;
+        self.stat_points.encode(encoder)?;
+        self.skill_points.encode(encoder)?;
+        self.body_size.encode(encoder)?;
+        self.head_size.encode(encoder)?;
+        self.penalty_xp.encode(encoder)?;
+        for value in &self.faction_fame {
+            value.encode(encoder)?;
+        }
+        for value in &self.faction_points {
+            value.encode(encoder)?;
+        }
+        self.guild_id.encode(encoder)?;
+        self.guild_contribution.encode(encoder)?;
+        self.guild_rank.encode(encoder)?;
+        self.pk_flag.encode(encoder)?;
+        self.stamina.encode(encoder)?;
+        for value in &self.effects {
+            value.encode(encoder)?;
+        }
+        self.pat_hp.encode(encoder)?;
+        self.pat_cooldown_time.encode(encoder)?;
+        for value in &self.skills {
+            value.encode(encoder)?;
+        }
+        for value in &self.hotbar {
+            value.encode(encoder)?;
+        }
+        self.tag.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSelectCharReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let race = u8::decode(decoder)?;
+        let map = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let spawn = u16::decode(decoder)?;
+        let body_face = u32::decode(decoder)?;
+        let body_hair = u32::decode(decoder)?;
+        let mut equipped_items: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)] =
+            core::array::from_fn(|i| EquippedItem::default());
+        for index in 0..MAX_VISIBLE_ITEMS as usize {
+            equipped_items[index] = EquippedItem::decode(decoder)?;
+        }
+        let stone = u8::decode(decoder)?;
+        let face = u8::decode(decoder)?;
+        let hair = u8::decode(decoder)?;
+        let job = u16::decode(decoder)?;
+        let faction_id = u8::decode(decoder)?;
+        let faction_rank = u8::decode(decoder)?;
+        let fame = u8::decode(decoder)?;
+        let str = u16::decode(decoder)?;
+        let dex = u16::decode(decoder)?;
+        let int = u16::decode(decoder)?;
+        let con = u16::decode(decoder)?;
+        let charm = u16::decode(decoder)?;
+        let sense = u16::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        let mp = i32::decode(decoder)?;
+        let xp = u32::decode(decoder)?;
+        let level = u16::decode(decoder)?;
+        let stat_points = u32::decode(decoder)?;
+        let skill_points = u32::decode(decoder)?;
+        let body_size = u8::decode(decoder)?;
+        let head_size = u8::decode(decoder)?;
+        let penalty_xp = u32::decode(decoder)?;
+        let mut faction_fame = [0u16; 2];
+        for value in &mut faction_fame {
+            *value = u16::decode(decoder)?;
+        }
+        let mut faction_points = [0u16; 10];
+        for value in &mut faction_points {
+            *value = u16::decode(decoder)?;
+        }
+        let guild_id = u32::decode(decoder)?;
+        let guild_contribution = u16::decode(decoder)?;
+        let guild_rank = u8::decode(decoder)?;
+        let pk_flag = u16::decode(decoder)?;
+        let stamina = u16::decode(decoder)?;
+        let mut effects: [StatusEffect; (MAX_STATUS_EFFECTS as usize)] =
+            core::array::from_fn(|i| StatusEffect::default());
+        for index in 0..MAX_STATUS_EFFECTS as usize {
+            effects[index] = StatusEffect::decode(decoder)?;
+        }
+        let pat_hp = u16::decode(decoder)?;
+        let pat_cooldown_time = u32::decode(decoder)?;
+        let mut skills = [0u16; (MAX_SKILL_COUNT as usize)];
+        for value in &mut skills {
+            *value = u16::decode(decoder)?;
+        }
+        let mut hotbar: [HotbarItem; (MAX_HOTBAR_ITEMS as usize)] = core::array::from_fn(|i| HotbarItem::default());
+        for index in 0..MAX_HOTBAR_ITEMS as usize {
+            hotbar[index] = HotbarItem::decode(decoder)?;
+        }
+        let tag = u32::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            race,
+            map,
+            x,
+            y,
+            spawn,
+            body_face,
+            body_hair,
+            equipped_items,
+            stone,
+            face,
+            hair,
+            job,
+            faction_id,
+            faction_rank,
+            fame,
+            str,
+            dex,
+            int,
+            con,
+            charm,
+            sense,
+            hp,
+            mp,
+            xp,
+            level,
+            stat_points,
+            skill_points,
+            body_size,
+            head_size,
+            penalty_xp,
+            faction_fame,
+            faction_points,
+            guild_id,
+            guild_contribution,
+            guild_rank,
+            pk_flag,
+            stamina,
+            effects,
+            pat_hp,
+            pat_cooldown_time,
+            skills,
+            hotbar,
+            tag,
+            name,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_server_data.rs b/packet-service/src/packets/srv_server_data.rs
new file mode 100644
index 0000000..be885bc
--- /dev/null
+++ b/packet-service/src/packets/srv_server_data.rs
@@ -0,0 +1,27 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvServerData {}
+
+impl PacketPayload for SrvServerData {}
+
+impl Encode for SrvServerData {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvServerData {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Self {})
+    }
+}
diff --git a/packet-service/src/packets/srv_set_animation.rs b/packet-service/src/packets/srv_set_animation.rs
new file mode 100644
index 0000000..5a1dcc5
--- /dev/null
+++ b/packet-service/src/packets/srv_set_animation.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetAnimation {
+    pub(crate) id: u16,
+    pub(crate) value: u16,
+    pub(crate) object_id: u16,
+}
+
+impl PacketPayload for SrvSetAnimation {}
+
+impl Encode for SrvSetAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.value.encode(encoder)?;
+        self.object_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let value = u16::decode(decoder)?;
+        let object_id = u16::decode(decoder)?;
+        Ok(Self { id, value, object_id })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_exp.rs b/packet-service/src/packets/srv_set_exp.rs
new file mode 100644
index 0000000..93f2129
--- /dev/null
+++ b/packet-service/src/packets/srv_set_exp.rs
@@ -0,0 +1,41 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetExp {
+    pub(crate) exp: i64,
+    pub(crate) stamina: i16,
+    pub(crate) source_id: u16,
+}
+
+impl PacketPayload for SrvSetExp {}
+
+impl Encode for SrvSetExp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.exp.encode(encoder)?;
+        self.stamina.encode(encoder)?;
+        self.source_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetExp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let exp = i64::decode(decoder)?;
+        let stamina = i16::decode(decoder)?;
+        let source_id = u16::decode(decoder)?;
+        Ok(Self {
+            exp,
+            stamina,
+            source_id,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_hp_and_mp.rs b/packet-service/src/packets/srv_set_hp_and_mp.rs
new file mode 100644
index 0000000..8812fa3
--- /dev/null
+++ b/packet-service/src/packets/srv_set_hp_and_mp.rs
@@ -0,0 +1,37 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetHpAndMp {
+    pub(crate) id: u16,
+    pub(crate) hp: i32,
+    pub(crate) mp: i32,
+}
+
+impl PacketPayload for SrvSetHpAndMp {}
+
+impl Encode for SrvSetHpAndMp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.hp.encode(encoder)?;
+        self.mp.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetHpAndMp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let hp = i32::decode(decoder)?;
+        let mp = i32::decode(decoder)?;
+        Ok(Self { id, hp, mp })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_item.rs b/packet-service/src/packets/srv_set_item.rs
new file mode 100644
index 0000000..6bfa32d
--- /dev/null
+++ b/packet-service/src/packets/srv_set_item.rs
@@ -0,0 +1,145 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct IndexAndItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for IndexAndItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for IndexAndItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSetItem {
+    pub(crate) items: Vec<IndexAndItem>,
+}
+
+impl PacketPayload for SrvSetItem {}
+
+impl Encode for SrvSetItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let items = Vec::decode(decoder)?;
+        Ok(Self { items })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_item_life.rs b/packet-service/src/packets/srv_set_item_life.rs
new file mode 100644
index 0000000..97036e4
--- /dev/null
+++ b/packet-service/src/packets/srv_set_item_life.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetItemLife {
+    pub(crate) index: u16,
+    pub(crate) life: u16,
+}
+
+impl PacketPayload for SrvSetItemLife {}
+
+impl Encode for SrvSetItemLife {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.life.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetItemLife {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        Ok(Self { index, life })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_money.rs b/packet-service/src/packets/srv_set_money.rs
new file mode 100644
index 0000000..2e08422
--- /dev/null
+++ b/packet-service/src/packets/srv_set_money.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetMoney {
+    pub(crate) zuly: i64,
+}
+
+impl PacketPayload for SrvSetMoney {}
+
+impl Encode for SrvSetMoney {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.zuly.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetMoney {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let zuly = i64::decode(decoder)?;
+        Ok(Self { zuly })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_money_and_item.rs b/packet-service/src/packets/srv_set_money_and_item.rs
new file mode 100644
index 0000000..ccd75ff
--- /dev/null
+++ b/packet-service/src/packets/srv_set_money_and_item.rs
@@ -0,0 +1,148 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct IndexAndItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+}
+
+impl Encode for IndexAndItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for IndexAndItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { index, item })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSetMoneyAndItem {
+    pub(crate) zuly: i64,
+    pub(crate) items: Vec<IndexAndItem>,
+}
+
+impl PacketPayload for SrvSetMoneyAndItem {}
+
+impl Encode for SrvSetMoneyAndItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.zuly.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetMoneyAndItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let zuly = i64::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self { zuly, items })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_position.rs b/packet-service/src/packets/srv_set_position.rs
new file mode 100644
index 0000000..b11b99d
--- /dev/null
+++ b/packet-service/src/packets/srv_set_position.rs
@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetPosition {
+    pub(crate) char_id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: i16,
+}
+
+impl PacketPayload for SrvSetPosition {}
+
+impl Encode for SrvSetPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = i16::decode(decoder)?;
+        Ok(Self { char_id, x, y, z })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_server_var_reply.rs b/packet-service/src/packets/srv_set_server_var_reply.rs
new file mode 100644
index 0000000..658fef3
--- /dev/null
+++ b/packet-service/src/packets/srv_set_server_var_reply.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetServerVarReply {
+    pub(crate) type_: u8,
+    pub(crate) value: u32,
+}
+
+impl PacketPayload for SrvSetServerVarReply {}
+
+impl Encode for SrvSetServerVarReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetServerVarReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let value = u32::decode(decoder)?;
+        Ok(Self { type_, value })
+    }
+}
diff --git a/packet-service/src/packets/srv_set_weight.rs b/packet-service/src/packets/srv_set_weight.rs
new file mode 100644
index 0000000..11a188a
--- /dev/null
+++ b/packet-service/src/packets/srv_set_weight.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetWeight {
+    pub(crate) char_id: u16,
+    pub(crate) weight: u8,
+}
+
+impl PacketPayload for SrvSetWeight {}
+
+impl Encode for SrvSetWeight {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.weight.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetWeight {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let weight = u8::decode(decoder)?;
+        Ok(Self { char_id, weight })
+    }
+}
diff --git a/packet-service/src/packets/srv_setexp.rs b/packet-service/src/packets/srv_setexp.rs
new file mode 100644
index 0000000..2c894b0
--- /dev/null
+++ b/packet-service/src/packets/srv_setexp.rs
@@ -0,0 +1,41 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSetexp {
+    pub(crate) exp: i64,
+    pub(crate) stamina: i16,
+    pub(crate) source_id: u16,
+}
+
+impl PacketPayload for SrvSetexp {}
+
+impl Encode for SrvSetexp {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.exp.encode(encoder)?;
+        self.stamina.encode(encoder)?;
+        self.source_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSetexp {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let exp = i64::decode(decoder)?;
+        let stamina = i16::decode(decoder)?;
+        let source_id = u16::decode(decoder)?;
+        Ok(Self {
+            exp,
+            stamina,
+            source_id,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_shop_close.rs b/packet-service/src/packets/srv_shop_close.rs
new file mode 100644
index 0000000..cb1374b
--- /dev/null
+++ b/packet-service/src/packets/srv_shop_close.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvShopClose {
+    pub(crate) id: u16,
+}
+
+impl PacketPayload for SrvShopClose {}
+
+impl Encode for SrvShopClose {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvShopClose {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        Ok(Self { id })
+    }
+}
diff --git a/packet-service/src/packets/srv_shop_list_reply.rs b/packet-service/src/packets/srv_shop_list_reply.rs
new file mode 100644
index 0000000..59536ec
--- /dev/null
+++ b/packet-service/src/packets/srv_shop_list_reply.rs
@@ -0,0 +1,158 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ShopListItem {
+    pub(crate) index: u8,
+    pub(crate) item: Item,
+    pub(crate) price: u32,
+}
+
+impl Encode for ShopListItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.index.encode(encoder)?;
+        self.item.encode(encoder)?;
+        self.price.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for ShopListItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let index = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        let price = u32::decode(decoder)?;
+        Ok(Self { index, item, price })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvShopListReply {
+    pub(crate) sell_count: u8,
+    pub(crate) wishlist_count: u8,
+    pub(crate) items: Vec<ShopListItem>,
+}
+
+impl PacketPayload for SrvShopListReply {}
+
+impl Encode for SrvShopListReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sell_count.encode(encoder)?;
+        self.wishlist_count.encode(encoder)?;
+        self.items.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvShopListReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sell_count = u8::decode(decoder)?;
+        let wishlist_count = u8::decode(decoder)?;
+        let items = Vec::decode(decoder)?;
+        Ok(Self {
+            sell_count,
+            wishlist_count,
+            items,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_shop_open.rs b/packet-service/src/packets/srv_shop_open.rs
new file mode 100644
index 0000000..ab8e225
--- /dev/null
+++ b/packet-service/src/packets/srv_shop_open.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvShopOpen {
+    pub(crate) id: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvShopOpen {}
+
+impl Encode for SrvShopOpen {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvShopOpen {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { id, name })
+    }
+}
diff --git a/packet-service/src/packets/srv_shout_chat.rs b/packet-service/src/packets/srv_shout_chat.rs
new file mode 100644
index 0000000..79618ce
--- /dev/null
+++ b/packet-service/src/packets/srv_shout_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvShoutChat {
+    pub(crate) sender: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvShoutChat {}
+
+impl Encode for SrvShoutChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sender.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvShoutChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sender = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { sender, message })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_cancel.rs b/packet-service/src/packets/srv_skill_cancel.rs
new file mode 100644
index 0000000..c4f9ccc
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_cancel.rs
@@ -0,0 +1,63 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum SkillCancelResult {
+    InvalidSkill = 0,
+    InvalidTarget = 1,
+    TargetNotFound = 2,
+}
+
+impl Encode for SkillCancelResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for SkillCancelResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(SkillCancelResult::InvalidSkill),
+            1 => Ok(SkillCancelResult::InvalidTarget),
+            2 => Ok(SkillCancelResult::TargetNotFound),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for SkillCancelResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillCancel {
+    pub(crate) target: u16,
+    pub(crate) result: SkillCancelResult,
+}
+
+impl PacketPayload for SrvSkillCancel {}
+
+impl Encode for SrvSkillCancel {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillCancel {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let result = SkillCancelResult::decode(decoder)?;
+        Ok(Self { target, result })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_cast_position.rs b/packet-service/src/packets/srv_skill_cast_position.rs
new file mode 100644
index 0000000..f300bd9
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_cast_position.rs
@@ -0,0 +1,92 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MobAnimation {
+    Stop = 0,
+    Attack = 1,
+    Hit = 2,
+    Die = 3,
+    Run = 4,
+    Action1 = 5,
+    Skill1 = 6,
+    Action2 = 7,
+    Skill2 = 8,
+    Etc = 9,
+}
+
+impl Encode for MobAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MobAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MobAnimation::Stop),
+            1 => Ok(MobAnimation::Attack),
+            2 => Ok(MobAnimation::Hit),
+            3 => Ok(MobAnimation::Die),
+            4 => Ok(MobAnimation::Run),
+            5 => Ok(MobAnimation::Action1),
+            6 => Ok(MobAnimation::Skill1),
+            7 => Ok(MobAnimation::Action2),
+            8 => Ok(MobAnimation::Skill2),
+            9 => Ok(MobAnimation::Etc),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MobAnimation: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillCastPosition {
+    pub(crate) source: u16,
+    pub(crate) id: i16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) animation: MobAnimation,
+}
+
+impl PacketPayload for SrvSkillCastPosition {}
+
+impl Encode for SrvSkillCastPosition {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.source.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.animation.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillCastPosition {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let source = u16::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let animation = MobAnimation::decode(decoder)?;
+        Ok(Self {
+            source,
+            id,
+            x,
+            y,
+            animation,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_cast_self.rs b/packet-service/src/packets/srv_skill_cast_self.rs
new file mode 100644
index 0000000..8c80867
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_cast_self.rs
@@ -0,0 +1,80 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MobAnimation {
+    Stop = 0,
+    Attack = 1,
+    Hit = 2,
+    Die = 3,
+    Run = 4,
+    Action1 = 5,
+    Skill1 = 6,
+    Action2 = 7,
+    Skill2 = 8,
+    Etc = 9,
+}
+
+impl Encode for MobAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MobAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MobAnimation::Stop),
+            1 => Ok(MobAnimation::Attack),
+            2 => Ok(MobAnimation::Hit),
+            3 => Ok(MobAnimation::Die),
+            4 => Ok(MobAnimation::Run),
+            5 => Ok(MobAnimation::Action1),
+            6 => Ok(MobAnimation::Skill1),
+            7 => Ok(MobAnimation::Action2),
+            8 => Ok(MobAnimation::Skill2),
+            9 => Ok(MobAnimation::Etc),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MobAnimation: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillCastSelf {
+    pub(crate) target: u16,
+    pub(crate) id: i8,
+    pub(crate) animation: MobAnimation,
+}
+
+impl PacketPayload for SrvSkillCastSelf {}
+
+impl Encode for SrvSkillCastSelf {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.animation.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillCastSelf {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let id = i8::decode(decoder)?;
+        let animation = MobAnimation::decode(decoder)?;
+        Ok(Self { target, id, animation })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_cast_target.rs b/packet-service/src/packets/srv_skill_cast_target.rs
new file mode 100644
index 0000000..15de987
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_cast_target.rs
@@ -0,0 +1,100 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum MobAnimation {
+    Stop = 0,
+    Attack = 1,
+    Hit = 2,
+    Die = 3,
+    Run = 4,
+    Action1 = 5,
+    Skill1 = 6,
+    Action2 = 7,
+    Skill2 = 8,
+    Etc = 9,
+}
+
+impl Encode for MobAnimation {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for MobAnimation {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(MobAnimation::Stop),
+            1 => Ok(MobAnimation::Attack),
+            2 => Ok(MobAnimation::Hit),
+            3 => Ok(MobAnimation::Die),
+            4 => Ok(MobAnimation::Run),
+            5 => Ok(MobAnimation::Action1),
+            6 => Ok(MobAnimation::Skill1),
+            7 => Ok(MobAnimation::Action2),
+            8 => Ok(MobAnimation::Skill2),
+            9 => Ok(MobAnimation::Etc),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for MobAnimation: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillCastTarget {
+    pub(crate) source: u16,
+    pub(crate) target: u16,
+    pub(crate) id: i8,
+    pub(crate) distance: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) animation: MobAnimation,
+}
+
+impl PacketPayload for SrvSkillCastTarget {}
+
+impl Encode for SrvSkillCastTarget {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.source.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.distance.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.animation.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillCastTarget {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let source = u16::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        let id = i8::decode(decoder)?;
+        let distance = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let animation = MobAnimation::decode(decoder)?;
+        Ok(Self {
+            source,
+            target,
+            id,
+            distance,
+            x,
+            y,
+            animation,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_damage.rs b/packet-service/src/packets/srv_skill_damage.rs
new file mode 100644
index 0000000..d99baa0
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_damage.rs
@@ -0,0 +1,153 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillDamage {
+    pub(crate) target: u16,
+    pub(crate) source: u16,
+    pub(crate) id: u16,
+    pub(crate) amount: f32,
+    pub(crate) state: u8,
+    pub(crate) damage: u32,
+    pub(crate) action: u32,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for SrvSkillDamage {}
+
+impl Encode for SrvSkillDamage {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.source.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        self.state.encode(encoder)?;
+        self.damage.encode(encoder)?;
+        self.action.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillDamage {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let source = u16::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let amount = f32::decode(decoder)?;
+        let state = u8::decode(decoder)?;
+        let damage = u32::decode(decoder)?;
+        let action = u32::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self {
+            target,
+            source,
+            id,
+            amount,
+            state,
+            damage,
+            action,
+            item,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_effect.rs b/packet-service/src/packets/srv_skill_effect.rs
new file mode 100644
index 0000000..000a326
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_effect.rs
@@ -0,0 +1,49 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSkillEffect {
+    pub(crate) target: u16,
+    pub(crate) source: u16,
+    pub(crate) id: u16,
+    pub(crate) amount: f32,
+    pub(crate) state: u8,
+}
+
+impl PacketPayload for SrvSkillEffect {}
+
+impl Encode for SrvSkillEffect {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.source.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.amount.encode(encoder)?;
+        self.state.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillEffect {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let source = u16::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let amount = f32::decode(decoder)?;
+        let state = u8::decode(decoder)?;
+        Ok(Self {
+            target,
+            source,
+            id,
+            amount,
+            state,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_finish.rs b/packet-service/src/packets/srv_skill_finish.rs
new file mode 100644
index 0000000..edd9da4
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_finish.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSkillFinish {
+    pub(crate) target: u16,
+    pub(crate) id: u16,
+}
+
+impl PacketPayload for SrvSkillFinish {}
+
+impl Encode for SrvSkillFinish {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillFinish {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        Ok(Self { target, id })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_learn.rs b/packet-service/src/packets/srv_skill_learn.rs
new file mode 100644
index 0000000..74ca642
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_learn.rs
@@ -0,0 +1,86 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum SkillLearnResult {
+    Failed = 0,
+    Succeeded = 1,
+    NeedJob = 2,
+    NeedSkill = 3,
+    NeedStat = 4,
+    NoSlots = 5,
+    InvalidSkill = 6,
+    NoPoints = 7,
+    Delete = 8,
+}
+
+impl Encode for SkillLearnResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for SkillLearnResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(SkillLearnResult::Failed),
+            1 => Ok(SkillLearnResult::Succeeded),
+            2 => Ok(SkillLearnResult::NeedJob),
+            3 => Ok(SkillLearnResult::NeedSkill),
+            4 => Ok(SkillLearnResult::NeedStat),
+            5 => Ok(SkillLearnResult::NoSlots),
+            6 => Ok(SkillLearnResult::InvalidSkill),
+            7 => Ok(SkillLearnResult::NoPoints),
+            8 => Ok(SkillLearnResult::Delete),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for SkillLearnResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillLearn {
+    pub(crate) result: SkillLearnResult,
+    pub(crate) slot: u8,
+    pub(crate) id: i16,
+    pub(crate) points: i16,
+}
+
+impl PacketPayload for SrvSkillLearn {}
+
+impl Encode for SrvSkillLearn {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.points.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillLearn {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = SkillLearnResult::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        let points = i16::decode(decoder)?;
+        Ok(Self {
+            result,
+            slot,
+            id,
+            points,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_level_reply.rs b/packet-service/src/packets/srv_skill_level_reply.rs
new file mode 100644
index 0000000..9b0e775
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_level_reply.rs
@@ -0,0 +1,82 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum SkillLevelResult {
+    Succeeded = 0,
+    Failed = 1,
+    NoPoints = 2,
+    NeedStat = 3,
+    NeedJob = 4,
+    NeedSkill = 5,
+    NoMoney = 6,
+}
+
+impl Encode for SkillLevelResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for SkillLevelResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(SkillLevelResult::Succeeded),
+            1 => Ok(SkillLevelResult::Failed),
+            2 => Ok(SkillLevelResult::NoPoints),
+            3 => Ok(SkillLevelResult::NeedStat),
+            4 => Ok(SkillLevelResult::NeedJob),
+            5 => Ok(SkillLevelResult::NeedSkill),
+            6 => Ok(SkillLevelResult::NoMoney),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for SkillLevelResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSkillLevelReply {
+    pub(crate) result: SkillLevelResult,
+    pub(crate) slot: u8,
+    pub(crate) id: i16,
+    pub(crate) points: i16,
+}
+
+impl PacketPayload for SrvSkillLevelReply {}
+
+impl Encode for SrvSkillLevelReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.slot.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.points.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillLevelReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = SkillLevelResult::decode(decoder)?;
+        let slot = u8::decode(decoder)?;
+        let id = i16::decode(decoder)?;
+        let points = i16::decode(decoder)?;
+        Ok(Self {
+            result,
+            slot,
+            id,
+            points,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_skill_start.rs b/packet-service/src/packets/srv_skill_start.rs
new file mode 100644
index 0000000..3baa244
--- /dev/null
+++ b/packet-service/src/packets/srv_skill_start.rs
@@ -0,0 +1,31 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSkillStart {
+    pub(crate) target: u16,
+}
+
+impl PacketPayload for SrvSkillStart {}
+
+impl Encode for SrvSkillStart {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSkillStart {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        Ok(Self { target })
+    }
+}
diff --git a/packet-service/src/packets/srv_speed_changed.rs b/packet-service/src/packets/srv_speed_changed.rs
new file mode 100644
index 0000000..1112e7b
--- /dev/null
+++ b/packet-service/src/packets/srv_speed_changed.rs
@@ -0,0 +1,45 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSpeedChanged {
+    pub(crate) target: u16,
+    pub(crate) move_speed: i16,
+    pub(crate) attack_speed: i16,
+    pub(crate) weight: u8,
+}
+
+impl PacketPayload for SrvSpeedChanged {}
+
+impl Encode for SrvSpeedChanged {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.move_speed.encode(encoder)?;
+        self.attack_speed.encode(encoder)?;
+        self.weight.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSpeedChanged {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let move_speed = i16::decode(decoder)?;
+        let attack_speed = i16::decode(decoder)?;
+        let weight = u8::decode(decoder)?;
+        Ok(Self {
+            target,
+            move_speed,
+            attack_speed,
+            weight,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_srv_select_reply.rs b/packet-service/src/packets/srv_srv_select_reply.rs
new file mode 100644
index 0000000..af1ae03
--- /dev/null
+++ b/packet-service/src/packets/srv_srv_select_reply.rs
@@ -0,0 +1,84 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Result {
+    Ok = 0,
+    Failed = 1,
+    Full = 2,
+    InvalidChannel = 3,
+    ChannelNotActive = 4,
+    InvalidAge = 5,
+}
+
+impl Encode for Result {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Result {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Result::Ok),
+            1 => Ok(Result::Failed),
+            2 => Ok(Result::Full),
+            3 => Ok(Result::InvalidChannel),
+            4 => Ok(Result::ChannelNotActive),
+            5 => Ok(Result::InvalidAge),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Result: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvSrvSelectReply {
+    pub(crate) result: Result,
+    pub(crate) session_id: u32,
+    pub(crate) crypt_val: u32,
+    pub(crate) ip: NullTerminatedString,
+    pub(crate) port: u16,
+}
+
+impl PacketPayload for SrvSrvSelectReply {}
+
+impl Encode for SrvSrvSelectReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        self.session_id.encode(encoder)?;
+        self.crypt_val.encode(encoder)?;
+        self.ip.encode(encoder)?;
+        self.port.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSrvSelectReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = Result::decode(decoder)?;
+        let session_id = u32::decode(decoder)?;
+        let crypt_val = u32::decode(decoder)?;
+        let ip = NullTerminatedString::decode(decoder)?;
+        let port = u16::decode(decoder)?;
+        Ok(Self {
+            result,
+            session_id,
+            crypt_val,
+            ip,
+            port,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_stat_add_reply.rs b/packet-service/src/packets/srv_stat_add_reply.rs
new file mode 100644
index 0000000..68671b0
--- /dev/null
+++ b/packet-service/src/packets/srv_stat_add_reply.rs
@@ -0,0 +1,69 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum Stat {
+    Str = 0,
+    Dex = 1,
+    Int = 2,
+    Con = 3,
+    Cha = 4,
+    Sen = 5,
+}
+
+impl Encode for Stat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for Stat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(Stat::Str),
+            1 => Ok(Stat::Dex),
+            2 => Ok(Stat::Int),
+            3 => Ok(Stat::Con),
+            4 => Ok(Stat::Cha),
+            5 => Ok(Stat::Sen),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for Stat: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvStatAddReply {
+    pub(crate) stat: Stat,
+    pub(crate) value: i16,
+}
+
+impl PacketPayload for SrvStatAddReply {}
+
+impl Encode for SrvStatAddReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.stat.encode(encoder)?;
+        self.value.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvStatAddReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let stat = Stat::decode(decoder)?;
+        let value = i16::decode(decoder)?;
+        Ok(Self { stat, value })
+    }
+}
diff --git a/packet-service/src/packets/srv_stop.rs b/packet-service/src/packets/srv_stop.rs
new file mode 100644
index 0000000..f596b74
--- /dev/null
+++ b/packet-service/src/packets/srv_stop.rs
@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvStop {
+    pub(crate) char_id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: i16,
+}
+
+impl PacketPayload for SrvStop {}
+
+impl Encode for SrvStop {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvStop {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = i16::decode(decoder)?;
+        Ok(Self { char_id, x, y, z })
+    }
+}
diff --git a/packet-service/src/packets/srv_stop_moving.rs b/packet-service/src/packets/srv_stop_moving.rs
new file mode 100644
index 0000000..1a5b4a8
--- /dev/null
+++ b/packet-service/src/packets/srv_stop_moving.rs
@@ -0,0 +1,40 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvStopMoving {
+    pub(crate) char_id: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) z: i16,
+}
+
+impl PacketPayload for SrvStopMoving {}
+
+impl Encode for SrvStopMoving {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.z.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvStopMoving {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let z = i16::decode(decoder)?;
+        Ok(Self { char_id, x, y, z })
+    }
+}
diff --git a/packet-service/src/packets/srv_store_trade_reply.rs b/packet-service/src/packets/srv_store_trade_reply.rs
new file mode 100644
index 0000000..1dedc9c
--- /dev/null
+++ b/packet-service/src/packets/srv_store_trade_reply.rs
@@ -0,0 +1,66 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum StoreTradeResult {
+    PriceDiff = 1,
+    InvalidNpc = 2,
+    TooFar = 3,
+    NoMoney = 4,
+    InvalidUnion = 5,
+    NoPoints = 6,
+}
+
+impl Encode for StoreTradeResult {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for StoreTradeResult {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            1 => Ok(StoreTradeResult::PriceDiff),
+            2 => Ok(StoreTradeResult::InvalidNpc),
+            3 => Ok(StoreTradeResult::TooFar),
+            4 => Ok(StoreTradeResult::NoMoney),
+            5 => Ok(StoreTradeResult::InvalidUnion),
+            6 => Ok(StoreTradeResult::NoPoints),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for StoreTradeResult: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvStoreTradeReply {
+    pub(crate) result: StoreTradeResult,
+}
+
+impl PacketPayload for SrvStoreTradeReply {}
+
+impl Encode for SrvStoreTradeReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.result.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvStoreTradeReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let result = StoreTradeResult::decode(decoder)?;
+        Ok(Self { result })
+    }
+}
diff --git a/packet-service/src/packets/srv_switch_server.rs b/packet-service/src/packets/srv_switch_server.rs
new file mode 100644
index 0000000..923d24a
--- /dev/null
+++ b/packet-service/src/packets/srv_switch_server.rs
@@ -0,0 +1,45 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvSwitchServer {
+    pub(crate) port: u16,
+    pub(crate) session_id: u32,
+    pub(crate) session_seed: u32,
+    pub(crate) ip: NullTerminatedString,
+}
+
+impl PacketPayload for SrvSwitchServer {}
+
+impl Encode for SrvSwitchServer {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.port.encode(encoder)?;
+        self.session_id.encode(encoder)?;
+        self.session_seed.encode(encoder)?;
+        self.ip.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvSwitchServer {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let port = u16::decode(decoder)?;
+        let session_id = u32::decode(decoder)?;
+        let session_seed = u32::decode(decoder)?;
+        let ip = NullTerminatedString::decode(decoder)?;
+        Ok(Self {
+            port,
+            session_id,
+            session_seed,
+            ip,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_teleport_reply.rs b/packet-service/src/packets/srv_teleport_reply.rs
new file mode 100644
index 0000000..77fa057
--- /dev/null
+++ b/packet-service/src/packets/srv_teleport_reply.rs
@@ -0,0 +1,53 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvTeleportReply {
+    pub(crate) id: u16,
+    pub(crate) map: u16,
+    pub(crate) x: f32,
+    pub(crate) y: f32,
+    pub(crate) move_mode: u8,
+    pub(crate) ride_mode: u8,
+}
+
+impl PacketPayload for SrvTeleportReply {}
+
+impl Encode for SrvTeleportReply {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.map.encode(encoder)?;
+        self.x.encode(encoder)?;
+        self.y.encode(encoder)?;
+        self.move_mode.encode(encoder)?;
+        self.ride_mode.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvTeleportReply {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let map = u16::decode(decoder)?;
+        let x = f32::decode(decoder)?;
+        let y = f32::decode(decoder)?;
+        let move_mode = u8::decode(decoder)?;
+        let ride_mode = u8::decode(decoder)?;
+        Ok(Self {
+            id,
+            map,
+            x,
+            y,
+            move_mode,
+            ride_mode,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_toggle_move.rs b/packet-service/src/packets/srv_toggle_move.rs
new file mode 100644
index 0000000..fed2560
--- /dev/null
+++ b/packet-service/src/packets/srv_toggle_move.rs
@@ -0,0 +1,70 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum ToggleMove {
+    Run = 0,
+    Sit = 1,
+    Drive = 2,
+}
+
+impl Encode for ToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for ToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(ToggleMove::Run),
+            1 => Ok(ToggleMove::Sit),
+            2 => Ok(ToggleMove::Drive),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for ToggleMove: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvToggleMove {
+    pub(crate) object_id: u16,
+    pub(crate) type_: ToggleMove,
+    pub(crate) run_speed: u16,
+}
+
+impl PacketPayload for SrvToggleMove {}
+
+impl Encode for SrvToggleMove {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.object_id.encode(encoder)?;
+        self.type_.encode(encoder)?;
+        self.run_speed.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvToggleMove {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let object_id = u16::decode(decoder)?;
+        let type_ = ToggleMove::decode(decoder)?;
+        let run_speed = u16::decode(decoder)?;
+        Ok(Self {
+            object_id,
+            type_,
+            run_speed,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_trade.rs b/packet-service/src/packets/srv_trade.rs
new file mode 100644
index 0000000..af158bc
--- /dev/null
+++ b/packet-service/src/packets/srv_trade.rs
@@ -0,0 +1,84 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[repr(u8)]
+#[derive(Debug, Clone)]
+pub(crate) enum TradeState {
+    Request = 0,
+    Accept = 1,
+    Reject = 2,
+    Cancel = 3,
+    Ready = 4,
+    Notready = 5,
+    Done = 6,
+    Busy = 7,
+    TooFar = 8,
+    InvalidTarget = 9,
+    NoSpace = 10,
+    TradeDisabled = 11,
+}
+
+impl Encode for TradeState {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        encoder.writer().write(&[self.clone() as u8]).map_err(Into::into)
+    }
+}
+
+impl<Context> Decode<Context> for TradeState {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let value = u8::decode(decoder)?;
+        match value {
+            0 => Ok(TradeState::Request),
+            1 => Ok(TradeState::Accept),
+            2 => Ok(TradeState::Reject),
+            3 => Ok(TradeState::Cancel),
+            4 => Ok(TradeState::Ready),
+            5 => Ok(TradeState::Notready),
+            6 => Ok(TradeState::Done),
+            7 => Ok(TradeState::Busy),
+            8 => Ok(TradeState::TooFar),
+            9 => Ok(TradeState::InvalidTarget),
+            10 => Ok(TradeState::NoSpace),
+            11 => Ok(TradeState::TradeDisabled),
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid value for TradeState: {}",
+                value
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvTrade {
+    pub(crate) state: TradeState,
+    pub(crate) target: u16,
+    pub(crate) index: u8,
+}
+
+impl PacketPayload for SrvTrade {}
+
+impl Encode for SrvTrade {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.state.encode(encoder)?;
+        self.target.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvTrade {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let state = TradeState::decode(decoder)?;
+        let target = u16::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        Ok(Self { state, target, index })
+    }
+}
diff --git a/packet-service/src/packets/srv_trade_item.rs b/packet-service/src/packets/srv_trade_item.rs
new file mode 100644
index 0000000..8aca91b
--- /dev/null
+++ b/packet-service/src/packets/srv_trade_item.rs
@@ -0,0 +1,126 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug, Clone, Default)]
+pub struct Header {
+    pub(crate) type_: u8,
+    pub(crate) id: u16,
+    pub(crate) is_created: u8,
+}
+
+impl Encode for Header {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.type_.encode(encoder)?;
+        self.id.encode(encoder)?;
+        self.is_created.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Header {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let type_ = u8::decode(decoder)?;
+        let id = u16::decode(decoder)?;
+        let is_created = u8::decode(decoder)?;
+        Ok(Self { type_, id, is_created })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Data {
+    pub(crate) gem_opt: u16,
+    pub(crate) life: u16,
+    pub(crate) durability: u8,
+    pub(crate) has_socket: u8,
+    pub(crate) is_appraised: u8,
+    pub(crate) refine: u8,
+    pub(crate) count: u32,
+}
+
+impl Encode for Data {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.gem_opt.encode(encoder)?;
+        self.life.encode(encoder)?;
+        self.durability.encode(encoder)?;
+        self.has_socket.encode(encoder)?;
+        self.is_appraised.encode(encoder)?;
+        self.refine.encode(encoder)?;
+        self.count.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Data {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let gem_opt = u16::decode(decoder)?;
+        let life = u16::decode(decoder)?;
+        let durability = u8::decode(decoder)?;
+        let has_socket = u8::decode(decoder)?;
+        let is_appraised = u8::decode(decoder)?;
+        let refine = u8::decode(decoder)?;
+        let count = u32::decode(decoder)?;
+        Ok(Self {
+            gem_opt,
+            life,
+            durability,
+            has_socket,
+            is_appraised,
+            refine,
+            count,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Item {
+    pub(crate) header: Header,
+    pub(crate) data: Data,
+}
+
+impl Encode for Item {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.header.encode(encoder)?;
+        self.data.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for Item {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let header = Header::decode(decoder)?;
+        let data = Data::decode(decoder)?;
+        Ok(Self { header, data })
+    }
+}
+
+#[derive(Debug)]
+pub struct SrvTradeItem {
+    pub(crate) slot: u8,
+    pub(crate) item: Item,
+}
+
+impl PacketPayload for SrvTradeItem {}
+
+impl Encode for SrvTradeItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.slot.encode(encoder)?;
+        self.item.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvTradeItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let slot = u8::decode(decoder)?;
+        let item = Item::decode(decoder)?;
+        Ok(Self { slot, item })
+    }
+}
diff --git a/packet-service/src/packets/srv_update_name.rs b/packet-service/src/packets/srv_update_name.rs
new file mode 100644
index 0000000..bffe687
--- /dev/null
+++ b/packet-service/src/packets/srv_update_name.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvUpdateName {
+    pub(crate) target: u16,
+    pub(crate) name: NullTerminatedString,
+}
+
+impl PacketPayload for SrvUpdateName {}
+
+impl Encode for SrvUpdateName {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.target.encode(encoder)?;
+        self.name.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvUpdateName {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let target = u16::decode(decoder)?;
+        let name = NullTerminatedString::decode(decoder)?;
+        Ok(Self { target, name })
+    }
+}
diff --git a/packet-service/src/packets/srv_update_npc.rs b/packet-service/src/packets/srv_update_npc.rs
new file mode 100644
index 0000000..ec7fa89
--- /dev/null
+++ b/packet-service/src/packets/srv_update_npc.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvUpdateNpc {
+    pub(crate) id: u16,
+    pub(crate) npc_id: i16,
+}
+
+impl PacketPayload for SrvUpdateNpc {}
+
+impl Encode for SrvUpdateNpc {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.id.encode(encoder)?;
+        self.npc_id.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvUpdateNpc {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let id = u16::decode(decoder)?;
+        let npc_id = i16::decode(decoder)?;
+        Ok(Self { id, npc_id })
+    }
+}
diff --git a/packet-service/src/packets/srv_use_item.rs b/packet-service/src/packets/srv_use_item.rs
new file mode 100644
index 0000000..b7a4b08
--- /dev/null
+++ b/packet-service/src/packets/srv_use_item.rs
@@ -0,0 +1,41 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvUseItem {
+    pub(crate) char_id: u16,
+    pub(crate) item_id: u16,
+    pub(crate) index: u8,
+}
+
+impl PacketPayload for SrvUseItem {}
+
+impl Encode for SrvUseItem {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.char_id.encode(encoder)?;
+        self.item_id.encode(encoder)?;
+        self.index.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvUseItem {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let char_id = u16::decode(decoder)?;
+        let item_id = u16::decode(decoder)?;
+        let index = u8::decode(decoder)?;
+        Ok(Self {
+            char_id,
+            item_id,
+            index,
+        })
+    }
+}
diff --git a/packet-service/src/packets/srv_whisper_chat.rs b/packet-service/src/packets/srv_whisper_chat.rs
new file mode 100644
index 0000000..bb462a6
--- /dev/null
+++ b/packet-service/src/packets/srv_whisper_chat.rs
@@ -0,0 +1,34 @@
+/* This file is @generated with IDL v0.2.2 */
+
+use crate::dataconsts::*;
+use crate::enums::*;
+use crate::packet::PacketPayload;
+use crate::types::*;
+use bincode::de::read::Reader;
+use bincode::enc::write::Writer;
+use bincode::{de::Decoder, enc::Encoder, error::DecodeError, Decode, Encode};
+use utils::null_string::NullTerminatedString;
+
+#[derive(Debug)]
+pub struct SrvWhisperChat {
+    pub(crate) sender: NullTerminatedString,
+    pub(crate) message: NullTerminatedString,
+}
+
+impl PacketPayload for SrvWhisperChat {}
+
+impl Encode for SrvWhisperChat {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> std::result::Result<(), bincode::error::EncodeError> {
+        self.sender.encode(encoder)?;
+        self.message.encode(encoder)?;
+        Ok(())
+    }
+}
+
+impl<Context> Decode<Context> for SrvWhisperChat {
+    fn decode<D: Decoder>(decoder: &mut D) -> std::result::Result<Self, bincode::error::DecodeError> {
+        let sender = NullTerminatedString::decode(decoder)?;
+        let message = NullTerminatedString::decode(decoder)?;
+        Ok(Self { sender, message })
+    }
+}