eolib 1.1.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

eolib/protocol/_generated/net/server/item_reply_server_packet.py

@@ -20,10 +20,25 @@ class ItemReplyServerPacket(Packet):
     Reply to using an item
     """
     _byte_size: int = 0
-    _item_type: ItemType = None # type: ignore [assignment]
-    _used_item: Item = None # type: ignore [assignment]
-    _weight: Weight = None # type: ignore [assignment]
-    _item_type_data: 'ItemReplyServerPacket.ItemTypeData' = None
+    _item_type: ItemType
+    _used_item: Item
+    _weight: Weight
+    _item_type_data: 'ItemReplyServerPacket.ItemTypeData'
+
+    def __init__(self, *, item_type: ItemType, used_item: Item, weight: Weight, item_type_data: 'ItemReplyServerPacket.ItemTypeData' = None):
+        """
+        Create a new instance of ItemReplyServerPacket.
+
+        Args:
+            item_type (ItemType): 
+            used_item (Item): 
+            weight (Weight): 
+            item_type_data (ItemReplyServerPacket.ItemTypeData): Data associated with the `item_type` field.
+        """
+        self._item_type = item_type
+        self._used_item = used_item
+        self._weight = weight
+        self._item_type_data = item_type_data
 
     @property
     def byte_size(self) -> int:
@@ -39,37 +54,21 @@ class ItemReplyServerPacket(Packet):
     def item_type(self) -> ItemType:
         return self._item_type
 
-    @item_type.setter
-    def item_type(self, item_type: ItemType) -> None:
-        self._item_type = item_type
-
     @property
     def used_item(self) -> Item:
         return self._used_item
 
-    @used_item.setter
-    def used_item(self, used_item: Item) -> None:
-        self._used_item = used_item
-
     @property
     def weight(self) -> Weight:
         return self._weight
 
-    @weight.setter
-    def weight(self, weight: Weight) -> None:
-        self._weight = weight
-
     @property
     def item_type_data(self) -> 'ItemReplyServerPacket.ItemTypeData':
         """
-        ItemReplyServerPacket.ItemTypeData: Gets or sets the data associated with the `item_type` field.
+        ItemReplyServerPacket.ItemTypeData: Data associated with the `item_type` field.
         """
         return self._item_type_data
 
-    @item_type_data.setter
-    def item_type_data(self, item_type_data: 'ItemReplyServerPacket.ItemTypeData') -> None:
-        self._item_type_data = item_type_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -108,35 +107,39 @@ class ItemReplyServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (ItemReplyServerPacket): The data to serialize.
         """
-        if data._item_type is None:
-            raise SerializationError("item_type must be provided.")
-        writer.add_char(int(data._item_type))
-        if data._used_item is None:
-            raise SerializationError("used_item must be provided.")
-        Item.serialize(writer, data._used_item)
-        if data._weight is None:
-            raise SerializationError("weight must be provided.")
-        Weight.serialize(writer, data._weight)
-        if data._item_type == ItemType.Heal:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHeal):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHeal for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataHeal.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.HairDye:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHairDye):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHairDye for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataHairDye.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.EffectPotion:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataEffectPotion):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataEffectPotion for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataEffectPotion.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.CureCurse:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataCureCurse):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataCureCurse for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataCureCurse.serialize(writer, data._item_type_data)
-        elif data._item_type == ItemType.ExpReward:
-            if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataExpReward):
-                raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataExpReward for item_type " + ItemType(data._item_type).name + ".")
-            ItemReplyServerPacket.ItemTypeDataExpReward.serialize(writer, data._item_type_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._item_type is None:
+                raise SerializationError("item_type must be provided.")
+            writer.add_char(int(data._item_type))
+            if data._used_item is None:
+                raise SerializationError("used_item must be provided.")
+            Item.serialize(writer, data._used_item)
+            if data._weight is None:
+                raise SerializationError("weight must be provided.")
+            Weight.serialize(writer, data._weight)
+            if data._item_type == ItemType.Heal:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHeal):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHeal for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataHeal.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.HairDye:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataHairDye):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataHairDye for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataHairDye.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.EffectPotion:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataEffectPotion):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataEffectPotion for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataEffectPotion.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.CureCurse:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataCureCurse):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataCureCurse for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataCureCurse.serialize(writer, data._item_type_data)
+            elif data._item_type == ItemType.ExpReward:
+                if not isinstance(data._item_type_data, ItemReplyServerPacket.ItemTypeDataExpReward):
+                    raise SerializationError("Expected item_type_data to be type ItemReplyServerPacket.ItemTypeDataExpReward for item_type " + ItemType(data._item_type).name + ".")
+                ItemReplyServerPacket.ItemTypeDataExpReward.serialize(writer, data._item_type_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "ItemReplyServerPacket":
@@ -149,25 +152,26 @@ class ItemReplyServerPacket(Packet):
         Returns:
             ItemReplyServerPacket: The data to serialize.
         """
-        data: ItemReplyServerPacket = ItemReplyServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._item_type = ItemType(reader.get_char())
-            data._used_item = Item.deserialize(reader)
-            data._weight = Weight.deserialize(reader)
-            if data._item_type == ItemType.Heal:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataHeal.deserialize(reader)
-            elif data._item_type == ItemType.HairDye:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataHairDye.deserialize(reader)
-            elif data._item_type == ItemType.EffectPotion:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataEffectPotion.deserialize(reader)
-            elif data._item_type == ItemType.CureCurse:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataCureCurse.deserialize(reader)
-            elif data._item_type == ItemType.ExpReward:
-                data._item_type_data = ItemReplyServerPacket.ItemTypeDataExpReward.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            item_type = ItemType(reader.get_char())
+            used_item = Item.deserialize(reader)
+            weight = Weight.deserialize(reader)
+            item_type_data: ItemReplyServerPacket.ItemTypeData = None
+            if item_type == ItemType.Heal:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataHeal.deserialize(reader)
+            elif item_type == ItemType.HairDye:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataHairDye.deserialize(reader)
+            elif item_type == ItemType.EffectPotion:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataEffectPotion.deserialize(reader)
+            elif item_type == ItemType.CureCurse:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataCureCurse.deserialize(reader)
+            elif item_type == ItemType.ExpReward:
+                item_type_data = ItemReplyServerPacket.ItemTypeDataExpReward.deserialize(reader)
+            result = ItemReplyServerPacket(item_type=item_type, used_item=used_item, weight=weight, item_type_data=item_type_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -175,19 +179,31 @@ class ItemReplyServerPacket(Packet):
         return f"ItemReplyServerPacket(byte_size={repr(self._byte_size)}, item_type={repr(self._item_type)}, used_item={repr(self._used_item)}, weight={repr(self._weight)}, item_type_data={repr(self._item_type_data)})"
 
     ItemTypeData = Union['ItemReplyServerPacket.ItemTypeDataHeal', 'ItemReplyServerPacket.ItemTypeDataHairDye', 'ItemReplyServerPacket.ItemTypeDataEffectPotion', 'ItemReplyServerPacket.ItemTypeDataCureCurse', 'ItemReplyServerPacket.ItemTypeDataExpReward', None]
-    ItemTypeData.__doc__ = \
-        """
-        Data associated with different values of the `item_type` field.
-        """
+    """
+    Data associated with different values of the `item_type` field.
+    """
 
     class ItemTypeDataHeal:
         """
         Data associated with item_type value ItemType.Heal
         """
         _byte_size: int = 0
-        _hp_gain: int = None # type: ignore [assignment]
-        _hp: int = None # type: ignore [assignment]
-        _tp: int = None # type: ignore [assignment]
+        _hp_gain: int
+        _hp: int
+        _tp: int
+
+        def __init__(self, *, hp_gain: int, hp: int, tp: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataHeal.
+
+            Args:
+                hp_gain (int): (Value range is 0-4097152080.)
+                hp (int): (Value range is 0-64008.)
+                tp (int): (Value range is 0-64008.)
+            """
+            self._hp_gain = hp_gain
+            self._hp = hp
+            self._tp = tp
 
         @property
         def byte_size(self) -> int:
@@ -201,52 +217,16 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def hp_gain(self) -> int:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
             return self._hp_gain
 
-        @hp_gain.setter
-        def hp_gain(self, hp_gain: int) -> None:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
-            self._hp_gain = hp_gain
-
         @property
         def hp(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._hp
 
-        @hp.setter
-        def hp(self, hp: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._hp = hp
-
         @property
         def tp(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._tp
 
-        @tp.setter
-        def tp(self, tp: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._tp = tp
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataHeal") -> None:
             """
@@ -256,15 +236,19 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataHeal): The data to serialize.
             """
-            if data._hp_gain is None:
-                raise SerializationError("hp_gain must be provided.")
-            writer.add_int(data._hp_gain)
-            if data._hp is None:
-                raise SerializationError("hp must be provided.")
-            writer.add_short(data._hp)
-            if data._tp is None:
-                raise SerializationError("tp must be provided.")
-            writer.add_short(data._tp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hp_gain is None:
+                    raise SerializationError("hp_gain must be provided.")
+                writer.add_int(data._hp_gain)
+                if data._hp is None:
+                    raise SerializationError("hp must be provided.")
+                writer.add_short(data._hp)
+                if data._tp is None:
+                    raise SerializationError("tp must be provided.")
+                writer.add_short(data._tp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataHeal":
@@ -277,15 +261,15 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataHeal: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataHeal = ItemReplyServerPacket.ItemTypeDataHeal()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._hp_gain = reader.get_int()
-                data._hp = reader.get_short()
-                data._tp = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                hp_gain = reader.get_int()
+                hp = reader.get_short()
+                tp = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataHeal(hp_gain=hp_gain, hp=hp, tp=tp)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -297,7 +281,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.HairDye
         """
         _byte_size: int = 0
-        _hair_color: int = None # type: ignore [assignment]
+        _hair_color: int
+
+        def __init__(self, *, hair_color: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataHairDye.
+
+            Args:
+                hair_color (int): (Value range is 0-252.)
+            """
+            self._hair_color = hair_color
 
         @property
         def byte_size(self) -> int:
@@ -311,20 +304,8 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def hair_color(self) -> int:
-            """
-            Note:
-              - Value range is 0-252.
-            """
             return self._hair_color
 
-        @hair_color.setter
-        def hair_color(self, hair_color: int) -> None:
-            """
-            Note:
-              - Value range is 0-252.
-            """
-            self._hair_color = hair_color
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataHairDye") -> None:
             """
@@ -334,9 +315,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataHairDye): The data to serialize.
             """
-            if data._hair_color is None:
-                raise SerializationError("hair_color must be provided.")
-            writer.add_char(data._hair_color)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._hair_color is None:
+                    raise SerializationError("hair_color must be provided.")
+                writer.add_char(data._hair_color)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataHairDye":
@@ -349,13 +334,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataHairDye: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataHairDye = ItemReplyServerPacket.ItemTypeDataHairDye()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._hair_color = reader.get_char()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                hair_color = reader.get_char()
+                result = ItemReplyServerPacket.ItemTypeDataHairDye(hair_color=hair_color)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -367,7 +352,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.EffectPotion
         """
         _byte_size: int = 0
-        _effect_id: int = None # type: ignore [assignment]
+        _effect_id: int
+
+        def __init__(self, *, effect_id: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataEffectPotion.
+
+            Args:
+                effect_id (int): (Value range is 0-64008.)
+            """
+            self._effect_id = effect_id
 
         @property
         def byte_size(self) -> int:
@@ -381,20 +375,8 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def effect_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._effect_id
 
-        @effect_id.setter
-        def effect_id(self, effect_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._effect_id = effect_id
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataEffectPotion") -> None:
             """
@@ -404,9 +386,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataEffectPotion): The data to serialize.
             """
-            if data._effect_id is None:
-                raise SerializationError("effect_id must be provided.")
-            writer.add_short(data._effect_id)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._effect_id is None:
+                    raise SerializationError("effect_id must be provided.")
+                writer.add_short(data._effect_id)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataEffectPotion":
@@ -419,13 +405,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataEffectPotion: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataEffectPotion = ItemReplyServerPacket.ItemTypeDataEffectPotion()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._effect_id = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                effect_id = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataEffectPotion(effect_id=effect_id)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -437,7 +423,16 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.CureCurse
         """
         _byte_size: int = 0
-        _stats: CharacterStatsEquipmentChange = None # type: ignore [assignment]
+        _stats: CharacterStatsEquipmentChange
+
+        def __init__(self, *, stats: CharacterStatsEquipmentChange):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataCureCurse.
+
+            Args:
+                stats (CharacterStatsEquipmentChange): 
+            """
+            self._stats = stats
 
         @property
         def byte_size(self) -> int:
@@ -453,10 +448,6 @@ class ItemReplyServerPacket(Packet):
         def stats(self) -> CharacterStatsEquipmentChange:
             return self._stats
 
-        @stats.setter
-        def stats(self, stats: CharacterStatsEquipmentChange) -> None:
-            self._stats = stats
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataCureCurse") -> None:
             """
@@ -466,9 +457,13 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataCureCurse): The data to serialize.
             """
-            if data._stats is None:
-                raise SerializationError("stats must be provided.")
-            CharacterStatsEquipmentChange.serialize(writer, data._stats)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._stats is None:
+                    raise SerializationError("stats must be provided.")
+                CharacterStatsEquipmentChange.serialize(writer, data._stats)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataCureCurse":
@@ -481,13 +476,13 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataCureCurse: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataCureCurse = ItemReplyServerPacket.ItemTypeDataCureCurse()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._stats = CharacterStatsEquipmentChange.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                stats = CharacterStatsEquipmentChange.deserialize(reader)
+                result = ItemReplyServerPacket.ItemTypeDataCureCurse(stats=stats)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -499,13 +494,34 @@ class ItemReplyServerPacket(Packet):
         Data associated with item_type value ItemType.ExpReward
         """
         _byte_size: int = 0
-        _experience: int = None # type: ignore [assignment]
-        _level_up: int = None # type: ignore [assignment]
-        _stat_points: int = None # type: ignore [assignment]
-        _skill_points: int = None # type: ignore [assignment]
-        _max_hp: int = None # type: ignore [assignment]
-        _max_tp: int = None # type: ignore [assignment]
-        _max_sp: int = None # type: ignore [assignment]
+        _experience: int
+        _level_up: int
+        _stat_points: int
+        _skill_points: int
+        _max_hp: int
+        _max_tp: int
+        _max_sp: int
+
+        def __init__(self, *, experience: int, level_up: int, stat_points: int, skill_points: int, max_hp: int, max_tp: int, max_sp: int):
+            """
+            Create a new instance of ItemReplyServerPacket.ItemTypeDataExpReward.
+
+            Args:
+                experience (int): (Value range is 0-4097152080.)
+                level_up (int): A value greater than 0 is "new level" and indicates the player leveled up. (Value range is 0-252.)
+                stat_points (int): (Value range is 0-64008.)
+                skill_points (int): (Value range is 0-64008.)
+                max_hp (int): (Value range is 0-64008.)
+                max_tp (int): (Value range is 0-64008.)
+                max_sp (int): (Value range is 0-64008.)
+            """
+            self._experience = experience
+            self._level_up = level_up
+            self._stat_points = stat_points
+            self._skill_points = skill_points
+            self._max_hp = max_hp
+            self._max_tp = max_tp
+            self._max_sp = max_sp
 
         @property
         def byte_size(self) -> int:
@@ -519,120 +535,35 @@ class ItemReplyServerPacket(Packet):
 
         @property
         def experience(self) -> int:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
             return self._experience
 
-        @experience.setter
-        def experience(self, experience: int) -> None:
-            """
-            Note:
-              - Value range is 0-4097152080.
-            """
-            self._experience = experience
-
         @property
         def level_up(self) -> int:
             """
-            A value greater than 0 is "new level" and indicates the player leveled up.
-
-            Note:
-              - Value range is 0-252.
+            A value greater than 0 is "new level" and indicates the player leveled up.
             """
             return self._level_up
 
-        @level_up.setter
-        def level_up(self, level_up: int) -> None:
-            """
-            A value greater than 0 is "new level" and indicates the player leveled up.
-
-            Note:
-              - Value range is 0-252.
-            """
-            self._level_up = level_up
-
         @property
         def stat_points(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._stat_points
 
-        @stat_points.setter
-        def stat_points(self, stat_points: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._stat_points = stat_points
-
         @property
         def skill_points(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._skill_points
 
-        @skill_points.setter
-        def skill_points(self, skill_points: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._skill_points = skill_points
-
         @property
         def max_hp(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._max_hp
 
-        @max_hp.setter
-        def max_hp(self, max_hp: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._max_hp = max_hp
-
         @property
         def max_tp(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._max_tp
 
-        @max_tp.setter
-        def max_tp(self, max_tp: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._max_tp = max_tp
-
         @property
         def max_sp(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._max_sp
 
-        @max_sp.setter
-        def max_sp(self, max_sp: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._max_sp = max_sp
-
         @staticmethod
         def serialize(writer: EoWriter, data: "ItemReplyServerPacket.ItemTypeDataExpReward") -> None:
             """
@@ -642,27 +573,31 @@ class ItemReplyServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (ItemReplyServerPacket.ItemTypeDataExpReward): The data to serialize.
             """
-            if data._experience is None:
-                raise SerializationError("experience must be provided.")
-            writer.add_int(data._experience)
-            if data._level_up is None:
-                raise SerializationError("level_up must be provided.")
-            writer.add_char(data._level_up)
-            if data._stat_points is None:
-                raise SerializationError("stat_points must be provided.")
-            writer.add_short(data._stat_points)
-            if data._skill_points is None:
-                raise SerializationError("skill_points must be provided.")
-            writer.add_short(data._skill_points)
-            if data._max_hp is None:
-                raise SerializationError("max_hp must be provided.")
-            writer.add_short(data._max_hp)
-            if data._max_tp is None:
-                raise SerializationError("max_tp must be provided.")
-            writer.add_short(data._max_tp)
-            if data._max_sp is None:
-                raise SerializationError("max_sp must be provided.")
-            writer.add_short(data._max_sp)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._experience is None:
+                    raise SerializationError("experience must be provided.")
+                writer.add_int(data._experience)
+                if data._level_up is None:
+                    raise SerializationError("level_up must be provided.")
+                writer.add_char(data._level_up)
+                if data._stat_points is None:
+                    raise SerializationError("stat_points must be provided.")
+                writer.add_short(data._stat_points)
+                if data._skill_points is None:
+                    raise SerializationError("skill_points must be provided.")
+                writer.add_short(data._skill_points)
+                if data._max_hp is None:
+                    raise SerializationError("max_hp must be provided.")
+                writer.add_short(data._max_hp)
+                if data._max_tp is None:
+                    raise SerializationError("max_tp must be provided.")
+                writer.add_short(data._max_tp)
+                if data._max_sp is None:
+                    raise SerializationError("max_sp must be provided.")
+                writer.add_short(data._max_sp)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "ItemReplyServerPacket.ItemTypeDataExpReward":
@@ -675,19 +610,19 @@ class ItemReplyServerPacket(Packet):
             Returns:
                 ItemReplyServerPacket.ItemTypeDataExpReward: The data to serialize.
             """
-            data: ItemReplyServerPacket.ItemTypeDataExpReward = ItemReplyServerPacket.ItemTypeDataExpReward()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._experience = reader.get_int()
-                data._level_up = reader.get_char()
-                data._stat_points = reader.get_short()
-                data._skill_points = reader.get_short()
-                data._max_hp = reader.get_short()
-                data._max_tp = reader.get_short()
-                data._max_sp = reader.get_short()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                experience = reader.get_int()
+                level_up = reader.get_char()
+                stat_points = reader.get_short()
+                skill_points = reader.get_short()
+                max_hp = reader.get_short()
+                max_tp = reader.get_short()
+                max_sp = reader.get_short()
+                result = ItemReplyServerPacket.ItemTypeDataExpReward(experience=experience, level_up=level_up, stat_points=stat_points, skill_points=skill_points, max_hp=max_hp, max_tp=max_tp, max_sp=max_sp)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode