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

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

@@ -24,8 +24,19 @@ class InitInitServerPacket(Packet):
     This packet is unencrypted.
     """
     _byte_size: int = 0
-    _reply_code: InitReply = None # type: ignore [assignment]
-    _reply_code_data: 'InitInitServerPacket.ReplyCodeData' = None
+    _reply_code: InitReply
+    _reply_code_data: 'InitInitServerPacket.ReplyCodeData'
+
+    def __init__(self, *, reply_code: InitReply, reply_code_data: 'InitInitServerPacket.ReplyCodeData' = None):
+        """
+        Create a new instance of InitInitServerPacket.
+
+        Args:
+            reply_code (InitReply): 
+            reply_code_data (InitInitServerPacket.ReplyCodeData): Data associated with the `reply_code` field.
+        """
+        self._reply_code = reply_code
+        self._reply_code_data = reply_code_data
 
     @property
     def byte_size(self) -> int:
@@ -41,21 +52,13 @@ class InitInitServerPacket(Packet):
     def reply_code(self) -> InitReply:
         return self._reply_code
 
-    @reply_code.setter
-    def reply_code(self, reply_code: InitReply) -> None:
-        self._reply_code = reply_code
-
     @property
     def reply_code_data(self) -> 'InitInitServerPacket.ReplyCodeData':
         """
-        InitInitServerPacket.ReplyCodeData: Gets or sets the data associated with the `reply_code` field.
+        InitInitServerPacket.ReplyCodeData: Data associated with the `reply_code` field.
         """
         return self._reply_code_data
 
-    @reply_code_data.setter
-    def reply_code_data(self, reply_code_data: 'InitInitServerPacket.ReplyCodeData') -> None:
-        self._reply_code_data = reply_code_data
-
     @staticmethod
     def family() -> PacketFamily:
         """
@@ -94,57 +97,61 @@ class InitInitServerPacket(Packet):
             writer (EoWriter): The writer that the data will be serialized to.
             data (InitInitServerPacket): The data to serialize.
         """
-        if data._reply_code is None:
-            raise SerializationError("reply_code must be provided.")
-        writer.add_byte(int(data._reply_code))
-        if data._reply_code == InitReply.OutOfDate:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOutOfDate):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOutOfDate for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataOutOfDate.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.Ok:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOk):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOk for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.Banned:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataBanned):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataBanned for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.WarpMap:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataWarpMap):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataWarpMap for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataWarpMap.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEmf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEmf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEmf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEmf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEif:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEif):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEif for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEif.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEnf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEnf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEnf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEnf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEsf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEsf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEsf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEsf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.FileEcf:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEcf):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEcf for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataFileEcf.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.MapMutation:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataMapMutation):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataMapMutation for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataMapMutation.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.PlayersList:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersList):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersList for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataPlayersList.serialize(writer, data._reply_code_data)
-        elif data._reply_code == InitReply.PlayersListFriends:
-            if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersListFriends):
-                raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersListFriends for reply_code " + InitReply(data._reply_code).name + ".")
-            InitInitServerPacket.ReplyCodeDataPlayersListFriends.serialize(writer, data._reply_code_data)
+        old_string_sanitization_mode: bool = writer.string_sanitization_mode
+        try:
+            if data._reply_code is None:
+                raise SerializationError("reply_code must be provided.")
+            writer.add_byte(int(data._reply_code))
+            if data._reply_code == InitReply.OutOfDate:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOutOfDate):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOutOfDate for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataOutOfDate.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.Ok:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataOk):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataOk for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataOk.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.Banned:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataBanned):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataBanned for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataBanned.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.WarpMap:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataWarpMap):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataWarpMap for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataWarpMap.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEmf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEmf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEmf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEmf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEif:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEif):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEif for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEif.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEnf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEnf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEnf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEnf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEsf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEsf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEsf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEsf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.FileEcf:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataFileEcf):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataFileEcf for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataFileEcf.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.MapMutation:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataMapMutation):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataMapMutation for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataMapMutation.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.PlayersList:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersList):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersList for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataPlayersList.serialize(writer, data._reply_code_data)
+            elif data._reply_code == InitReply.PlayersListFriends:
+                if not isinstance(data._reply_code_data, InitInitServerPacket.ReplyCodeDataPlayersListFriends):
+                    raise SerializationError("Expected reply_code_data to be type InitInitServerPacket.ReplyCodeDataPlayersListFriends for reply_code " + InitReply(data._reply_code).name + ".")
+                InitInitServerPacket.ReplyCodeDataPlayersListFriends.serialize(writer, data._reply_code_data)
+        finally:
+            writer.string_sanitization_mode = old_string_sanitization_mode
 
     @staticmethod
     def deserialize(reader: EoReader) -> "InitInitServerPacket":
@@ -157,37 +164,38 @@ class InitInitServerPacket(Packet):
         Returns:
             InitInitServerPacket: The data to serialize.
         """
-        data: InitInitServerPacket = InitInitServerPacket()
         old_chunked_reading_mode: bool = reader.chunked_reading_mode
         try:
             reader_start_position: int = reader.position
-            data._reply_code = InitReply(reader.get_byte())
-            if data._reply_code == InitReply.OutOfDate:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataOutOfDate.deserialize(reader)
-            elif data._reply_code == InitReply.Ok:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataOk.deserialize(reader)
-            elif data._reply_code == InitReply.Banned:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataBanned.deserialize(reader)
-            elif data._reply_code == InitReply.WarpMap:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataWarpMap.deserialize(reader)
-            elif data._reply_code == InitReply.FileEmf:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataFileEmf.deserialize(reader)
-            elif data._reply_code == InitReply.FileEif:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataFileEif.deserialize(reader)
-            elif data._reply_code == InitReply.FileEnf:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataFileEnf.deserialize(reader)
-            elif data._reply_code == InitReply.FileEsf:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataFileEsf.deserialize(reader)
-            elif data._reply_code == InitReply.FileEcf:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataFileEcf.deserialize(reader)
-            elif data._reply_code == InitReply.MapMutation:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataMapMutation.deserialize(reader)
-            elif data._reply_code == InitReply.PlayersList:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataPlayersList.deserialize(reader)
-            elif data._reply_code == InitReply.PlayersListFriends:
-                data._reply_code_data = InitInitServerPacket.ReplyCodeDataPlayersListFriends.deserialize(reader)
-            data._byte_size = reader.position - reader_start_position
-            return data
+            reply_code = InitReply(reader.get_byte())
+            reply_code_data: InitInitServerPacket.ReplyCodeData = None
+            if reply_code == InitReply.OutOfDate:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataOutOfDate.deserialize(reader)
+            elif reply_code == InitReply.Ok:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataOk.deserialize(reader)
+            elif reply_code == InitReply.Banned:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataBanned.deserialize(reader)
+            elif reply_code == InitReply.WarpMap:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataWarpMap.deserialize(reader)
+            elif reply_code == InitReply.FileEmf:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataFileEmf.deserialize(reader)
+            elif reply_code == InitReply.FileEif:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataFileEif.deserialize(reader)
+            elif reply_code == InitReply.FileEnf:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataFileEnf.deserialize(reader)
+            elif reply_code == InitReply.FileEsf:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataFileEsf.deserialize(reader)
+            elif reply_code == InitReply.FileEcf:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataFileEcf.deserialize(reader)
+            elif reply_code == InitReply.MapMutation:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataMapMutation.deserialize(reader)
+            elif reply_code == InitReply.PlayersList:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataPlayersList.deserialize(reader)
+            elif reply_code == InitReply.PlayersListFriends:
+                reply_code_data = InitInitServerPacket.ReplyCodeDataPlayersListFriends.deserialize(reader)
+            result = InitInitServerPacket(reply_code=reply_code, reply_code_data=reply_code_data)
+            result._byte_size = reader.position - reader_start_position
+            return result
         finally:
             reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -195,17 +203,25 @@ class InitInitServerPacket(Packet):
         return f"InitInitServerPacket(byte_size={repr(self._byte_size)}, reply_code={repr(self._reply_code)}, reply_code_data={repr(self._reply_code_data)})"
 
     ReplyCodeData = Union['InitInitServerPacket.ReplyCodeDataOutOfDate', 'InitInitServerPacket.ReplyCodeDataOk', 'InitInitServerPacket.ReplyCodeDataBanned', 'InitInitServerPacket.ReplyCodeDataWarpMap', 'InitInitServerPacket.ReplyCodeDataFileEmf', 'InitInitServerPacket.ReplyCodeDataFileEif', 'InitInitServerPacket.ReplyCodeDataFileEnf', 'InitInitServerPacket.ReplyCodeDataFileEsf', 'InitInitServerPacket.ReplyCodeDataFileEcf', 'InitInitServerPacket.ReplyCodeDataMapMutation', 'InitInitServerPacket.ReplyCodeDataPlayersList', 'InitInitServerPacket.ReplyCodeDataPlayersListFriends', None]
-    ReplyCodeData.__doc__ = \
-        """
-        Data associated with different values of the `reply_code` field.
-        """
+    """
+    Data associated with different values of the `reply_code` field.
+    """
 
     class ReplyCodeDataOutOfDate:
         """
         Data associated with reply_code value InitReply.OutOfDate
         """
         _byte_size: int = 0
-        _version: Version = None # type: ignore [assignment]
+        _version: Version
+
+        def __init__(self, *, version: Version):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataOutOfDate.
+
+            Args:
+                version (Version): 
+            """
+            self._version = version
 
         @property
         def byte_size(self) -> int:
@@ -221,10 +237,6 @@ class InitInitServerPacket(Packet):
         def version(self) -> Version:
             return self._version
 
-        @version.setter
-        def version(self, version: Version) -> None:
-            self._version = version
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataOutOfDate") -> None:
             """
@@ -234,9 +246,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataOutOfDate): The data to serialize.
             """
-            if data._version is None:
-                raise SerializationError("version must be provided.")
-            Version.serialize(writer, data._version)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._version is None:
+                    raise SerializationError("version must be provided.")
+                Version.serialize(writer, data._version)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataOutOfDate":
@@ -249,13 +265,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataOutOfDate: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataOutOfDate = InitInitServerPacket.ReplyCodeDataOutOfDate()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._version = Version.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                version = Version.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataOutOfDate(version=version)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -267,12 +283,31 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.Ok
         """
         _byte_size: int = 0
-        _seq1: int = None # type: ignore [assignment]
-        _seq2: int = None # type: ignore [assignment]
-        _server_encryption_multiple: int = None # type: ignore [assignment]
-        _client_encryption_multiple: int = None # type: ignore [assignment]
-        _player_id: int = None # type: ignore [assignment]
-        _challenge_response: int = None # type: ignore [assignment]
+        _seq1: int
+        _seq2: int
+        _server_encryption_multiple: int
+        _client_encryption_multiple: int
+        _player_id: int
+        _challenge_response: int
+
+        def __init__(self, *, seq1: int, seq2: int, server_encryption_multiple: int, client_encryption_multiple: int, player_id: int, challenge_response: int):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataOk.
+
+            Args:
+                seq1 (int): (Value range is 0-255.)
+                seq2 (int): (Value range is 0-255.)
+                server_encryption_multiple (int): (Value range is 0-255.)
+                client_encryption_multiple (int): (Value range is 0-255.)
+                player_id (int): (Value range is 0-64008.)
+                challenge_response (int): (Value range is 0-16194276.)
+            """
+            self._seq1 = seq1
+            self._seq2 = seq2
+            self._server_encryption_multiple = server_encryption_multiple
+            self._client_encryption_multiple = client_encryption_multiple
+            self._player_id = player_id
+            self._challenge_response = challenge_response
 
         @property
         def byte_size(self) -> int:
@@ -286,100 +321,28 @@ class InitInitServerPacket(Packet):
 
         @property
         def seq1(self) -> int:
-            """
-            Note:
-              - Value range is 0-255.
-            """
             return self._seq1
 
-        @seq1.setter
-        def seq1(self, seq1: int) -> None:
-            """
-            Note:
-              - Value range is 0-255.
-            """
-            self._seq1 = seq1
-
         @property
         def seq2(self) -> int:
-            """
-            Note:
-              - Value range is 0-255.
-            """
             return self._seq2
 
-        @seq2.setter
-        def seq2(self, seq2: int) -> None:
-            """
-            Note:
-              - Value range is 0-255.
-            """
-            self._seq2 = seq2
-
         @property
         def server_encryption_multiple(self) -> int:
-            """
-            Note:
-              - Value range is 0-255.
-            """
             return self._server_encryption_multiple
 
-        @server_encryption_multiple.setter
-        def server_encryption_multiple(self, server_encryption_multiple: int) -> None:
-            """
-            Note:
-              - Value range is 0-255.
-            """
-            self._server_encryption_multiple = server_encryption_multiple
-
         @property
         def client_encryption_multiple(self) -> int:
-            """
-            Note:
-              - Value range is 0-255.
-            """
             return self._client_encryption_multiple
 
-        @client_encryption_multiple.setter
-        def client_encryption_multiple(self, client_encryption_multiple: int) -> None:
-            """
-            Note:
-              - Value range is 0-255.
-            """
-            self._client_encryption_multiple = client_encryption_multiple
-
         @property
         def player_id(self) -> int:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
             return self._player_id
 
-        @player_id.setter
-        def player_id(self, player_id: int) -> None:
-            """
-            Note:
-              - Value range is 0-64008.
-            """
-            self._player_id = player_id
-
         @property
         def challenge_response(self) -> int:
-            """
-            Note:
-              - Value range is 0-16194276.
-            """
             return self._challenge_response
 
-        @challenge_response.setter
-        def challenge_response(self, challenge_response: int) -> None:
-            """
-            Note:
-              - Value range is 0-16194276.
-            """
-            self._challenge_response = challenge_response
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataOk") -> None:
             """
@@ -389,24 +352,28 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataOk): The data to serialize.
             """
-            if data._seq1 is None:
-                raise SerializationError("seq1 must be provided.")
-            writer.add_byte(data._seq1)
-            if data._seq2 is None:
-                raise SerializationError("seq2 must be provided.")
-            writer.add_byte(data._seq2)
-            if data._server_encryption_multiple is None:
-                raise SerializationError("server_encryption_multiple must be provided.")
-            writer.add_byte(data._server_encryption_multiple)
-            if data._client_encryption_multiple is None:
-                raise SerializationError("client_encryption_multiple must be provided.")
-            writer.add_byte(data._client_encryption_multiple)
-            if data._player_id is None:
-                raise SerializationError("player_id must be provided.")
-            writer.add_short(data._player_id)
-            if data._challenge_response is None:
-                raise SerializationError("challenge_response must be provided.")
-            writer.add_three(data._challenge_response)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._seq1 is None:
+                    raise SerializationError("seq1 must be provided.")
+                writer.add_byte(data._seq1)
+                if data._seq2 is None:
+                    raise SerializationError("seq2 must be provided.")
+                writer.add_byte(data._seq2)
+                if data._server_encryption_multiple is None:
+                    raise SerializationError("server_encryption_multiple must be provided.")
+                writer.add_byte(data._server_encryption_multiple)
+                if data._client_encryption_multiple is None:
+                    raise SerializationError("client_encryption_multiple must be provided.")
+                writer.add_byte(data._client_encryption_multiple)
+                if data._player_id is None:
+                    raise SerializationError("player_id must be provided.")
+                writer.add_short(data._player_id)
+                if data._challenge_response is None:
+                    raise SerializationError("challenge_response must be provided.")
+                writer.add_three(data._challenge_response)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataOk":
@@ -419,18 +386,18 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataOk: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataOk = InitInitServerPacket.ReplyCodeDataOk()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._seq1 = reader.get_byte()
-                data._seq2 = reader.get_byte()
-                data._server_encryption_multiple = reader.get_byte()
-                data._client_encryption_multiple = reader.get_byte()
-                data._player_id = reader.get_short()
-                data._challenge_response = reader.get_three()
-                data._byte_size = reader.position - reader_start_position
-                return data
+                seq1 = reader.get_byte()
+                seq2 = reader.get_byte()
+                server_encryption_multiple = reader.get_byte()
+                client_encryption_multiple = reader.get_byte()
+                player_id = reader.get_short()
+                challenge_response = reader.get_three()
+                result = InitInitServerPacket.ReplyCodeDataOk(seq1=seq1, seq2=seq2, server_encryption_multiple=server_encryption_multiple, client_encryption_multiple=client_encryption_multiple, player_id=player_id, challenge_response=challenge_response)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -442,8 +409,19 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.Banned
         """
         _byte_size: int = 0
-        _ban_type: InitBanType = None # type: ignore [assignment]
-        _ban_type_data: 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeData' = None
+        _ban_type: InitBanType
+        _ban_type_data: 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeData'
+
+        def __init__(self, *, ban_type: InitBanType, ban_type_data: 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeData' = None):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataBanned.
+
+            Args:
+                ban_type (InitBanType): 
+                ban_type_data (InitInitServerPacket.ReplyCodeDataBanned.BanTypeData): Data associated with the `ban_type` field.
+            """
+            self._ban_type = ban_type
+            self._ban_type_data = ban_type_data
 
         @property
         def byte_size(self) -> int:
@@ -459,21 +437,13 @@ class InitInitServerPacket(Packet):
         def ban_type(self) -> InitBanType:
             return self._ban_type
 
-        @ban_type.setter
-        def ban_type(self, ban_type: InitBanType) -> None:
-            self._ban_type = ban_type
-
         @property
         def ban_type_data(self) -> 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeData':
             """
-            InitInitServerPacket.ReplyCodeDataBanned.BanTypeData: Gets or sets the data associated with the `ban_type` field.
+            InitInitServerPacket.ReplyCodeDataBanned.BanTypeData: Data associated with the `ban_type` field.
             """
             return self._ban_type_data
 
-        @ban_type_data.setter
-        def ban_type_data(self, ban_type_data: 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeData') -> None:
-            self._ban_type_data = ban_type_data
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataBanned") -> None:
             """
@@ -483,17 +453,21 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataBanned): The data to serialize.
             """
-            if data._ban_type is None:
-                raise SerializationError("ban_type must be provided.")
-            writer.add_byte(int(data._ban_type))
-            if data._ban_type == 0:
-                if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0):
-                    raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0 for ban_type " + InitBanType(data._ban_type).name + ".")
-                InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.serialize(writer, data._ban_type_data)
-            elif data._ban_type == InitBanType.Temporary:
-                if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary):
-                    raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary for ban_type " + InitBanType(data._ban_type).name + ".")
-                InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.serialize(writer, data._ban_type_data)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._ban_type is None:
+                    raise SerializationError("ban_type must be provided.")
+                writer.add_byte(int(data._ban_type))
+                if data._ban_type == 0:
+                    if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0):
+                        raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0 for ban_type " + InitBanType(data._ban_type).name + ".")
+                    InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.serialize(writer, data._ban_type_data)
+                elif data._ban_type == InitBanType.Temporary:
+                    if not isinstance(data._ban_type_data, InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary):
+                        raise SerializationError("Expected ban_type_data to be type InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary for ban_type " + InitBanType(data._ban_type).name + ".")
+                    InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.serialize(writer, data._ban_type_data)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned":
@@ -506,17 +480,18 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataBanned: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataBanned = InitInitServerPacket.ReplyCodeDataBanned()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._ban_type = InitBanType(reader.get_byte())
-                if data._ban_type == 0:
-                    data._ban_type_data = InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.deserialize(reader)
-                elif data._ban_type == InitBanType.Temporary:
-                    data._ban_type_data = InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                ban_type = InitBanType(reader.get_byte())
+                ban_type_data: InitInitServerPacket.ReplyCodeDataBanned.BanTypeData = None
+                if ban_type == 0:
+                    ban_type_data = InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.deserialize(reader)
+                elif ban_type == InitBanType.Temporary:
+                    ban_type_data = InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataBanned(ban_type=ban_type, ban_type_data=ban_type_data)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -524,10 +499,9 @@ class InitInitServerPacket(Packet):
             return f"InitInitServerPacket.ReplyCodeDataBanned(byte_size={repr(self._byte_size)}, ban_type={repr(self._ban_type)}, ban_type_data={repr(self._ban_type_data)})"
 
         BanTypeData = Union['InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0', 'InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary', None]
-        BanTypeData.__doc__ = \
-            """
-            Data associated with different values of the `ban_type` field.
-            """
+        """
+        Data associated with different values of the `ban_type` field.
+        """
 
         class BanTypeData0:
             """
@@ -538,7 +512,16 @@ class InitInitServerPacket(Packet):
             erroneously send 0.
             """
             _byte_size: int = 0
-            _minutes_remaining: int = None # type: ignore [assignment]
+            _minutes_remaining: int
+
+            def __init__(self, *, minutes_remaining: int):
+                """
+                Create a new instance of InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0.
+
+                Args:
+                    minutes_remaining (int): (Value range is 0-255.)
+                """
+                self._minutes_remaining = minutes_remaining
 
             @property
             def byte_size(self) -> int:
@@ -552,20 +535,8 @@ class InitInitServerPacket(Packet):
 
             @property
             def minutes_remaining(self) -> int:
-                """
-                Note:
-                  - Value range is 0-255.
-                """
                 return self._minutes_remaining
 
-            @minutes_remaining.setter
-            def minutes_remaining(self, minutes_remaining: int) -> None:
-                """
-                Note:
-                  - Value range is 0-255.
-                """
-                self._minutes_remaining = minutes_remaining
-
             @staticmethod
             def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0") -> None:
                 """
@@ -575,9 +546,13 @@ class InitInitServerPacket(Packet):
                     writer (EoWriter): The writer that the data will be serialized to.
                     data (InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0): The data to serialize.
                 """
-                if data._minutes_remaining is None:
-                    raise SerializationError("minutes_remaining must be provided.")
-                writer.add_byte(data._minutes_remaining)
+                old_string_sanitization_mode: bool = writer.string_sanitization_mode
+                try:
+                    if data._minutes_remaining is None:
+                        raise SerializationError("minutes_remaining must be provided.")
+                    writer.add_byte(data._minutes_remaining)
+                finally:
+                    writer.string_sanitization_mode = old_string_sanitization_mode
 
             @staticmethod
             def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0":
@@ -590,13 +565,13 @@ class InitInitServerPacket(Packet):
                 Returns:
                     InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0: The data to serialize.
                 """
-                data: InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0 = InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0()
                 old_chunked_reading_mode: bool = reader.chunked_reading_mode
                 try:
                     reader_start_position: int = reader.position
-                    data._minutes_remaining = reader.get_byte()
-                    data._byte_size = reader.position - reader_start_position
-                    return data
+                    minutes_remaining = reader.get_byte()
+                    result = InitInitServerPacket.ReplyCodeDataBanned.BanTypeData0(minutes_remaining=minutes_remaining)
+                    result._byte_size = reader.position - reader_start_position
+                    return result
                 finally:
                     reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -608,7 +583,16 @@ class InitInitServerPacket(Packet):
             Data associated with ban_type value InitBanType.Temporary
             """
             _byte_size: int = 0
-            _minutes_remaining: int = None # type: ignore [assignment]
+            _minutes_remaining: int
+
+            def __init__(self, *, minutes_remaining: int):
+                """
+                Create a new instance of InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary.
+
+                Args:
+                    minutes_remaining (int): (Value range is 0-255.)
+                """
+                self._minutes_remaining = minutes_remaining
 
             @property
             def byte_size(self) -> int:
@@ -622,20 +606,8 @@ class InitInitServerPacket(Packet):
 
             @property
             def minutes_remaining(self) -> int:
-                """
-                Note:
-                  - Value range is 0-255.
-                """
                 return self._minutes_remaining
 
-            @minutes_remaining.setter
-            def minutes_remaining(self, minutes_remaining: int) -> None:
-                """
-                Note:
-                  - Value range is 0-255.
-                """
-                self._minutes_remaining = minutes_remaining
-
             @staticmethod
             def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary") -> None:
                 """
@@ -645,9 +617,13 @@ class InitInitServerPacket(Packet):
                     writer (EoWriter): The writer that the data will be serialized to.
                     data (InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary): The data to serialize.
                 """
-                if data._minutes_remaining is None:
-                    raise SerializationError("minutes_remaining must be provided.")
-                writer.add_byte(data._minutes_remaining)
+                old_string_sanitization_mode: bool = writer.string_sanitization_mode
+                try:
+                    if data._minutes_remaining is None:
+                        raise SerializationError("minutes_remaining must be provided.")
+                    writer.add_byte(data._minutes_remaining)
+                finally:
+                    writer.string_sanitization_mode = old_string_sanitization_mode
 
             @staticmethod
             def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary":
@@ -660,13 +636,13 @@ class InitInitServerPacket(Packet):
                 Returns:
                     InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary: The data to serialize.
                 """
-                data: InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary = InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary()
                 old_chunked_reading_mode: bool = reader.chunked_reading_mode
                 try:
                     reader_start_position: int = reader.position
-                    data._minutes_remaining = reader.get_byte()
-                    data._byte_size = reader.position - reader_start_position
-                    return data
+                    minutes_remaining = reader.get_byte()
+                    result = InitInitServerPacket.ReplyCodeDataBanned.BanTypeDataTemporary(minutes_remaining=minutes_remaining)
+                    result._byte_size = reader.position - reader_start_position
+                    return result
                 finally:
                     reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -678,7 +654,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.WarpMap
         """
         _byte_size: int = 0
-        _map_file: MapFile = None # type: ignore [assignment]
+        _map_file: MapFile
+
+        def __init__(self, *, map_file: MapFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataWarpMap.
+
+            Args:
+                map_file (MapFile): 
+            """
+            self._map_file = map_file
 
         @property
         def byte_size(self) -> int:
@@ -694,10 +679,6 @@ class InitInitServerPacket(Packet):
         def map_file(self) -> MapFile:
             return self._map_file
 
-        @map_file.setter
-        def map_file(self, map_file: MapFile) -> None:
-            self._map_file = map_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataWarpMap") -> None:
             """
@@ -707,9 +688,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataWarpMap): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataWarpMap":
@@ -722,13 +707,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataWarpMap: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataWarpMap = InitInitServerPacket.ReplyCodeDataWarpMap()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_file = MapFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                map_file = MapFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataWarpMap(map_file=map_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -740,7 +725,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.FileEmf
         """
         _byte_size: int = 0
-        _map_file: MapFile = None # type: ignore [assignment]
+        _map_file: MapFile
+
+        def __init__(self, *, map_file: MapFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataFileEmf.
+
+            Args:
+                map_file (MapFile): 
+            """
+            self._map_file = map_file
 
         @property
         def byte_size(self) -> int:
@@ -756,10 +750,6 @@ class InitInitServerPacket(Packet):
         def map_file(self) -> MapFile:
             return self._map_file
 
-        @map_file.setter
-        def map_file(self, map_file: MapFile) -> None:
-            self._map_file = map_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataFileEmf") -> None:
             """
@@ -769,9 +759,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEmf): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEmf":
@@ -784,13 +778,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataFileEmf: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataFileEmf = InitInitServerPacket.ReplyCodeDataFileEmf()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_file = MapFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                map_file = MapFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataFileEmf(map_file=map_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -802,7 +796,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.FileEif
         """
         _byte_size: int = 0
-        _pub_file: PubFile = None # type: ignore [assignment]
+        _pub_file: PubFile
+
+        def __init__(self, *, pub_file: PubFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataFileEif.
+
+            Args:
+                pub_file (PubFile): 
+            """
+            self._pub_file = pub_file
 
         @property
         def byte_size(self) -> int:
@@ -818,10 +821,6 @@ class InitInitServerPacket(Packet):
         def pub_file(self) -> PubFile:
             return self._pub_file
 
-        @pub_file.setter
-        def pub_file(self, pub_file: PubFile) -> None:
-            self._pub_file = pub_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataFileEif") -> None:
             """
@@ -831,9 +830,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEif): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEif":
@@ -846,13 +849,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataFileEif: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataFileEif = InitInitServerPacket.ReplyCodeDataFileEif()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._pub_file = PubFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                pub_file = PubFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataFileEif(pub_file=pub_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -864,7 +867,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.FileEnf
         """
         _byte_size: int = 0
-        _pub_file: PubFile = None # type: ignore [assignment]
+        _pub_file: PubFile
+
+        def __init__(self, *, pub_file: PubFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataFileEnf.
+
+            Args:
+                pub_file (PubFile): 
+            """
+            self._pub_file = pub_file
 
         @property
         def byte_size(self) -> int:
@@ -880,10 +892,6 @@ class InitInitServerPacket(Packet):
         def pub_file(self) -> PubFile:
             return self._pub_file
 
-        @pub_file.setter
-        def pub_file(self, pub_file: PubFile) -> None:
-            self._pub_file = pub_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataFileEnf") -> None:
             """
@@ -893,9 +901,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEnf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEnf":
@@ -908,13 +920,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataFileEnf: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataFileEnf = InitInitServerPacket.ReplyCodeDataFileEnf()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._pub_file = PubFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                pub_file = PubFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataFileEnf(pub_file=pub_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -926,7 +938,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.FileEsf
         """
         _byte_size: int = 0
-        _pub_file: PubFile = None # type: ignore [assignment]
+        _pub_file: PubFile
+
+        def __init__(self, *, pub_file: PubFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataFileEsf.
+
+            Args:
+                pub_file (PubFile): 
+            """
+            self._pub_file = pub_file
 
         @property
         def byte_size(self) -> int:
@@ -942,10 +963,6 @@ class InitInitServerPacket(Packet):
         def pub_file(self) -> PubFile:
             return self._pub_file
 
-        @pub_file.setter
-        def pub_file(self, pub_file: PubFile) -> None:
-            self._pub_file = pub_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataFileEsf") -> None:
             """
@@ -955,9 +972,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEsf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEsf":
@@ -970,13 +991,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataFileEsf: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataFileEsf = InitInitServerPacket.ReplyCodeDataFileEsf()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._pub_file = PubFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                pub_file = PubFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataFileEsf(pub_file=pub_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -988,7 +1009,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.FileEcf
         """
         _byte_size: int = 0
-        _pub_file: PubFile = None # type: ignore [assignment]
+        _pub_file: PubFile
+
+        def __init__(self, *, pub_file: PubFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataFileEcf.
+
+            Args:
+                pub_file (PubFile): 
+            """
+            self._pub_file = pub_file
 
         @property
         def byte_size(self) -> int:
@@ -1004,10 +1034,6 @@ class InitInitServerPacket(Packet):
         def pub_file(self) -> PubFile:
             return self._pub_file
 
-        @pub_file.setter
-        def pub_file(self, pub_file: PubFile) -> None:
-            self._pub_file = pub_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataFileEcf") -> None:
             """
@@ -1017,9 +1043,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataFileEcf): The data to serialize.
             """
-            if data._pub_file is None:
-                raise SerializationError("pub_file must be provided.")
-            PubFile.serialize(writer, data._pub_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._pub_file is None:
+                    raise SerializationError("pub_file must be provided.")
+                PubFile.serialize(writer, data._pub_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataFileEcf":
@@ -1032,13 +1062,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataFileEcf: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataFileEcf = InitInitServerPacket.ReplyCodeDataFileEcf()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._pub_file = PubFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                pub_file = PubFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataFileEcf(pub_file=pub_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -1050,7 +1080,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.MapMutation
         """
         _byte_size: int = 0
-        _map_file: MapFile = None # type: ignore [assignment]
+        _map_file: MapFile
+
+        def __init__(self, *, map_file: MapFile):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataMapMutation.
+
+            Args:
+                map_file (MapFile): 
+            """
+            self._map_file = map_file
 
         @property
         def byte_size(self) -> int:
@@ -1066,10 +1105,6 @@ class InitInitServerPacket(Packet):
         def map_file(self) -> MapFile:
             return self._map_file
 
-        @map_file.setter
-        def map_file(self, map_file: MapFile) -> None:
-            self._map_file = map_file
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataMapMutation") -> None:
             """
@@ -1079,9 +1114,13 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataMapMutation): The data to serialize.
             """
-            if data._map_file is None:
-                raise SerializationError("map_file must be provided.")
-            MapFile.serialize(writer, data._map_file)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                if data._map_file is None:
+                    raise SerializationError("map_file must be provided.")
+                MapFile.serialize(writer, data._map_file)
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataMapMutation":
@@ -1094,13 +1133,13 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataMapMutation: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataMapMutation = InitInitServerPacket.ReplyCodeDataMapMutation()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
-                data._map_file = MapFile.deserialize(reader)
-                data._byte_size = reader.position - reader_start_position
-                return data
+                map_file = MapFile.deserialize(reader)
+                result = InitInitServerPacket.ReplyCodeDataMapMutation(map_file=map_file)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -1112,7 +1151,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.PlayersList
         """
         _byte_size: int = 0
-        _players_list: PlayersList = None # type: ignore [assignment]
+        _players_list: PlayersList
+
+        def __init__(self, *, players_list: PlayersList):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataPlayersList.
+
+            Args:
+                players_list (PlayersList): 
+            """
+            self._players_list = players_list
 
         @property
         def byte_size(self) -> int:
@@ -1128,10 +1176,6 @@ class InitInitServerPacket(Packet):
         def players_list(self) -> PlayersList:
             return self._players_list
 
-        @players_list.setter
-        def players_list(self, players_list: PlayersList) -> None:
-            self._players_list = players_list
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataPlayersList") -> None:
             """
@@ -1141,9 +1185,15 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataPlayersList): The data to serialize.
             """
-            if data._players_list is None:
-                raise SerializationError("players_list must be provided.")
-            PlayersList.serialize(writer, data._players_list)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.string_sanitization_mode = True
+                if data._players_list is None:
+                    raise SerializationError("players_list must be provided.")
+                PlayersList.serialize(writer, data._players_list)
+                writer.string_sanitization_mode = False
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataPlayersList":
@@ -1156,15 +1206,15 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataPlayersList: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataPlayersList = InitInitServerPacket.ReplyCodeDataPlayersList()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.chunked_reading_mode = True
-                data._players_list = PlayersList.deserialize(reader)
+                players_list = PlayersList.deserialize(reader)
                 reader.chunked_reading_mode = False
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = InitInitServerPacket.ReplyCodeDataPlayersList(players_list=players_list)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode
 
@@ -1176,7 +1226,16 @@ class InitInitServerPacket(Packet):
         Data associated with reply_code value InitReply.PlayersListFriends
         """
         _byte_size: int = 0
-        _players_list: PlayersListFriends = None # type: ignore [assignment]
+        _players_list: PlayersListFriends
+
+        def __init__(self, *, players_list: PlayersListFriends):
+            """
+            Create a new instance of InitInitServerPacket.ReplyCodeDataPlayersListFriends.
+
+            Args:
+                players_list (PlayersListFriends): 
+            """
+            self._players_list = players_list
 
         @property
         def byte_size(self) -> int:
@@ -1192,10 +1251,6 @@ class InitInitServerPacket(Packet):
         def players_list(self) -> PlayersListFriends:
             return self._players_list
 
-        @players_list.setter
-        def players_list(self, players_list: PlayersListFriends) -> None:
-            self._players_list = players_list
-
         @staticmethod
         def serialize(writer: EoWriter, data: "InitInitServerPacket.ReplyCodeDataPlayersListFriends") -> None:
             """
@@ -1205,9 +1260,15 @@ class InitInitServerPacket(Packet):
                 writer (EoWriter): The writer that the data will be serialized to.
                 data (InitInitServerPacket.ReplyCodeDataPlayersListFriends): The data to serialize.
             """
-            if data._players_list is None:
-                raise SerializationError("players_list must be provided.")
-            PlayersListFriends.serialize(writer, data._players_list)
+            old_string_sanitization_mode: bool = writer.string_sanitization_mode
+            try:
+                writer.string_sanitization_mode = True
+                if data._players_list is None:
+                    raise SerializationError("players_list must be provided.")
+                PlayersListFriends.serialize(writer, data._players_list)
+                writer.string_sanitization_mode = False
+            finally:
+                writer.string_sanitization_mode = old_string_sanitization_mode
 
         @staticmethod
         def deserialize(reader: EoReader) -> "InitInitServerPacket.ReplyCodeDataPlayersListFriends":
@@ -1220,15 +1281,15 @@ class InitInitServerPacket(Packet):
             Returns:
                 InitInitServerPacket.ReplyCodeDataPlayersListFriends: The data to serialize.
             """
-            data: InitInitServerPacket.ReplyCodeDataPlayersListFriends = InitInitServerPacket.ReplyCodeDataPlayersListFriends()
             old_chunked_reading_mode: bool = reader.chunked_reading_mode
             try:
                 reader_start_position: int = reader.position
                 reader.chunked_reading_mode = True
-                data._players_list = PlayersListFriends.deserialize(reader)
+                players_list = PlayersListFriends.deserialize(reader)
                 reader.chunked_reading_mode = False
-                data._byte_size = reader.position - reader_start_position
-                return data
+                result = InitInitServerPacket.ReplyCodeDataPlayersListFriends(players_list=players_list)
+                result._byte_size = reader.position - reader_start_position
+                return result
             finally:
                 reader.chunked_reading_mode = old_chunked_reading_mode